eigenlayer_contract_deployer/bindings/core/
i_service_manager.rs

1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use IServiceManager::*;
3
4///Module containing a contract's types and functions.
5/**
6
7```solidity
8library IRewardsCoordinatorTypes {
9    struct RewardsSubmission { StrategyAndMultiplier[] strategiesAndMultipliers; address token; uint256 amount; uint32 startTimestamp; uint32 duration; }
10    struct StrategyAndMultiplier { address strategy; uint96 multiplier; }
11}
12```*/
13#[allow(
14    non_camel_case_types,
15    non_snake_case,
16    clippy::pub_underscore_fields,
17    clippy::style,
18    clippy::empty_structs_with_brackets
19)]
20pub mod IRewardsCoordinatorTypes {
21    use super::*;
22    use alloy::sol_types as alloy_sol_types;
23    #[derive(serde::Serialize, serde::Deserialize)]
24    #[derive(Default, Debug, PartialEq, Eq, Hash)]
25    /**```solidity
26struct RewardsSubmission { StrategyAndMultiplier[] strategiesAndMultipliers; address token; uint256 amount; uint32 startTimestamp; uint32 duration; }
27```*/
28    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
29    #[derive(Clone)]
30    pub struct RewardsSubmission {
31        #[allow(missing_docs)]
32        pub strategiesAndMultipliers: alloy::sol_types::private::Vec<
33            <StrategyAndMultiplier as alloy::sol_types::SolType>::RustType,
34        >,
35        #[allow(missing_docs)]
36        pub token: alloy::sol_types::private::Address,
37        #[allow(missing_docs)]
38        pub amount: alloy::sol_types::private::primitives::aliases::U256,
39        #[allow(missing_docs)]
40        pub startTimestamp: u32,
41        #[allow(missing_docs)]
42        pub duration: u32,
43    }
44    #[allow(
45        non_camel_case_types,
46        non_snake_case,
47        clippy::pub_underscore_fields,
48        clippy::style
49    )]
50    const _: () = {
51        use alloy::sol_types as alloy_sol_types;
52        #[doc(hidden)]
53        type UnderlyingSolTuple<'a> = (
54            alloy::sol_types::sol_data::Array<StrategyAndMultiplier>,
55            alloy::sol_types::sol_data::Address,
56            alloy::sol_types::sol_data::Uint<256>,
57            alloy::sol_types::sol_data::Uint<32>,
58            alloy::sol_types::sol_data::Uint<32>,
59        );
60        #[doc(hidden)]
61        type UnderlyingRustTuple<'a> = (
62            alloy::sol_types::private::Vec<
63                <StrategyAndMultiplier as alloy::sol_types::SolType>::RustType,
64            >,
65            alloy::sol_types::private::Address,
66            alloy::sol_types::private::primitives::aliases::U256,
67            u32,
68            u32,
69        );
70        #[cfg(test)]
71        #[allow(dead_code, unreachable_patterns)]
72        fn _type_assertion(
73            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
74        ) {
75            match _t {
76                alloy_sol_types::private::AssertTypeEq::<
77                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
78                >(_) => {}
79            }
80        }
81        #[automatically_derived]
82        #[doc(hidden)]
83        impl ::core::convert::From<RewardsSubmission> for UnderlyingRustTuple<'_> {
84            fn from(value: RewardsSubmission) -> Self {
85                (
86                    value.strategiesAndMultipliers,
87                    value.token,
88                    value.amount,
89                    value.startTimestamp,
90                    value.duration,
91                )
92            }
93        }
94        #[automatically_derived]
95        #[doc(hidden)]
96        impl ::core::convert::From<UnderlyingRustTuple<'_>> for RewardsSubmission {
97            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
98                Self {
99                    strategiesAndMultipliers: tuple.0,
100                    token: tuple.1,
101                    amount: tuple.2,
102                    startTimestamp: tuple.3,
103                    duration: tuple.4,
104                }
105            }
106        }
107        #[automatically_derived]
108        impl alloy_sol_types::SolValue for RewardsSubmission {
109            type SolType = Self;
110        }
111        #[automatically_derived]
112        impl alloy_sol_types::private::SolTypeValue<Self> for RewardsSubmission {
113            #[inline]
114            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
115                (
116                    <alloy::sol_types::sol_data::Array<
117                        StrategyAndMultiplier,
118                    > as alloy_sol_types::SolType>::tokenize(
119                        &self.strategiesAndMultipliers,
120                    ),
121                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
122                        &self.token,
123                    ),
124                    <alloy::sol_types::sol_data::Uint<
125                        256,
126                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
127                    <alloy::sol_types::sol_data::Uint<
128                        32,
129                    > as alloy_sol_types::SolType>::tokenize(&self.startTimestamp),
130                    <alloy::sol_types::sol_data::Uint<
131                        32,
132                    > as alloy_sol_types::SolType>::tokenize(&self.duration),
133                )
134            }
135            #[inline]
136            fn stv_abi_encoded_size(&self) -> usize {
137                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
138                    return size;
139                }
140                let tuple = <UnderlyingRustTuple<
141                    '_,
142                > as ::core::convert::From<Self>>::from(self.clone());
143                <UnderlyingSolTuple<
144                    '_,
145                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
146            }
147            #[inline]
148            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
149                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
150            }
151            #[inline]
152            fn stv_abi_encode_packed_to(
153                &self,
154                out: &mut alloy_sol_types::private::Vec<u8>,
155            ) {
156                let tuple = <UnderlyingRustTuple<
157                    '_,
158                > as ::core::convert::From<Self>>::from(self.clone());
159                <UnderlyingSolTuple<
160                    '_,
161                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
162            }
163            #[inline]
164            fn stv_abi_packed_encoded_size(&self) -> usize {
165                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
166                    return size;
167                }
168                let tuple = <UnderlyingRustTuple<
169                    '_,
170                > as ::core::convert::From<Self>>::from(self.clone());
171                <UnderlyingSolTuple<
172                    '_,
173                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
174            }
175        }
176        #[automatically_derived]
177        impl alloy_sol_types::SolType for RewardsSubmission {
178            type RustType = Self;
179            type Token<'a> = <UnderlyingSolTuple<
180                'a,
181            > as alloy_sol_types::SolType>::Token<'a>;
182            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
183            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
184                '_,
185            > as alloy_sol_types::SolType>::ENCODED_SIZE;
186            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
187                '_,
188            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
189            #[inline]
190            fn valid_token(token: &Self::Token<'_>) -> bool {
191                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
192            }
193            #[inline]
194            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
195                let tuple = <UnderlyingSolTuple<
196                    '_,
197                > as alloy_sol_types::SolType>::detokenize(token);
198                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
199            }
200        }
201        #[automatically_derived]
202        impl alloy_sol_types::SolStruct for RewardsSubmission {
203            const NAME: &'static str = "RewardsSubmission";
204            #[inline]
205            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
206                alloy_sol_types::private::Cow::Borrowed(
207                    "RewardsSubmission(StrategyAndMultiplier[] strategiesAndMultipliers,address token,uint256 amount,uint32 startTimestamp,uint32 duration)",
208                )
209            }
210            #[inline]
211            fn eip712_components() -> alloy_sol_types::private::Vec<
212                alloy_sol_types::private::Cow<'static, str>,
213            > {
214                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
215                components
216                    .push(
217                        <StrategyAndMultiplier as alloy_sol_types::SolStruct>::eip712_root_type(),
218                    );
219                components
220                    .extend(
221                        <StrategyAndMultiplier as alloy_sol_types::SolStruct>::eip712_components(),
222                    );
223                components
224            }
225            #[inline]
226            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
227                [
228                    <alloy::sol_types::sol_data::Array<
229                        StrategyAndMultiplier,
230                    > as alloy_sol_types::SolType>::eip712_data_word(
231                            &self.strategiesAndMultipliers,
232                        )
233                        .0,
234                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
235                            &self.token,
236                        )
237                        .0,
238                    <alloy::sol_types::sol_data::Uint<
239                        256,
240                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
241                        .0,
242                    <alloy::sol_types::sol_data::Uint<
243                        32,
244                    > as alloy_sol_types::SolType>::eip712_data_word(
245                            &self.startTimestamp,
246                        )
247                        .0,
248                    <alloy::sol_types::sol_data::Uint<
249                        32,
250                    > as alloy_sol_types::SolType>::eip712_data_word(&self.duration)
251                        .0,
252                ]
253                    .concat()
254            }
255        }
256        #[automatically_derived]
257        impl alloy_sol_types::EventTopic for RewardsSubmission {
258            #[inline]
259            fn topic_preimage_length(rust: &Self::RustType) -> usize {
260                0usize
261                    + <alloy::sol_types::sol_data::Array<
262                        StrategyAndMultiplier,
263                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
264                        &rust.strategiesAndMultipliers,
265                    )
266                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
267                        &rust.token,
268                    )
269                    + <alloy::sol_types::sol_data::Uint<
270                        256,
271                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
272                        &rust.amount,
273                    )
274                    + <alloy::sol_types::sol_data::Uint<
275                        32,
276                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
277                        &rust.startTimestamp,
278                    )
279                    + <alloy::sol_types::sol_data::Uint<
280                        32,
281                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
282                        &rust.duration,
283                    )
284            }
285            #[inline]
286            fn encode_topic_preimage(
287                rust: &Self::RustType,
288                out: &mut alloy_sol_types::private::Vec<u8>,
289            ) {
290                out.reserve(
291                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
292                );
293                <alloy::sol_types::sol_data::Array<
294                    StrategyAndMultiplier,
295                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
296                    &rust.strategiesAndMultipliers,
297                    out,
298                );
299                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
300                    &rust.token,
301                    out,
302                );
303                <alloy::sol_types::sol_data::Uint<
304                    256,
305                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
306                    &rust.amount,
307                    out,
308                );
309                <alloy::sol_types::sol_data::Uint<
310                    32,
311                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
312                    &rust.startTimestamp,
313                    out,
314                );
315                <alloy::sol_types::sol_data::Uint<
316                    32,
317                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
318                    &rust.duration,
319                    out,
320                );
321            }
322            #[inline]
323            fn encode_topic(
324                rust: &Self::RustType,
325            ) -> alloy_sol_types::abi::token::WordToken {
326                let mut out = alloy_sol_types::private::Vec::new();
327                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
328                    rust,
329                    &mut out,
330                );
331                alloy_sol_types::abi::token::WordToken(
332                    alloy_sol_types::private::keccak256(out),
333                )
334            }
335        }
336    };
337    #[derive(serde::Serialize, serde::Deserialize)]
338    #[derive(Default, Debug, PartialEq, Eq, Hash)]
339    /**```solidity
340struct StrategyAndMultiplier { address strategy; uint96 multiplier; }
341```*/
342    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
343    #[derive(Clone)]
344    pub struct StrategyAndMultiplier {
345        #[allow(missing_docs)]
346        pub strategy: alloy::sol_types::private::Address,
347        #[allow(missing_docs)]
348        pub multiplier: alloy::sol_types::private::primitives::aliases::U96,
349    }
350    #[allow(
351        non_camel_case_types,
352        non_snake_case,
353        clippy::pub_underscore_fields,
354        clippy::style
355    )]
356    const _: () = {
357        use alloy::sol_types as alloy_sol_types;
358        #[doc(hidden)]
359        type UnderlyingSolTuple<'a> = (
360            alloy::sol_types::sol_data::Address,
361            alloy::sol_types::sol_data::Uint<96>,
362        );
363        #[doc(hidden)]
364        type UnderlyingRustTuple<'a> = (
365            alloy::sol_types::private::Address,
366            alloy::sol_types::private::primitives::aliases::U96,
367        );
368        #[cfg(test)]
369        #[allow(dead_code, unreachable_patterns)]
370        fn _type_assertion(
371            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
372        ) {
373            match _t {
374                alloy_sol_types::private::AssertTypeEq::<
375                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
376                >(_) => {}
377            }
378        }
379        #[automatically_derived]
380        #[doc(hidden)]
381        impl ::core::convert::From<StrategyAndMultiplier> for UnderlyingRustTuple<'_> {
382            fn from(value: StrategyAndMultiplier) -> Self {
383                (value.strategy, value.multiplier)
384            }
385        }
386        #[automatically_derived]
387        #[doc(hidden)]
388        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StrategyAndMultiplier {
389            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
390                Self {
391                    strategy: tuple.0,
392                    multiplier: tuple.1,
393                }
394            }
395        }
396        #[automatically_derived]
397        impl alloy_sol_types::SolValue for StrategyAndMultiplier {
398            type SolType = Self;
399        }
400        #[automatically_derived]
401        impl alloy_sol_types::private::SolTypeValue<Self> for StrategyAndMultiplier {
402            #[inline]
403            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
404                (
405                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
406                        &self.strategy,
407                    ),
408                    <alloy::sol_types::sol_data::Uint<
409                        96,
410                    > as alloy_sol_types::SolType>::tokenize(&self.multiplier),
411                )
412            }
413            #[inline]
414            fn stv_abi_encoded_size(&self) -> usize {
415                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
416                    return size;
417                }
418                let tuple = <UnderlyingRustTuple<
419                    '_,
420                > as ::core::convert::From<Self>>::from(self.clone());
421                <UnderlyingSolTuple<
422                    '_,
423                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
424            }
425            #[inline]
426            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
427                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
428            }
429            #[inline]
430            fn stv_abi_encode_packed_to(
431                &self,
432                out: &mut alloy_sol_types::private::Vec<u8>,
433            ) {
434                let tuple = <UnderlyingRustTuple<
435                    '_,
436                > as ::core::convert::From<Self>>::from(self.clone());
437                <UnderlyingSolTuple<
438                    '_,
439                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
440            }
441            #[inline]
442            fn stv_abi_packed_encoded_size(&self) -> usize {
443                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
444                    return size;
445                }
446                let tuple = <UnderlyingRustTuple<
447                    '_,
448                > as ::core::convert::From<Self>>::from(self.clone());
449                <UnderlyingSolTuple<
450                    '_,
451                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
452            }
453        }
454        #[automatically_derived]
455        impl alloy_sol_types::SolType for StrategyAndMultiplier {
456            type RustType = Self;
457            type Token<'a> = <UnderlyingSolTuple<
458                'a,
459            > as alloy_sol_types::SolType>::Token<'a>;
460            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
461            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
462                '_,
463            > as alloy_sol_types::SolType>::ENCODED_SIZE;
464            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
465                '_,
466            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
467            #[inline]
468            fn valid_token(token: &Self::Token<'_>) -> bool {
469                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
470            }
471            #[inline]
472            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
473                let tuple = <UnderlyingSolTuple<
474                    '_,
475                > as alloy_sol_types::SolType>::detokenize(token);
476                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
477            }
478        }
479        #[automatically_derived]
480        impl alloy_sol_types::SolStruct for StrategyAndMultiplier {
481            const NAME: &'static str = "StrategyAndMultiplier";
482            #[inline]
483            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
484                alloy_sol_types::private::Cow::Borrowed(
485                    "StrategyAndMultiplier(address strategy,uint96 multiplier)",
486                )
487            }
488            #[inline]
489            fn eip712_components() -> alloy_sol_types::private::Vec<
490                alloy_sol_types::private::Cow<'static, str>,
491            > {
492                alloy_sol_types::private::Vec::new()
493            }
494            #[inline]
495            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
496                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
497            }
498            #[inline]
499            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
500                [
501                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
502                            &self.strategy,
503                        )
504                        .0,
505                    <alloy::sol_types::sol_data::Uint<
506                        96,
507                    > as alloy_sol_types::SolType>::eip712_data_word(&self.multiplier)
508                        .0,
509                ]
510                    .concat()
511            }
512        }
513        #[automatically_derived]
514        impl alloy_sol_types::EventTopic for StrategyAndMultiplier {
515            #[inline]
516            fn topic_preimage_length(rust: &Self::RustType) -> usize {
517                0usize
518                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
519                        &rust.strategy,
520                    )
521                    + <alloy::sol_types::sol_data::Uint<
522                        96,
523                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
524                        &rust.multiplier,
525                    )
526            }
527            #[inline]
528            fn encode_topic_preimage(
529                rust: &Self::RustType,
530                out: &mut alloy_sol_types::private::Vec<u8>,
531            ) {
532                out.reserve(
533                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
534                );
535                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
536                    &rust.strategy,
537                    out,
538                );
539                <alloy::sol_types::sol_data::Uint<
540                    96,
541                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
542                    &rust.multiplier,
543                    out,
544                );
545            }
546            #[inline]
547            fn encode_topic(
548                rust: &Self::RustType,
549            ) -> alloy_sol_types::abi::token::WordToken {
550                let mut out = alloy_sol_types::private::Vec::new();
551                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
552                    rust,
553                    &mut out,
554                );
555                alloy_sol_types::abi::token::WordToken(
556                    alloy_sol_types::private::keccak256(out),
557                )
558            }
559        }
560    };
561    use alloy::contract as alloy_contract;
562    /**Creates a new wrapper around an on-chain [`IRewardsCoordinatorTypes`](self) contract instance.
563
564See the [wrapper's documentation](`IRewardsCoordinatorTypesInstance`) for more details.*/
565    #[inline]
566    pub const fn new<
567        P: alloy_contract::private::Provider<N>,
568        N: alloy_contract::private::Network,
569    >(
570        address: alloy_sol_types::private::Address,
571        provider: P,
572    ) -> IRewardsCoordinatorTypesInstance<P, N> {
573        IRewardsCoordinatorTypesInstance::<P, N>::new(address, provider)
574    }
575    /**A [`IRewardsCoordinatorTypes`](self) instance.
576
577Contains type-safe methods for interacting with an on-chain instance of the
578[`IRewardsCoordinatorTypes`](self) contract located at a given `address`, using a given
579provider `P`.
580
581If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
582documentation on how to provide it), the `deploy` and `deploy_builder` methods can
583be used to deploy a new instance of the contract.
584
585See the [module-level documentation](self) for all the available methods.*/
586    #[derive(Clone)]
587    pub struct IRewardsCoordinatorTypesInstance<
588        P,
589        N = alloy_contract::private::Ethereum,
590    > {
591        address: alloy_sol_types::private::Address,
592        provider: P,
593        _network: ::core::marker::PhantomData<N>,
594    }
595    #[automatically_derived]
596    impl<P, N> ::core::fmt::Debug for IRewardsCoordinatorTypesInstance<P, N> {
597        #[inline]
598        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
599            f.debug_tuple("IRewardsCoordinatorTypesInstance")
600                .field(&self.address)
601                .finish()
602        }
603    }
604    /// Instantiation and getters/setters.
605    #[automatically_derived]
606    impl<
607        P: alloy_contract::private::Provider<N>,
608        N: alloy_contract::private::Network,
609    > IRewardsCoordinatorTypesInstance<P, N> {
610        /**Creates a new wrapper around an on-chain [`IRewardsCoordinatorTypes`](self) contract instance.
611
612See the [wrapper's documentation](`IRewardsCoordinatorTypesInstance`) for more details.*/
613        #[inline]
614        pub const fn new(
615            address: alloy_sol_types::private::Address,
616            provider: P,
617        ) -> Self {
618            Self {
619                address,
620                provider,
621                _network: ::core::marker::PhantomData,
622            }
623        }
624        /// Returns a reference to the address.
625        #[inline]
626        pub const fn address(&self) -> &alloy_sol_types::private::Address {
627            &self.address
628        }
629        /// Sets the address.
630        #[inline]
631        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
632            self.address = address;
633        }
634        /// Sets the address and returns `self`.
635        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
636            self.set_address(address);
637            self
638        }
639        /// Returns a reference to the provider.
640        #[inline]
641        pub const fn provider(&self) -> &P {
642            &self.provider
643        }
644    }
645    impl<P: ::core::clone::Clone, N> IRewardsCoordinatorTypesInstance<&P, N> {
646        /// Clones the provider and returns a new instance with the cloned provider.
647        #[inline]
648        pub fn with_cloned_provider(self) -> IRewardsCoordinatorTypesInstance<P, N> {
649            IRewardsCoordinatorTypesInstance {
650                address: self.address,
651                provider: ::core::clone::Clone::clone(&self.provider),
652                _network: ::core::marker::PhantomData,
653            }
654        }
655    }
656    /// Function calls.
657    #[automatically_derived]
658    impl<
659        P: alloy_contract::private::Provider<N>,
660        N: alloy_contract::private::Network,
661    > IRewardsCoordinatorTypesInstance<P, N> {
662        /// Creates a new call builder using this contract instance's provider and address.
663        ///
664        /// Note that the call can be any function call, not just those defined in this
665        /// contract. Prefer using the other methods for building type-safe contract calls.
666        pub fn call_builder<C: alloy_sol_types::SolCall>(
667            &self,
668            call: &C,
669        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
670            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
671        }
672    }
673    /// Event filters.
674    #[automatically_derived]
675    impl<
676        P: alloy_contract::private::Provider<N>,
677        N: alloy_contract::private::Network,
678    > IRewardsCoordinatorTypesInstance<P, N> {
679        /// Creates a new event filter using this contract instance's provider and address.
680        ///
681        /// Note that the type can be any event, not just those defined in this contract.
682        /// Prefer using the other methods for building type-safe event filters.
683        pub fn event_filter<E: alloy_sol_types::SolEvent>(
684            &self,
685        ) -> alloy_contract::Event<&P, E, N> {
686            alloy_contract::Event::new_sol(&self.provider, &self.address)
687        }
688    }
689}
690///Module containing a contract's types and functions.
691/**
692
693```solidity
694library ISignatureUtilsMixinTypes {
695    struct SignatureWithSaltAndExpiry { bytes signature; bytes32 salt; uint256 expiry; }
696}
697```*/
698#[allow(
699    non_camel_case_types,
700    non_snake_case,
701    clippy::pub_underscore_fields,
702    clippy::style,
703    clippy::empty_structs_with_brackets
704)]
705pub mod ISignatureUtilsMixinTypes {
706    use super::*;
707    use alloy::sol_types as alloy_sol_types;
708    #[derive(serde::Serialize, serde::Deserialize)]
709    #[derive(Default, Debug, PartialEq, Eq, Hash)]
710    /**```solidity
711struct SignatureWithSaltAndExpiry { bytes signature; bytes32 salt; uint256 expiry; }
712```*/
713    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
714    #[derive(Clone)]
715    pub struct SignatureWithSaltAndExpiry {
716        #[allow(missing_docs)]
717        pub signature: alloy::sol_types::private::Bytes,
718        #[allow(missing_docs)]
719        pub salt: alloy::sol_types::private::FixedBytes<32>,
720        #[allow(missing_docs)]
721        pub expiry: alloy::sol_types::private::primitives::aliases::U256,
722    }
723    #[allow(
724        non_camel_case_types,
725        non_snake_case,
726        clippy::pub_underscore_fields,
727        clippy::style
728    )]
729    const _: () = {
730        use alloy::sol_types as alloy_sol_types;
731        #[doc(hidden)]
732        type UnderlyingSolTuple<'a> = (
733            alloy::sol_types::sol_data::Bytes,
734            alloy::sol_types::sol_data::FixedBytes<32>,
735            alloy::sol_types::sol_data::Uint<256>,
736        );
737        #[doc(hidden)]
738        type UnderlyingRustTuple<'a> = (
739            alloy::sol_types::private::Bytes,
740            alloy::sol_types::private::FixedBytes<32>,
741            alloy::sol_types::private::primitives::aliases::U256,
742        );
743        #[cfg(test)]
744        #[allow(dead_code, unreachable_patterns)]
745        fn _type_assertion(
746            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
747        ) {
748            match _t {
749                alloy_sol_types::private::AssertTypeEq::<
750                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
751                >(_) => {}
752            }
753        }
754        #[automatically_derived]
755        #[doc(hidden)]
756        impl ::core::convert::From<SignatureWithSaltAndExpiry>
757        for UnderlyingRustTuple<'_> {
758            fn from(value: SignatureWithSaltAndExpiry) -> Self {
759                (value.signature, value.salt, value.expiry)
760            }
761        }
762        #[automatically_derived]
763        #[doc(hidden)]
764        impl ::core::convert::From<UnderlyingRustTuple<'_>>
765        for SignatureWithSaltAndExpiry {
766            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
767                Self {
768                    signature: tuple.0,
769                    salt: tuple.1,
770                    expiry: tuple.2,
771                }
772            }
773        }
774        #[automatically_derived]
775        impl alloy_sol_types::SolValue for SignatureWithSaltAndExpiry {
776            type SolType = Self;
777        }
778        #[automatically_derived]
779        impl alloy_sol_types::private::SolTypeValue<Self>
780        for SignatureWithSaltAndExpiry {
781            #[inline]
782            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
783                (
784                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
785                        &self.signature,
786                    ),
787                    <alloy::sol_types::sol_data::FixedBytes<
788                        32,
789                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
790                    <alloy::sol_types::sol_data::Uint<
791                        256,
792                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
793                )
794            }
795            #[inline]
796            fn stv_abi_encoded_size(&self) -> usize {
797                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
798                    return size;
799                }
800                let tuple = <UnderlyingRustTuple<
801                    '_,
802                > as ::core::convert::From<Self>>::from(self.clone());
803                <UnderlyingSolTuple<
804                    '_,
805                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
806            }
807            #[inline]
808            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
809                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
810            }
811            #[inline]
812            fn stv_abi_encode_packed_to(
813                &self,
814                out: &mut alloy_sol_types::private::Vec<u8>,
815            ) {
816                let tuple = <UnderlyingRustTuple<
817                    '_,
818                > as ::core::convert::From<Self>>::from(self.clone());
819                <UnderlyingSolTuple<
820                    '_,
821                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
822            }
823            #[inline]
824            fn stv_abi_packed_encoded_size(&self) -> usize {
825                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
826                    return size;
827                }
828                let tuple = <UnderlyingRustTuple<
829                    '_,
830                > as ::core::convert::From<Self>>::from(self.clone());
831                <UnderlyingSolTuple<
832                    '_,
833                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
834            }
835        }
836        #[automatically_derived]
837        impl alloy_sol_types::SolType for SignatureWithSaltAndExpiry {
838            type RustType = Self;
839            type Token<'a> = <UnderlyingSolTuple<
840                'a,
841            > as alloy_sol_types::SolType>::Token<'a>;
842            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
843            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
844                '_,
845            > as alloy_sol_types::SolType>::ENCODED_SIZE;
846            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
847                '_,
848            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
849            #[inline]
850            fn valid_token(token: &Self::Token<'_>) -> bool {
851                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
852            }
853            #[inline]
854            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
855                let tuple = <UnderlyingSolTuple<
856                    '_,
857                > as alloy_sol_types::SolType>::detokenize(token);
858                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
859            }
860        }
861        #[automatically_derived]
862        impl alloy_sol_types::SolStruct for SignatureWithSaltAndExpiry {
863            const NAME: &'static str = "SignatureWithSaltAndExpiry";
864            #[inline]
865            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
866                alloy_sol_types::private::Cow::Borrowed(
867                    "SignatureWithSaltAndExpiry(bytes signature,bytes32 salt,uint256 expiry)",
868                )
869            }
870            #[inline]
871            fn eip712_components() -> alloy_sol_types::private::Vec<
872                alloy_sol_types::private::Cow<'static, str>,
873            > {
874                alloy_sol_types::private::Vec::new()
875            }
876            #[inline]
877            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
878                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
879            }
880            #[inline]
881            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
882                [
883                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
884                            &self.signature,
885                        )
886                        .0,
887                    <alloy::sol_types::sol_data::FixedBytes<
888                        32,
889                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
890                        .0,
891                    <alloy::sol_types::sol_data::Uint<
892                        256,
893                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
894                        .0,
895                ]
896                    .concat()
897            }
898        }
899        #[automatically_derived]
900        impl alloy_sol_types::EventTopic for SignatureWithSaltAndExpiry {
901            #[inline]
902            fn topic_preimage_length(rust: &Self::RustType) -> usize {
903                0usize
904                    + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
905                        &rust.signature,
906                    )
907                    + <alloy::sol_types::sol_data::FixedBytes<
908                        32,
909                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
910                    + <alloy::sol_types::sol_data::Uint<
911                        256,
912                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
913                        &rust.expiry,
914                    )
915            }
916            #[inline]
917            fn encode_topic_preimage(
918                rust: &Self::RustType,
919                out: &mut alloy_sol_types::private::Vec<u8>,
920            ) {
921                out.reserve(
922                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
923                );
924                <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
925                    &rust.signature,
926                    out,
927                );
928                <alloy::sol_types::sol_data::FixedBytes<
929                    32,
930                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
931                    &rust.salt,
932                    out,
933                );
934                <alloy::sol_types::sol_data::Uint<
935                    256,
936                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
937                    &rust.expiry,
938                    out,
939                );
940            }
941            #[inline]
942            fn encode_topic(
943                rust: &Self::RustType,
944            ) -> alloy_sol_types::abi::token::WordToken {
945                let mut out = alloy_sol_types::private::Vec::new();
946                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
947                    rust,
948                    &mut out,
949                );
950                alloy_sol_types::abi::token::WordToken(
951                    alloy_sol_types::private::keccak256(out),
952                )
953            }
954        }
955    };
956    use alloy::contract as alloy_contract;
957    /**Creates a new wrapper around an on-chain [`ISignatureUtilsMixinTypes`](self) contract instance.
958
959See the [wrapper's documentation](`ISignatureUtilsMixinTypesInstance`) for more details.*/
960    #[inline]
961    pub const fn new<
962        P: alloy_contract::private::Provider<N>,
963        N: alloy_contract::private::Network,
964    >(
965        address: alloy_sol_types::private::Address,
966        provider: P,
967    ) -> ISignatureUtilsMixinTypesInstance<P, N> {
968        ISignatureUtilsMixinTypesInstance::<P, N>::new(address, provider)
969    }
970    /**A [`ISignatureUtilsMixinTypes`](self) instance.
971
972Contains type-safe methods for interacting with an on-chain instance of the
973[`ISignatureUtilsMixinTypes`](self) contract located at a given `address`, using a given
974provider `P`.
975
976If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
977documentation on how to provide it), the `deploy` and `deploy_builder` methods can
978be used to deploy a new instance of the contract.
979
980See the [module-level documentation](self) for all the available methods.*/
981    #[derive(Clone)]
982    pub struct ISignatureUtilsMixinTypesInstance<
983        P,
984        N = alloy_contract::private::Ethereum,
985    > {
986        address: alloy_sol_types::private::Address,
987        provider: P,
988        _network: ::core::marker::PhantomData<N>,
989    }
990    #[automatically_derived]
991    impl<P, N> ::core::fmt::Debug for ISignatureUtilsMixinTypesInstance<P, N> {
992        #[inline]
993        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
994            f.debug_tuple("ISignatureUtilsMixinTypesInstance")
995                .field(&self.address)
996                .finish()
997        }
998    }
999    /// Instantiation and getters/setters.
1000    #[automatically_derived]
1001    impl<
1002        P: alloy_contract::private::Provider<N>,
1003        N: alloy_contract::private::Network,
1004    > ISignatureUtilsMixinTypesInstance<P, N> {
1005        /**Creates a new wrapper around an on-chain [`ISignatureUtilsMixinTypes`](self) contract instance.
1006
1007See the [wrapper's documentation](`ISignatureUtilsMixinTypesInstance`) for more details.*/
1008        #[inline]
1009        pub const fn new(
1010            address: alloy_sol_types::private::Address,
1011            provider: P,
1012        ) -> Self {
1013            Self {
1014                address,
1015                provider,
1016                _network: ::core::marker::PhantomData,
1017            }
1018        }
1019        /// Returns a reference to the address.
1020        #[inline]
1021        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1022            &self.address
1023        }
1024        /// Sets the address.
1025        #[inline]
1026        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1027            self.address = address;
1028        }
1029        /// Sets the address and returns `self`.
1030        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1031            self.set_address(address);
1032            self
1033        }
1034        /// Returns a reference to the provider.
1035        #[inline]
1036        pub const fn provider(&self) -> &P {
1037            &self.provider
1038        }
1039    }
1040    impl<P: ::core::clone::Clone, N> ISignatureUtilsMixinTypesInstance<&P, N> {
1041        /// Clones the provider and returns a new instance with the cloned provider.
1042        #[inline]
1043        pub fn with_cloned_provider(self) -> ISignatureUtilsMixinTypesInstance<P, N> {
1044            ISignatureUtilsMixinTypesInstance {
1045                address: self.address,
1046                provider: ::core::clone::Clone::clone(&self.provider),
1047                _network: ::core::marker::PhantomData,
1048            }
1049        }
1050    }
1051    /// Function calls.
1052    #[automatically_derived]
1053    impl<
1054        P: alloy_contract::private::Provider<N>,
1055        N: alloy_contract::private::Network,
1056    > ISignatureUtilsMixinTypesInstance<P, N> {
1057        /// Creates a new call builder using this contract instance's provider and address.
1058        ///
1059        /// Note that the call can be any function call, not just those defined in this
1060        /// contract. Prefer using the other methods for building type-safe contract calls.
1061        pub fn call_builder<C: alloy_sol_types::SolCall>(
1062            &self,
1063            call: &C,
1064        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1065            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1066        }
1067    }
1068    /// Event filters.
1069    #[automatically_derived]
1070    impl<
1071        P: alloy_contract::private::Provider<N>,
1072        N: alloy_contract::private::Network,
1073    > ISignatureUtilsMixinTypesInstance<P, N> {
1074        /// Creates a new event filter using this contract instance's provider and address.
1075        ///
1076        /// Note that the type can be any event, not just those defined in this contract.
1077        /// Prefer using the other methods for building type-safe event filters.
1078        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1079            &self,
1080        ) -> alloy_contract::Event<&P, E, N> {
1081            alloy_contract::Event::new_sol(&self.provider, &self.address)
1082        }
1083    }
1084}
1085/**
1086
1087Generated by the following Solidity interface...
1088```solidity
1089library IRewardsCoordinatorTypes {
1090    struct RewardsSubmission {
1091        StrategyAndMultiplier[] strategiesAndMultipliers;
1092        address token;
1093        uint256 amount;
1094        uint32 startTimestamp;
1095        uint32 duration;
1096    }
1097    struct StrategyAndMultiplier {
1098        address strategy;
1099        uint96 multiplier;
1100    }
1101}
1102
1103library ISignatureUtilsMixinTypes {
1104    struct SignatureWithSaltAndExpiry {
1105        bytes signature;
1106        bytes32 salt;
1107        uint256 expiry;
1108    }
1109}
1110
1111interface IServiceManager {
1112    error DelayPeriodNotPassed();
1113    error OnlyRegistryCoordinator();
1114    error OnlyRewardsInitiator();
1115    error OnlyStakeRegistry();
1116
1117    event RewardsInitiatorUpdated(address prevRewardsInitiator, address newRewardsInitiator);
1118
1119    function addPendingAdmin(address admin) external;
1120    function avsDirectory() external view returns (address);
1121    function createAVSRewardsSubmission(IRewardsCoordinatorTypes.RewardsSubmission[] memory rewardsSubmissions) external;
1122    function deregisterOperatorFromAVS(address operator) external;
1123    function deregisterOperatorFromOperatorSets(address operator, uint32[] memory operatorSetIds) external;
1124    function getOperatorRestakedStrategies(address operator) external view returns (address[] memory);
1125    function getRestakeableStrategies() external view returns (address[] memory);
1126    function registerOperatorToAVS(address operator, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
1127    function removeAdmin(address admin) external;
1128    function removeAppointee(address appointee, address target, bytes4 selector) external;
1129    function removePendingAdmin(address pendingAdmin) external;
1130    function setAppointee(address appointee, address target, bytes4 selector) external;
1131    function updateAVSMetadataURI(string memory metadataURI) external;
1132}
1133```
1134
1135...which was generated by the following JSON ABI:
1136```json
1137[
1138  {
1139    "type": "function",
1140    "name": "addPendingAdmin",
1141    "inputs": [
1142      {
1143        "name": "admin",
1144        "type": "address",
1145        "internalType": "address"
1146      }
1147    ],
1148    "outputs": [],
1149    "stateMutability": "nonpayable"
1150  },
1151  {
1152    "type": "function",
1153    "name": "avsDirectory",
1154    "inputs": [],
1155    "outputs": [
1156      {
1157        "name": "",
1158        "type": "address",
1159        "internalType": "address"
1160      }
1161    ],
1162    "stateMutability": "view"
1163  },
1164  {
1165    "type": "function",
1166    "name": "createAVSRewardsSubmission",
1167    "inputs": [
1168      {
1169        "name": "rewardsSubmissions",
1170        "type": "tuple[]",
1171        "internalType": "struct IRewardsCoordinatorTypes.RewardsSubmission[]",
1172        "components": [
1173          {
1174            "name": "strategiesAndMultipliers",
1175            "type": "tuple[]",
1176            "internalType": "struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]",
1177            "components": [
1178              {
1179                "name": "strategy",
1180                "type": "address",
1181                "internalType": "contract IStrategy"
1182              },
1183              {
1184                "name": "multiplier",
1185                "type": "uint96",
1186                "internalType": "uint96"
1187              }
1188            ]
1189          },
1190          {
1191            "name": "token",
1192            "type": "address",
1193            "internalType": "contract IERC20"
1194          },
1195          {
1196            "name": "amount",
1197            "type": "uint256",
1198            "internalType": "uint256"
1199          },
1200          {
1201            "name": "startTimestamp",
1202            "type": "uint32",
1203            "internalType": "uint32"
1204          },
1205          {
1206            "name": "duration",
1207            "type": "uint32",
1208            "internalType": "uint32"
1209          }
1210        ]
1211      }
1212    ],
1213    "outputs": [],
1214    "stateMutability": "nonpayable"
1215  },
1216  {
1217    "type": "function",
1218    "name": "deregisterOperatorFromAVS",
1219    "inputs": [
1220      {
1221        "name": "operator",
1222        "type": "address",
1223        "internalType": "address"
1224      }
1225    ],
1226    "outputs": [],
1227    "stateMutability": "nonpayable"
1228  },
1229  {
1230    "type": "function",
1231    "name": "deregisterOperatorFromOperatorSets",
1232    "inputs": [
1233      {
1234        "name": "operator",
1235        "type": "address",
1236        "internalType": "address"
1237      },
1238      {
1239        "name": "operatorSetIds",
1240        "type": "uint32[]",
1241        "internalType": "uint32[]"
1242      }
1243    ],
1244    "outputs": [],
1245    "stateMutability": "nonpayable"
1246  },
1247  {
1248    "type": "function",
1249    "name": "getOperatorRestakedStrategies",
1250    "inputs": [
1251      {
1252        "name": "operator",
1253        "type": "address",
1254        "internalType": "address"
1255      }
1256    ],
1257    "outputs": [
1258      {
1259        "name": "",
1260        "type": "address[]",
1261        "internalType": "address[]"
1262      }
1263    ],
1264    "stateMutability": "view"
1265  },
1266  {
1267    "type": "function",
1268    "name": "getRestakeableStrategies",
1269    "inputs": [],
1270    "outputs": [
1271      {
1272        "name": "",
1273        "type": "address[]",
1274        "internalType": "address[]"
1275      }
1276    ],
1277    "stateMutability": "view"
1278  },
1279  {
1280    "type": "function",
1281    "name": "registerOperatorToAVS",
1282    "inputs": [
1283      {
1284        "name": "operator",
1285        "type": "address",
1286        "internalType": "address"
1287      },
1288      {
1289        "name": "operatorSignature",
1290        "type": "tuple",
1291        "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry",
1292        "components": [
1293          {
1294            "name": "signature",
1295            "type": "bytes",
1296            "internalType": "bytes"
1297          },
1298          {
1299            "name": "salt",
1300            "type": "bytes32",
1301            "internalType": "bytes32"
1302          },
1303          {
1304            "name": "expiry",
1305            "type": "uint256",
1306            "internalType": "uint256"
1307          }
1308        ]
1309      }
1310    ],
1311    "outputs": [],
1312    "stateMutability": "nonpayable"
1313  },
1314  {
1315    "type": "function",
1316    "name": "removeAdmin",
1317    "inputs": [
1318      {
1319        "name": "admin",
1320        "type": "address",
1321        "internalType": "address"
1322      }
1323    ],
1324    "outputs": [],
1325    "stateMutability": "nonpayable"
1326  },
1327  {
1328    "type": "function",
1329    "name": "removeAppointee",
1330    "inputs": [
1331      {
1332        "name": "appointee",
1333        "type": "address",
1334        "internalType": "address"
1335      },
1336      {
1337        "name": "target",
1338        "type": "address",
1339        "internalType": "address"
1340      },
1341      {
1342        "name": "selector",
1343        "type": "bytes4",
1344        "internalType": "bytes4"
1345      }
1346    ],
1347    "outputs": [],
1348    "stateMutability": "nonpayable"
1349  },
1350  {
1351    "type": "function",
1352    "name": "removePendingAdmin",
1353    "inputs": [
1354      {
1355        "name": "pendingAdmin",
1356        "type": "address",
1357        "internalType": "address"
1358      }
1359    ],
1360    "outputs": [],
1361    "stateMutability": "nonpayable"
1362  },
1363  {
1364    "type": "function",
1365    "name": "setAppointee",
1366    "inputs": [
1367      {
1368        "name": "appointee",
1369        "type": "address",
1370        "internalType": "address"
1371      },
1372      {
1373        "name": "target",
1374        "type": "address",
1375        "internalType": "address"
1376      },
1377      {
1378        "name": "selector",
1379        "type": "bytes4",
1380        "internalType": "bytes4"
1381      }
1382    ],
1383    "outputs": [],
1384    "stateMutability": "nonpayable"
1385  },
1386  {
1387    "type": "function",
1388    "name": "updateAVSMetadataURI",
1389    "inputs": [
1390      {
1391        "name": "metadataURI",
1392        "type": "string",
1393        "internalType": "string"
1394      }
1395    ],
1396    "outputs": [],
1397    "stateMutability": "nonpayable"
1398  },
1399  {
1400    "type": "event",
1401    "name": "RewardsInitiatorUpdated",
1402    "inputs": [
1403      {
1404        "name": "prevRewardsInitiator",
1405        "type": "address",
1406        "indexed": false,
1407        "internalType": "address"
1408      },
1409      {
1410        "name": "newRewardsInitiator",
1411        "type": "address",
1412        "indexed": false,
1413        "internalType": "address"
1414      }
1415    ],
1416    "anonymous": false
1417  },
1418  {
1419    "type": "error",
1420    "name": "DelayPeriodNotPassed",
1421    "inputs": []
1422  },
1423  {
1424    "type": "error",
1425    "name": "OnlyRegistryCoordinator",
1426    "inputs": []
1427  },
1428  {
1429    "type": "error",
1430    "name": "OnlyRewardsInitiator",
1431    "inputs": []
1432  },
1433  {
1434    "type": "error",
1435    "name": "OnlyStakeRegistry",
1436    "inputs": []
1437  }
1438]
1439```*/
1440#[allow(
1441    non_camel_case_types,
1442    non_snake_case,
1443    clippy::pub_underscore_fields,
1444    clippy::style,
1445    clippy::empty_structs_with_brackets
1446)]
1447pub mod IServiceManager {
1448    use super::*;
1449    use alloy::sol_types as alloy_sol_types;
1450    /// The creation / init bytecode of the contract.
1451    ///
1452    /// ```text
1453    ///0x
1454    /// ```
1455    #[rustfmt::skip]
1456    #[allow(clippy::all)]
1457    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1458        b"",
1459    );
1460    /// The runtime bytecode of the contract, as deployed on the network.
1461    ///
1462    /// ```text
1463    ///0x
1464    /// ```
1465    #[rustfmt::skip]
1466    #[allow(clippy::all)]
1467    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1468        b"",
1469    );
1470    #[derive(serde::Serialize, serde::Deserialize)]
1471    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1472    /**Custom error with signature `DelayPeriodNotPassed()` and selector `0xfb623b04`.
1473```solidity
1474error DelayPeriodNotPassed();
1475```*/
1476    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1477    #[derive(Clone)]
1478    pub struct DelayPeriodNotPassed;
1479    #[allow(
1480        non_camel_case_types,
1481        non_snake_case,
1482        clippy::pub_underscore_fields,
1483        clippy::style
1484    )]
1485    const _: () = {
1486        use alloy::sol_types as alloy_sol_types;
1487        #[doc(hidden)]
1488        type UnderlyingSolTuple<'a> = ();
1489        #[doc(hidden)]
1490        type UnderlyingRustTuple<'a> = ();
1491        #[cfg(test)]
1492        #[allow(dead_code, unreachable_patterns)]
1493        fn _type_assertion(
1494            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1495        ) {
1496            match _t {
1497                alloy_sol_types::private::AssertTypeEq::<
1498                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1499                >(_) => {}
1500            }
1501        }
1502        #[automatically_derived]
1503        #[doc(hidden)]
1504        impl ::core::convert::From<DelayPeriodNotPassed> for UnderlyingRustTuple<'_> {
1505            fn from(value: DelayPeriodNotPassed) -> Self {
1506                ()
1507            }
1508        }
1509        #[automatically_derived]
1510        #[doc(hidden)]
1511        impl ::core::convert::From<UnderlyingRustTuple<'_>> for DelayPeriodNotPassed {
1512            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1513                Self
1514            }
1515        }
1516        #[automatically_derived]
1517        impl alloy_sol_types::SolError for DelayPeriodNotPassed {
1518            type Parameters<'a> = UnderlyingSolTuple<'a>;
1519            type Token<'a> = <Self::Parameters<
1520                'a,
1521            > as alloy_sol_types::SolType>::Token<'a>;
1522            const SIGNATURE: &'static str = "DelayPeriodNotPassed()";
1523            const SELECTOR: [u8; 4] = [251u8, 98u8, 59u8, 4u8];
1524            #[inline]
1525            fn new<'a>(
1526                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1527            ) -> Self {
1528                tuple.into()
1529            }
1530            #[inline]
1531            fn tokenize(&self) -> Self::Token<'_> {
1532                ()
1533            }
1534            #[inline]
1535            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1536                <Self::Parameters<
1537                    '_,
1538                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1539                    .map(Self::new)
1540            }
1541        }
1542    };
1543    #[derive(serde::Serialize, serde::Deserialize)]
1544    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1545    /**Custom error with signature `OnlyRegistryCoordinator()` and selector `0x8729b7be`.
1546```solidity
1547error OnlyRegistryCoordinator();
1548```*/
1549    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1550    #[derive(Clone)]
1551    pub struct OnlyRegistryCoordinator;
1552    #[allow(
1553        non_camel_case_types,
1554        non_snake_case,
1555        clippy::pub_underscore_fields,
1556        clippy::style
1557    )]
1558    const _: () = {
1559        use alloy::sol_types as alloy_sol_types;
1560        #[doc(hidden)]
1561        type UnderlyingSolTuple<'a> = ();
1562        #[doc(hidden)]
1563        type UnderlyingRustTuple<'a> = ();
1564        #[cfg(test)]
1565        #[allow(dead_code, unreachable_patterns)]
1566        fn _type_assertion(
1567            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1568        ) {
1569            match _t {
1570                alloy_sol_types::private::AssertTypeEq::<
1571                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1572                >(_) => {}
1573            }
1574        }
1575        #[automatically_derived]
1576        #[doc(hidden)]
1577        impl ::core::convert::From<OnlyRegistryCoordinator> for UnderlyingRustTuple<'_> {
1578            fn from(value: OnlyRegistryCoordinator) -> Self {
1579                ()
1580            }
1581        }
1582        #[automatically_derived]
1583        #[doc(hidden)]
1584        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyRegistryCoordinator {
1585            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1586                Self
1587            }
1588        }
1589        #[automatically_derived]
1590        impl alloy_sol_types::SolError for OnlyRegistryCoordinator {
1591            type Parameters<'a> = UnderlyingSolTuple<'a>;
1592            type Token<'a> = <Self::Parameters<
1593                'a,
1594            > as alloy_sol_types::SolType>::Token<'a>;
1595            const SIGNATURE: &'static str = "OnlyRegistryCoordinator()";
1596            const SELECTOR: [u8; 4] = [135u8, 41u8, 183u8, 190u8];
1597            #[inline]
1598            fn new<'a>(
1599                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1600            ) -> Self {
1601                tuple.into()
1602            }
1603            #[inline]
1604            fn tokenize(&self) -> Self::Token<'_> {
1605                ()
1606            }
1607            #[inline]
1608            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1609                <Self::Parameters<
1610                    '_,
1611                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1612                    .map(Self::new)
1613            }
1614        }
1615    };
1616    #[derive(serde::Serialize, serde::Deserialize)]
1617    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1618    /**Custom error with signature `OnlyRewardsInitiator()` and selector `0x8e79fdb5`.
1619```solidity
1620error OnlyRewardsInitiator();
1621```*/
1622    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1623    #[derive(Clone)]
1624    pub struct OnlyRewardsInitiator;
1625    #[allow(
1626        non_camel_case_types,
1627        non_snake_case,
1628        clippy::pub_underscore_fields,
1629        clippy::style
1630    )]
1631    const _: () = {
1632        use alloy::sol_types as alloy_sol_types;
1633        #[doc(hidden)]
1634        type UnderlyingSolTuple<'a> = ();
1635        #[doc(hidden)]
1636        type UnderlyingRustTuple<'a> = ();
1637        #[cfg(test)]
1638        #[allow(dead_code, unreachable_patterns)]
1639        fn _type_assertion(
1640            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1641        ) {
1642            match _t {
1643                alloy_sol_types::private::AssertTypeEq::<
1644                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1645                >(_) => {}
1646            }
1647        }
1648        #[automatically_derived]
1649        #[doc(hidden)]
1650        impl ::core::convert::From<OnlyRewardsInitiator> for UnderlyingRustTuple<'_> {
1651            fn from(value: OnlyRewardsInitiator) -> Self {
1652                ()
1653            }
1654        }
1655        #[automatically_derived]
1656        #[doc(hidden)]
1657        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyRewardsInitiator {
1658            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1659                Self
1660            }
1661        }
1662        #[automatically_derived]
1663        impl alloy_sol_types::SolError for OnlyRewardsInitiator {
1664            type Parameters<'a> = UnderlyingSolTuple<'a>;
1665            type Token<'a> = <Self::Parameters<
1666                'a,
1667            > as alloy_sol_types::SolType>::Token<'a>;
1668            const SIGNATURE: &'static str = "OnlyRewardsInitiator()";
1669            const SELECTOR: [u8; 4] = [142u8, 121u8, 253u8, 181u8];
1670            #[inline]
1671            fn new<'a>(
1672                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1673            ) -> Self {
1674                tuple.into()
1675            }
1676            #[inline]
1677            fn tokenize(&self) -> Self::Token<'_> {
1678                ()
1679            }
1680            #[inline]
1681            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1682                <Self::Parameters<
1683                    '_,
1684                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1685                    .map(Self::new)
1686            }
1687        }
1688    };
1689    #[derive(serde::Serialize, serde::Deserialize)]
1690    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1691    /**Custom error with signature `OnlyStakeRegistry()` and selector `0x46bf2281`.
1692```solidity
1693error OnlyStakeRegistry();
1694```*/
1695    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1696    #[derive(Clone)]
1697    pub struct OnlyStakeRegistry;
1698    #[allow(
1699        non_camel_case_types,
1700        non_snake_case,
1701        clippy::pub_underscore_fields,
1702        clippy::style
1703    )]
1704    const _: () = {
1705        use alloy::sol_types as alloy_sol_types;
1706        #[doc(hidden)]
1707        type UnderlyingSolTuple<'a> = ();
1708        #[doc(hidden)]
1709        type UnderlyingRustTuple<'a> = ();
1710        #[cfg(test)]
1711        #[allow(dead_code, unreachable_patterns)]
1712        fn _type_assertion(
1713            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1714        ) {
1715            match _t {
1716                alloy_sol_types::private::AssertTypeEq::<
1717                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1718                >(_) => {}
1719            }
1720        }
1721        #[automatically_derived]
1722        #[doc(hidden)]
1723        impl ::core::convert::From<OnlyStakeRegistry> for UnderlyingRustTuple<'_> {
1724            fn from(value: OnlyStakeRegistry) -> Self {
1725                ()
1726            }
1727        }
1728        #[automatically_derived]
1729        #[doc(hidden)]
1730        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyStakeRegistry {
1731            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1732                Self
1733            }
1734        }
1735        #[automatically_derived]
1736        impl alloy_sol_types::SolError for OnlyStakeRegistry {
1737            type Parameters<'a> = UnderlyingSolTuple<'a>;
1738            type Token<'a> = <Self::Parameters<
1739                'a,
1740            > as alloy_sol_types::SolType>::Token<'a>;
1741            const SIGNATURE: &'static str = "OnlyStakeRegistry()";
1742            const SELECTOR: [u8; 4] = [70u8, 191u8, 34u8, 129u8];
1743            #[inline]
1744            fn new<'a>(
1745                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1746            ) -> Self {
1747                tuple.into()
1748            }
1749            #[inline]
1750            fn tokenize(&self) -> Self::Token<'_> {
1751                ()
1752            }
1753            #[inline]
1754            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1755                <Self::Parameters<
1756                    '_,
1757                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1758                    .map(Self::new)
1759            }
1760        }
1761    };
1762    #[derive(serde::Serialize, serde::Deserialize)]
1763    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1764    /**Event with signature `RewardsInitiatorUpdated(address,address)` and selector `0xe11cddf1816a43318ca175bbc52cd0185436e9cbead7c83acc54a73e461717e3`.
1765```solidity
1766event RewardsInitiatorUpdated(address prevRewardsInitiator, address newRewardsInitiator);
1767```*/
1768    #[allow(
1769        non_camel_case_types,
1770        non_snake_case,
1771        clippy::pub_underscore_fields,
1772        clippy::style
1773    )]
1774    #[derive(Clone)]
1775    pub struct RewardsInitiatorUpdated {
1776        #[allow(missing_docs)]
1777        pub prevRewardsInitiator: alloy::sol_types::private::Address,
1778        #[allow(missing_docs)]
1779        pub newRewardsInitiator: alloy::sol_types::private::Address,
1780    }
1781    #[allow(
1782        non_camel_case_types,
1783        non_snake_case,
1784        clippy::pub_underscore_fields,
1785        clippy::style
1786    )]
1787    const _: () = {
1788        use alloy::sol_types as alloy_sol_types;
1789        #[automatically_derived]
1790        impl alloy_sol_types::SolEvent for RewardsInitiatorUpdated {
1791            type DataTuple<'a> = (
1792                alloy::sol_types::sol_data::Address,
1793                alloy::sol_types::sol_data::Address,
1794            );
1795            type DataToken<'a> = <Self::DataTuple<
1796                'a,
1797            > as alloy_sol_types::SolType>::Token<'a>;
1798            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1799            const SIGNATURE: &'static str = "RewardsInitiatorUpdated(address,address)";
1800            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1801                225u8, 28u8, 221u8, 241u8, 129u8, 106u8, 67u8, 49u8, 140u8, 161u8, 117u8,
1802                187u8, 197u8, 44u8, 208u8, 24u8, 84u8, 54u8, 233u8, 203u8, 234u8, 215u8,
1803                200u8, 58u8, 204u8, 84u8, 167u8, 62u8, 70u8, 23u8, 23u8, 227u8,
1804            ]);
1805            const ANONYMOUS: bool = false;
1806            #[allow(unused_variables)]
1807            #[inline]
1808            fn new(
1809                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1810                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1811            ) -> Self {
1812                Self {
1813                    prevRewardsInitiator: data.0,
1814                    newRewardsInitiator: data.1,
1815                }
1816            }
1817            #[inline]
1818            fn check_signature(
1819                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1820            ) -> alloy_sol_types::Result<()> {
1821                if topics.0 != Self::SIGNATURE_HASH {
1822                    return Err(
1823                        alloy_sol_types::Error::invalid_event_signature_hash(
1824                            Self::SIGNATURE,
1825                            topics.0,
1826                            Self::SIGNATURE_HASH,
1827                        ),
1828                    );
1829                }
1830                Ok(())
1831            }
1832            #[inline]
1833            fn tokenize_body(&self) -> Self::DataToken<'_> {
1834                (
1835                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1836                        &self.prevRewardsInitiator,
1837                    ),
1838                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1839                        &self.newRewardsInitiator,
1840                    ),
1841                )
1842            }
1843            #[inline]
1844            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1845                (Self::SIGNATURE_HASH.into(),)
1846            }
1847            #[inline]
1848            fn encode_topics_raw(
1849                &self,
1850                out: &mut [alloy_sol_types::abi::token::WordToken],
1851            ) -> alloy_sol_types::Result<()> {
1852                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1853                    return Err(alloy_sol_types::Error::Overrun);
1854                }
1855                out[0usize] = alloy_sol_types::abi::token::WordToken(
1856                    Self::SIGNATURE_HASH,
1857                );
1858                Ok(())
1859            }
1860        }
1861        #[automatically_derived]
1862        impl alloy_sol_types::private::IntoLogData for RewardsInitiatorUpdated {
1863            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1864                From::from(self)
1865            }
1866            fn into_log_data(self) -> alloy_sol_types::private::LogData {
1867                From::from(&self)
1868            }
1869        }
1870        #[automatically_derived]
1871        impl From<&RewardsInitiatorUpdated> for alloy_sol_types::private::LogData {
1872            #[inline]
1873            fn from(
1874                this: &RewardsInitiatorUpdated,
1875            ) -> alloy_sol_types::private::LogData {
1876                alloy_sol_types::SolEvent::encode_log_data(this)
1877            }
1878        }
1879    };
1880    #[derive(serde::Serialize, serde::Deserialize)]
1881    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1882    /**Function with signature `addPendingAdmin(address)` and selector `0x279432eb`.
1883```solidity
1884function addPendingAdmin(address admin) external;
1885```*/
1886    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1887    #[derive(Clone)]
1888    pub struct addPendingAdminCall {
1889        #[allow(missing_docs)]
1890        pub admin: alloy::sol_types::private::Address,
1891    }
1892    ///Container type for the return parameters of the [`addPendingAdmin(address)`](addPendingAdminCall) function.
1893    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1894    #[derive(Clone)]
1895    pub struct addPendingAdminReturn {}
1896    #[allow(
1897        non_camel_case_types,
1898        non_snake_case,
1899        clippy::pub_underscore_fields,
1900        clippy::style
1901    )]
1902    const _: () = {
1903        use alloy::sol_types as alloy_sol_types;
1904        {
1905            #[doc(hidden)]
1906            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1907            #[doc(hidden)]
1908            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1909            #[cfg(test)]
1910            #[allow(dead_code, unreachable_patterns)]
1911            fn _type_assertion(
1912                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1913            ) {
1914                match _t {
1915                    alloy_sol_types::private::AssertTypeEq::<
1916                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1917                    >(_) => {}
1918                }
1919            }
1920            #[automatically_derived]
1921            #[doc(hidden)]
1922            impl ::core::convert::From<addPendingAdminCall> for UnderlyingRustTuple<'_> {
1923                fn from(value: addPendingAdminCall) -> Self {
1924                    (value.admin,)
1925                }
1926            }
1927            #[automatically_derived]
1928            #[doc(hidden)]
1929            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addPendingAdminCall {
1930                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1931                    Self { admin: tuple.0 }
1932                }
1933            }
1934        }
1935        {
1936            #[doc(hidden)]
1937            type UnderlyingSolTuple<'a> = ();
1938            #[doc(hidden)]
1939            type UnderlyingRustTuple<'a> = ();
1940            #[cfg(test)]
1941            #[allow(dead_code, unreachable_patterns)]
1942            fn _type_assertion(
1943                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1944            ) {
1945                match _t {
1946                    alloy_sol_types::private::AssertTypeEq::<
1947                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1948                    >(_) => {}
1949                }
1950            }
1951            #[automatically_derived]
1952            #[doc(hidden)]
1953            impl ::core::convert::From<addPendingAdminReturn>
1954            for UnderlyingRustTuple<'_> {
1955                fn from(value: addPendingAdminReturn) -> Self {
1956                    ()
1957                }
1958            }
1959            #[automatically_derived]
1960            #[doc(hidden)]
1961            impl ::core::convert::From<UnderlyingRustTuple<'_>>
1962            for addPendingAdminReturn {
1963                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1964                    Self {}
1965                }
1966            }
1967        }
1968        impl addPendingAdminReturn {
1969            fn _tokenize(
1970                &self,
1971            ) -> <addPendingAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1972                ()
1973            }
1974        }
1975        #[automatically_derived]
1976        impl alloy_sol_types::SolCall for addPendingAdminCall {
1977            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1978            type Token<'a> = <Self::Parameters<
1979                'a,
1980            > as alloy_sol_types::SolType>::Token<'a>;
1981            type Return = addPendingAdminReturn;
1982            type ReturnTuple<'a> = ();
1983            type ReturnToken<'a> = <Self::ReturnTuple<
1984                'a,
1985            > as alloy_sol_types::SolType>::Token<'a>;
1986            const SIGNATURE: &'static str = "addPendingAdmin(address)";
1987            const SELECTOR: [u8; 4] = [39u8, 148u8, 50u8, 235u8];
1988            #[inline]
1989            fn new<'a>(
1990                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1991            ) -> Self {
1992                tuple.into()
1993            }
1994            #[inline]
1995            fn tokenize(&self) -> Self::Token<'_> {
1996                (
1997                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1998                        &self.admin,
1999                    ),
2000                )
2001            }
2002            #[inline]
2003            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2004                addPendingAdminReturn::_tokenize(ret)
2005            }
2006            #[inline]
2007            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2008                <Self::ReturnTuple<
2009                    '_,
2010                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2011                    .map(Into::into)
2012            }
2013            #[inline]
2014            fn abi_decode_returns_validate(
2015                data: &[u8],
2016            ) -> alloy_sol_types::Result<Self::Return> {
2017                <Self::ReturnTuple<
2018                    '_,
2019                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2020                    .map(Into::into)
2021            }
2022        }
2023    };
2024    #[derive(serde::Serialize, serde::Deserialize)]
2025    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2026    /**Function with signature `avsDirectory()` and selector `0x6b3aa72e`.
2027```solidity
2028function avsDirectory() external view returns (address);
2029```*/
2030    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2031    #[derive(Clone)]
2032    pub struct avsDirectoryCall;
2033    #[derive(serde::Serialize, serde::Deserialize)]
2034    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2035    ///Container type for the return parameters of the [`avsDirectory()`](avsDirectoryCall) function.
2036    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2037    #[derive(Clone)]
2038    pub struct avsDirectoryReturn {
2039        #[allow(missing_docs)]
2040        pub _0: alloy::sol_types::private::Address,
2041    }
2042    #[allow(
2043        non_camel_case_types,
2044        non_snake_case,
2045        clippy::pub_underscore_fields,
2046        clippy::style
2047    )]
2048    const _: () = {
2049        use alloy::sol_types as alloy_sol_types;
2050        {
2051            #[doc(hidden)]
2052            type UnderlyingSolTuple<'a> = ();
2053            #[doc(hidden)]
2054            type UnderlyingRustTuple<'a> = ();
2055            #[cfg(test)]
2056            #[allow(dead_code, unreachable_patterns)]
2057            fn _type_assertion(
2058                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2059            ) {
2060                match _t {
2061                    alloy_sol_types::private::AssertTypeEq::<
2062                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2063                    >(_) => {}
2064                }
2065            }
2066            #[automatically_derived]
2067            #[doc(hidden)]
2068            impl ::core::convert::From<avsDirectoryCall> for UnderlyingRustTuple<'_> {
2069                fn from(value: avsDirectoryCall) -> Self {
2070                    ()
2071                }
2072            }
2073            #[automatically_derived]
2074            #[doc(hidden)]
2075            impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsDirectoryCall {
2076                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2077                    Self
2078                }
2079            }
2080        }
2081        {
2082            #[doc(hidden)]
2083            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2084            #[doc(hidden)]
2085            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2086            #[cfg(test)]
2087            #[allow(dead_code, unreachable_patterns)]
2088            fn _type_assertion(
2089                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2090            ) {
2091                match _t {
2092                    alloy_sol_types::private::AssertTypeEq::<
2093                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2094                    >(_) => {}
2095                }
2096            }
2097            #[automatically_derived]
2098            #[doc(hidden)]
2099            impl ::core::convert::From<avsDirectoryReturn> for UnderlyingRustTuple<'_> {
2100                fn from(value: avsDirectoryReturn) -> Self {
2101                    (value._0,)
2102                }
2103            }
2104            #[automatically_derived]
2105            #[doc(hidden)]
2106            impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsDirectoryReturn {
2107                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2108                    Self { _0: tuple.0 }
2109                }
2110            }
2111        }
2112        #[automatically_derived]
2113        impl alloy_sol_types::SolCall for avsDirectoryCall {
2114            type Parameters<'a> = ();
2115            type Token<'a> = <Self::Parameters<
2116                'a,
2117            > as alloy_sol_types::SolType>::Token<'a>;
2118            type Return = alloy::sol_types::private::Address;
2119            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2120            type ReturnToken<'a> = <Self::ReturnTuple<
2121                'a,
2122            > as alloy_sol_types::SolType>::Token<'a>;
2123            const SIGNATURE: &'static str = "avsDirectory()";
2124            const SELECTOR: [u8; 4] = [107u8, 58u8, 167u8, 46u8];
2125            #[inline]
2126            fn new<'a>(
2127                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2128            ) -> Self {
2129                tuple.into()
2130            }
2131            #[inline]
2132            fn tokenize(&self) -> Self::Token<'_> {
2133                ()
2134            }
2135            #[inline]
2136            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2137                (
2138                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2139                        ret,
2140                    ),
2141                )
2142            }
2143            #[inline]
2144            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2145                <Self::ReturnTuple<
2146                    '_,
2147                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2148                    .map(|r| {
2149                        let r: avsDirectoryReturn = r.into();
2150                        r._0
2151                    })
2152            }
2153            #[inline]
2154            fn abi_decode_returns_validate(
2155                data: &[u8],
2156            ) -> alloy_sol_types::Result<Self::Return> {
2157                <Self::ReturnTuple<
2158                    '_,
2159                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2160                    .map(|r| {
2161                        let r: avsDirectoryReturn = r.into();
2162                        r._0
2163                    })
2164            }
2165        }
2166    };
2167    #[derive(serde::Serialize, serde::Deserialize)]
2168    #[derive()]
2169    /**Function with signature `createAVSRewardsSubmission(((address,uint96)[],address,uint256,uint32,uint32)[])` and selector `0xfce36c7d`.
2170```solidity
2171function createAVSRewardsSubmission(IRewardsCoordinatorTypes.RewardsSubmission[] memory rewardsSubmissions) external;
2172```*/
2173    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2174    #[derive(Clone)]
2175    pub struct createAVSRewardsSubmissionCall {
2176        #[allow(missing_docs)]
2177        pub rewardsSubmissions: alloy::sol_types::private::Vec<
2178            <IRewardsCoordinatorTypes::RewardsSubmission as alloy::sol_types::SolType>::RustType,
2179        >,
2180    }
2181    ///Container type for the return parameters of the [`createAVSRewardsSubmission(((address,uint96)[],address,uint256,uint32,uint32)[])`](createAVSRewardsSubmissionCall) function.
2182    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2183    #[derive(Clone)]
2184    pub struct createAVSRewardsSubmissionReturn {}
2185    #[allow(
2186        non_camel_case_types,
2187        non_snake_case,
2188        clippy::pub_underscore_fields,
2189        clippy::style
2190    )]
2191    const _: () = {
2192        use alloy::sol_types as alloy_sol_types;
2193        {
2194            #[doc(hidden)]
2195            type UnderlyingSolTuple<'a> = (
2196                alloy::sol_types::sol_data::Array<
2197                    IRewardsCoordinatorTypes::RewardsSubmission,
2198                >,
2199            );
2200            #[doc(hidden)]
2201            type UnderlyingRustTuple<'a> = (
2202                alloy::sol_types::private::Vec<
2203                    <IRewardsCoordinatorTypes::RewardsSubmission as alloy::sol_types::SolType>::RustType,
2204                >,
2205            );
2206            #[cfg(test)]
2207            #[allow(dead_code, unreachable_patterns)]
2208            fn _type_assertion(
2209                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2210            ) {
2211                match _t {
2212                    alloy_sol_types::private::AssertTypeEq::<
2213                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2214                    >(_) => {}
2215                }
2216            }
2217            #[automatically_derived]
2218            #[doc(hidden)]
2219            impl ::core::convert::From<createAVSRewardsSubmissionCall>
2220            for UnderlyingRustTuple<'_> {
2221                fn from(value: createAVSRewardsSubmissionCall) -> Self {
2222                    (value.rewardsSubmissions,)
2223                }
2224            }
2225            #[automatically_derived]
2226            #[doc(hidden)]
2227            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2228            for createAVSRewardsSubmissionCall {
2229                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2230                    Self {
2231                        rewardsSubmissions: tuple.0,
2232                    }
2233                }
2234            }
2235        }
2236        {
2237            #[doc(hidden)]
2238            type UnderlyingSolTuple<'a> = ();
2239            #[doc(hidden)]
2240            type UnderlyingRustTuple<'a> = ();
2241            #[cfg(test)]
2242            #[allow(dead_code, unreachable_patterns)]
2243            fn _type_assertion(
2244                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2245            ) {
2246                match _t {
2247                    alloy_sol_types::private::AssertTypeEq::<
2248                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2249                    >(_) => {}
2250                }
2251            }
2252            #[automatically_derived]
2253            #[doc(hidden)]
2254            impl ::core::convert::From<createAVSRewardsSubmissionReturn>
2255            for UnderlyingRustTuple<'_> {
2256                fn from(value: createAVSRewardsSubmissionReturn) -> Self {
2257                    ()
2258                }
2259            }
2260            #[automatically_derived]
2261            #[doc(hidden)]
2262            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2263            for createAVSRewardsSubmissionReturn {
2264                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2265                    Self {}
2266                }
2267            }
2268        }
2269        impl createAVSRewardsSubmissionReturn {
2270            fn _tokenize(
2271                &self,
2272            ) -> <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::ReturnToken<
2273                '_,
2274            > {
2275                ()
2276            }
2277        }
2278        #[automatically_derived]
2279        impl alloy_sol_types::SolCall for createAVSRewardsSubmissionCall {
2280            type Parameters<'a> = (
2281                alloy::sol_types::sol_data::Array<
2282                    IRewardsCoordinatorTypes::RewardsSubmission,
2283                >,
2284            );
2285            type Token<'a> = <Self::Parameters<
2286                'a,
2287            > as alloy_sol_types::SolType>::Token<'a>;
2288            type Return = createAVSRewardsSubmissionReturn;
2289            type ReturnTuple<'a> = ();
2290            type ReturnToken<'a> = <Self::ReturnTuple<
2291                'a,
2292            > as alloy_sol_types::SolType>::Token<'a>;
2293            const SIGNATURE: &'static str = "createAVSRewardsSubmission(((address,uint96)[],address,uint256,uint32,uint32)[])";
2294            const SELECTOR: [u8; 4] = [252u8, 227u8, 108u8, 125u8];
2295            #[inline]
2296            fn new<'a>(
2297                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2298            ) -> Self {
2299                tuple.into()
2300            }
2301            #[inline]
2302            fn tokenize(&self) -> Self::Token<'_> {
2303                (
2304                    <alloy::sol_types::sol_data::Array<
2305                        IRewardsCoordinatorTypes::RewardsSubmission,
2306                    > as alloy_sol_types::SolType>::tokenize(&self.rewardsSubmissions),
2307                )
2308            }
2309            #[inline]
2310            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2311                createAVSRewardsSubmissionReturn::_tokenize(ret)
2312            }
2313            #[inline]
2314            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2315                <Self::ReturnTuple<
2316                    '_,
2317                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2318                    .map(Into::into)
2319            }
2320            #[inline]
2321            fn abi_decode_returns_validate(
2322                data: &[u8],
2323            ) -> alloy_sol_types::Result<Self::Return> {
2324                <Self::ReturnTuple<
2325                    '_,
2326                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2327                    .map(Into::into)
2328            }
2329        }
2330    };
2331    #[derive(serde::Serialize, serde::Deserialize)]
2332    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2333    /**Function with signature `deregisterOperatorFromAVS(address)` and selector `0xa364f4da`.
2334```solidity
2335function deregisterOperatorFromAVS(address operator) external;
2336```*/
2337    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2338    #[derive(Clone)]
2339    pub struct deregisterOperatorFromAVSCall {
2340        #[allow(missing_docs)]
2341        pub operator: alloy::sol_types::private::Address,
2342    }
2343    ///Container type for the return parameters of the [`deregisterOperatorFromAVS(address)`](deregisterOperatorFromAVSCall) function.
2344    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2345    #[derive(Clone)]
2346    pub struct deregisterOperatorFromAVSReturn {}
2347    #[allow(
2348        non_camel_case_types,
2349        non_snake_case,
2350        clippy::pub_underscore_fields,
2351        clippy::style
2352    )]
2353    const _: () = {
2354        use alloy::sol_types as alloy_sol_types;
2355        {
2356            #[doc(hidden)]
2357            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2358            #[doc(hidden)]
2359            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2360            #[cfg(test)]
2361            #[allow(dead_code, unreachable_patterns)]
2362            fn _type_assertion(
2363                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2364            ) {
2365                match _t {
2366                    alloy_sol_types::private::AssertTypeEq::<
2367                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2368                    >(_) => {}
2369                }
2370            }
2371            #[automatically_derived]
2372            #[doc(hidden)]
2373            impl ::core::convert::From<deregisterOperatorFromAVSCall>
2374            for UnderlyingRustTuple<'_> {
2375                fn from(value: deregisterOperatorFromAVSCall) -> Self {
2376                    (value.operator,)
2377                }
2378            }
2379            #[automatically_derived]
2380            #[doc(hidden)]
2381            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2382            for deregisterOperatorFromAVSCall {
2383                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2384                    Self { operator: tuple.0 }
2385                }
2386            }
2387        }
2388        {
2389            #[doc(hidden)]
2390            type UnderlyingSolTuple<'a> = ();
2391            #[doc(hidden)]
2392            type UnderlyingRustTuple<'a> = ();
2393            #[cfg(test)]
2394            #[allow(dead_code, unreachable_patterns)]
2395            fn _type_assertion(
2396                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2397            ) {
2398                match _t {
2399                    alloy_sol_types::private::AssertTypeEq::<
2400                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2401                    >(_) => {}
2402                }
2403            }
2404            #[automatically_derived]
2405            #[doc(hidden)]
2406            impl ::core::convert::From<deregisterOperatorFromAVSReturn>
2407            for UnderlyingRustTuple<'_> {
2408                fn from(value: deregisterOperatorFromAVSReturn) -> Self {
2409                    ()
2410                }
2411            }
2412            #[automatically_derived]
2413            #[doc(hidden)]
2414            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2415            for deregisterOperatorFromAVSReturn {
2416                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2417                    Self {}
2418                }
2419            }
2420        }
2421        impl deregisterOperatorFromAVSReturn {
2422            fn _tokenize(
2423                &self,
2424            ) -> <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::ReturnToken<
2425                '_,
2426            > {
2427                ()
2428            }
2429        }
2430        #[automatically_derived]
2431        impl alloy_sol_types::SolCall for deregisterOperatorFromAVSCall {
2432            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2433            type Token<'a> = <Self::Parameters<
2434                'a,
2435            > as alloy_sol_types::SolType>::Token<'a>;
2436            type Return = deregisterOperatorFromAVSReturn;
2437            type ReturnTuple<'a> = ();
2438            type ReturnToken<'a> = <Self::ReturnTuple<
2439                'a,
2440            > as alloy_sol_types::SolType>::Token<'a>;
2441            const SIGNATURE: &'static str = "deregisterOperatorFromAVS(address)";
2442            const SELECTOR: [u8; 4] = [163u8, 100u8, 244u8, 218u8];
2443            #[inline]
2444            fn new<'a>(
2445                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2446            ) -> Self {
2447                tuple.into()
2448            }
2449            #[inline]
2450            fn tokenize(&self) -> Self::Token<'_> {
2451                (
2452                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2453                        &self.operator,
2454                    ),
2455                )
2456            }
2457            #[inline]
2458            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2459                deregisterOperatorFromAVSReturn::_tokenize(ret)
2460            }
2461            #[inline]
2462            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2463                <Self::ReturnTuple<
2464                    '_,
2465                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2466                    .map(Into::into)
2467            }
2468            #[inline]
2469            fn abi_decode_returns_validate(
2470                data: &[u8],
2471            ) -> alloy_sol_types::Result<Self::Return> {
2472                <Self::ReturnTuple<
2473                    '_,
2474                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2475                    .map(Into::into)
2476            }
2477        }
2478    };
2479    #[derive(serde::Serialize, serde::Deserialize)]
2480    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2481    /**Function with signature `deregisterOperatorFromOperatorSets(address,uint32[])` and selector `0xc1a8e2c5`.
2482```solidity
2483function deregisterOperatorFromOperatorSets(address operator, uint32[] memory operatorSetIds) external;
2484```*/
2485    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2486    #[derive(Clone)]
2487    pub struct deregisterOperatorFromOperatorSetsCall {
2488        #[allow(missing_docs)]
2489        pub operator: alloy::sol_types::private::Address,
2490        #[allow(missing_docs)]
2491        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
2492    }
2493    ///Container type for the return parameters of the [`deregisterOperatorFromOperatorSets(address,uint32[])`](deregisterOperatorFromOperatorSetsCall) function.
2494    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2495    #[derive(Clone)]
2496    pub struct deregisterOperatorFromOperatorSetsReturn {}
2497    #[allow(
2498        non_camel_case_types,
2499        non_snake_case,
2500        clippy::pub_underscore_fields,
2501        clippy::style
2502    )]
2503    const _: () = {
2504        use alloy::sol_types as alloy_sol_types;
2505        {
2506            #[doc(hidden)]
2507            type UnderlyingSolTuple<'a> = (
2508                alloy::sol_types::sol_data::Address,
2509                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
2510            );
2511            #[doc(hidden)]
2512            type UnderlyingRustTuple<'a> = (
2513                alloy::sol_types::private::Address,
2514                alloy::sol_types::private::Vec<u32>,
2515            );
2516            #[cfg(test)]
2517            #[allow(dead_code, unreachable_patterns)]
2518            fn _type_assertion(
2519                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2520            ) {
2521                match _t {
2522                    alloy_sol_types::private::AssertTypeEq::<
2523                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2524                    >(_) => {}
2525                }
2526            }
2527            #[automatically_derived]
2528            #[doc(hidden)]
2529            impl ::core::convert::From<deregisterOperatorFromOperatorSetsCall>
2530            for UnderlyingRustTuple<'_> {
2531                fn from(value: deregisterOperatorFromOperatorSetsCall) -> Self {
2532                    (value.operator, value.operatorSetIds)
2533                }
2534            }
2535            #[automatically_derived]
2536            #[doc(hidden)]
2537            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2538            for deregisterOperatorFromOperatorSetsCall {
2539                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2540                    Self {
2541                        operator: tuple.0,
2542                        operatorSetIds: tuple.1,
2543                    }
2544                }
2545            }
2546        }
2547        {
2548            #[doc(hidden)]
2549            type UnderlyingSolTuple<'a> = ();
2550            #[doc(hidden)]
2551            type UnderlyingRustTuple<'a> = ();
2552            #[cfg(test)]
2553            #[allow(dead_code, unreachable_patterns)]
2554            fn _type_assertion(
2555                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2556            ) {
2557                match _t {
2558                    alloy_sol_types::private::AssertTypeEq::<
2559                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2560                    >(_) => {}
2561                }
2562            }
2563            #[automatically_derived]
2564            #[doc(hidden)]
2565            impl ::core::convert::From<deregisterOperatorFromOperatorSetsReturn>
2566            for UnderlyingRustTuple<'_> {
2567                fn from(value: deregisterOperatorFromOperatorSetsReturn) -> Self {
2568                    ()
2569                }
2570            }
2571            #[automatically_derived]
2572            #[doc(hidden)]
2573            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2574            for deregisterOperatorFromOperatorSetsReturn {
2575                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2576                    Self {}
2577                }
2578            }
2579        }
2580        impl deregisterOperatorFromOperatorSetsReturn {
2581            fn _tokenize(
2582                &self,
2583            ) -> <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<
2584                '_,
2585            > {
2586                ()
2587            }
2588        }
2589        #[automatically_derived]
2590        impl alloy_sol_types::SolCall for deregisterOperatorFromOperatorSetsCall {
2591            type Parameters<'a> = (
2592                alloy::sol_types::sol_data::Address,
2593                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
2594            );
2595            type Token<'a> = <Self::Parameters<
2596                'a,
2597            > as alloy_sol_types::SolType>::Token<'a>;
2598            type Return = deregisterOperatorFromOperatorSetsReturn;
2599            type ReturnTuple<'a> = ();
2600            type ReturnToken<'a> = <Self::ReturnTuple<
2601                'a,
2602            > as alloy_sol_types::SolType>::Token<'a>;
2603            const SIGNATURE: &'static str = "deregisterOperatorFromOperatorSets(address,uint32[])";
2604            const SELECTOR: [u8; 4] = [193u8, 168u8, 226u8, 197u8];
2605            #[inline]
2606            fn new<'a>(
2607                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2608            ) -> Self {
2609                tuple.into()
2610            }
2611            #[inline]
2612            fn tokenize(&self) -> Self::Token<'_> {
2613                (
2614                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2615                        &self.operator,
2616                    ),
2617                    <alloy::sol_types::sol_data::Array<
2618                        alloy::sol_types::sol_data::Uint<32>,
2619                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
2620                )
2621            }
2622            #[inline]
2623            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2624                deregisterOperatorFromOperatorSetsReturn::_tokenize(ret)
2625            }
2626            #[inline]
2627            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2628                <Self::ReturnTuple<
2629                    '_,
2630                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2631                    .map(Into::into)
2632            }
2633            #[inline]
2634            fn abi_decode_returns_validate(
2635                data: &[u8],
2636            ) -> alloy_sol_types::Result<Self::Return> {
2637                <Self::ReturnTuple<
2638                    '_,
2639                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2640                    .map(Into::into)
2641            }
2642        }
2643    };
2644    #[derive(serde::Serialize, serde::Deserialize)]
2645    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2646    /**Function with signature `getOperatorRestakedStrategies(address)` and selector `0x33cfb7b7`.
2647```solidity
2648function getOperatorRestakedStrategies(address operator) external view returns (address[] memory);
2649```*/
2650    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2651    #[derive(Clone)]
2652    pub struct getOperatorRestakedStrategiesCall {
2653        #[allow(missing_docs)]
2654        pub operator: alloy::sol_types::private::Address,
2655    }
2656    #[derive(serde::Serialize, serde::Deserialize)]
2657    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2658    ///Container type for the return parameters of the [`getOperatorRestakedStrategies(address)`](getOperatorRestakedStrategiesCall) function.
2659    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2660    #[derive(Clone)]
2661    pub struct getOperatorRestakedStrategiesReturn {
2662        #[allow(missing_docs)]
2663        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2664    }
2665    #[allow(
2666        non_camel_case_types,
2667        non_snake_case,
2668        clippy::pub_underscore_fields,
2669        clippy::style
2670    )]
2671    const _: () = {
2672        use alloy::sol_types as alloy_sol_types;
2673        {
2674            #[doc(hidden)]
2675            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2676            #[doc(hidden)]
2677            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2678            #[cfg(test)]
2679            #[allow(dead_code, unreachable_patterns)]
2680            fn _type_assertion(
2681                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2682            ) {
2683                match _t {
2684                    alloy_sol_types::private::AssertTypeEq::<
2685                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2686                    >(_) => {}
2687                }
2688            }
2689            #[automatically_derived]
2690            #[doc(hidden)]
2691            impl ::core::convert::From<getOperatorRestakedStrategiesCall>
2692            for UnderlyingRustTuple<'_> {
2693                fn from(value: getOperatorRestakedStrategiesCall) -> Self {
2694                    (value.operator,)
2695                }
2696            }
2697            #[automatically_derived]
2698            #[doc(hidden)]
2699            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2700            for getOperatorRestakedStrategiesCall {
2701                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2702                    Self { operator: tuple.0 }
2703                }
2704            }
2705        }
2706        {
2707            #[doc(hidden)]
2708            type UnderlyingSolTuple<'a> = (
2709                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2710            );
2711            #[doc(hidden)]
2712            type UnderlyingRustTuple<'a> = (
2713                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2714            );
2715            #[cfg(test)]
2716            #[allow(dead_code, unreachable_patterns)]
2717            fn _type_assertion(
2718                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2719            ) {
2720                match _t {
2721                    alloy_sol_types::private::AssertTypeEq::<
2722                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2723                    >(_) => {}
2724                }
2725            }
2726            #[automatically_derived]
2727            #[doc(hidden)]
2728            impl ::core::convert::From<getOperatorRestakedStrategiesReturn>
2729            for UnderlyingRustTuple<'_> {
2730                fn from(value: getOperatorRestakedStrategiesReturn) -> Self {
2731                    (value._0,)
2732                }
2733            }
2734            #[automatically_derived]
2735            #[doc(hidden)]
2736            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2737            for getOperatorRestakedStrategiesReturn {
2738                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2739                    Self { _0: tuple.0 }
2740                }
2741            }
2742        }
2743        #[automatically_derived]
2744        impl alloy_sol_types::SolCall for getOperatorRestakedStrategiesCall {
2745            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2746            type Token<'a> = <Self::Parameters<
2747                'a,
2748            > as alloy_sol_types::SolType>::Token<'a>;
2749            type Return = alloy::sol_types::private::Vec<
2750                alloy::sol_types::private::Address,
2751            >;
2752            type ReturnTuple<'a> = (
2753                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2754            );
2755            type ReturnToken<'a> = <Self::ReturnTuple<
2756                'a,
2757            > as alloy_sol_types::SolType>::Token<'a>;
2758            const SIGNATURE: &'static str = "getOperatorRestakedStrategies(address)";
2759            const SELECTOR: [u8; 4] = [51u8, 207u8, 183u8, 183u8];
2760            #[inline]
2761            fn new<'a>(
2762                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2763            ) -> Self {
2764                tuple.into()
2765            }
2766            #[inline]
2767            fn tokenize(&self) -> Self::Token<'_> {
2768                (
2769                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2770                        &self.operator,
2771                    ),
2772                )
2773            }
2774            #[inline]
2775            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2776                (
2777                    <alloy::sol_types::sol_data::Array<
2778                        alloy::sol_types::sol_data::Address,
2779                    > as alloy_sol_types::SolType>::tokenize(ret),
2780                )
2781            }
2782            #[inline]
2783            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2784                <Self::ReturnTuple<
2785                    '_,
2786                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2787                    .map(|r| {
2788                        let r: getOperatorRestakedStrategiesReturn = r.into();
2789                        r._0
2790                    })
2791            }
2792            #[inline]
2793            fn abi_decode_returns_validate(
2794                data: &[u8],
2795            ) -> alloy_sol_types::Result<Self::Return> {
2796                <Self::ReturnTuple<
2797                    '_,
2798                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2799                    .map(|r| {
2800                        let r: getOperatorRestakedStrategiesReturn = r.into();
2801                        r._0
2802                    })
2803            }
2804        }
2805    };
2806    #[derive(serde::Serialize, serde::Deserialize)]
2807    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2808    /**Function with signature `getRestakeableStrategies()` and selector `0xe481af9d`.
2809```solidity
2810function getRestakeableStrategies() external view returns (address[] memory);
2811```*/
2812    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2813    #[derive(Clone)]
2814    pub struct getRestakeableStrategiesCall;
2815    #[derive(serde::Serialize, serde::Deserialize)]
2816    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2817    ///Container type for the return parameters of the [`getRestakeableStrategies()`](getRestakeableStrategiesCall) function.
2818    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2819    #[derive(Clone)]
2820    pub struct getRestakeableStrategiesReturn {
2821        #[allow(missing_docs)]
2822        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2823    }
2824    #[allow(
2825        non_camel_case_types,
2826        non_snake_case,
2827        clippy::pub_underscore_fields,
2828        clippy::style
2829    )]
2830    const _: () = {
2831        use alloy::sol_types as alloy_sol_types;
2832        {
2833            #[doc(hidden)]
2834            type UnderlyingSolTuple<'a> = ();
2835            #[doc(hidden)]
2836            type UnderlyingRustTuple<'a> = ();
2837            #[cfg(test)]
2838            #[allow(dead_code, unreachable_patterns)]
2839            fn _type_assertion(
2840                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2841            ) {
2842                match _t {
2843                    alloy_sol_types::private::AssertTypeEq::<
2844                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2845                    >(_) => {}
2846                }
2847            }
2848            #[automatically_derived]
2849            #[doc(hidden)]
2850            impl ::core::convert::From<getRestakeableStrategiesCall>
2851            for UnderlyingRustTuple<'_> {
2852                fn from(value: getRestakeableStrategiesCall) -> Self {
2853                    ()
2854                }
2855            }
2856            #[automatically_derived]
2857            #[doc(hidden)]
2858            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2859            for getRestakeableStrategiesCall {
2860                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2861                    Self
2862                }
2863            }
2864        }
2865        {
2866            #[doc(hidden)]
2867            type UnderlyingSolTuple<'a> = (
2868                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2869            );
2870            #[doc(hidden)]
2871            type UnderlyingRustTuple<'a> = (
2872                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2873            );
2874            #[cfg(test)]
2875            #[allow(dead_code, unreachable_patterns)]
2876            fn _type_assertion(
2877                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2878            ) {
2879                match _t {
2880                    alloy_sol_types::private::AssertTypeEq::<
2881                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2882                    >(_) => {}
2883                }
2884            }
2885            #[automatically_derived]
2886            #[doc(hidden)]
2887            impl ::core::convert::From<getRestakeableStrategiesReturn>
2888            for UnderlyingRustTuple<'_> {
2889                fn from(value: getRestakeableStrategiesReturn) -> Self {
2890                    (value._0,)
2891                }
2892            }
2893            #[automatically_derived]
2894            #[doc(hidden)]
2895            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2896            for getRestakeableStrategiesReturn {
2897                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2898                    Self { _0: tuple.0 }
2899                }
2900            }
2901        }
2902        #[automatically_derived]
2903        impl alloy_sol_types::SolCall for getRestakeableStrategiesCall {
2904            type Parameters<'a> = ();
2905            type Token<'a> = <Self::Parameters<
2906                'a,
2907            > as alloy_sol_types::SolType>::Token<'a>;
2908            type Return = alloy::sol_types::private::Vec<
2909                alloy::sol_types::private::Address,
2910            >;
2911            type ReturnTuple<'a> = (
2912                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2913            );
2914            type ReturnToken<'a> = <Self::ReturnTuple<
2915                'a,
2916            > as alloy_sol_types::SolType>::Token<'a>;
2917            const SIGNATURE: &'static str = "getRestakeableStrategies()";
2918            const SELECTOR: [u8; 4] = [228u8, 129u8, 175u8, 157u8];
2919            #[inline]
2920            fn new<'a>(
2921                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2922            ) -> Self {
2923                tuple.into()
2924            }
2925            #[inline]
2926            fn tokenize(&self) -> Self::Token<'_> {
2927                ()
2928            }
2929            #[inline]
2930            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2931                (
2932                    <alloy::sol_types::sol_data::Array<
2933                        alloy::sol_types::sol_data::Address,
2934                    > as alloy_sol_types::SolType>::tokenize(ret),
2935                )
2936            }
2937            #[inline]
2938            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2939                <Self::ReturnTuple<
2940                    '_,
2941                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2942                    .map(|r| {
2943                        let r: getRestakeableStrategiesReturn = r.into();
2944                        r._0
2945                    })
2946            }
2947            #[inline]
2948            fn abi_decode_returns_validate(
2949                data: &[u8],
2950            ) -> alloy_sol_types::Result<Self::Return> {
2951                <Self::ReturnTuple<
2952                    '_,
2953                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2954                    .map(|r| {
2955                        let r: getRestakeableStrategiesReturn = r.into();
2956                        r._0
2957                    })
2958            }
2959        }
2960    };
2961    #[derive(serde::Serialize, serde::Deserialize)]
2962    #[derive(Default, Debug, PartialEq, Eq, Hash)]
2963    /**Function with signature `registerOperatorToAVS(address,(bytes,bytes32,uint256))` and selector `0x9926ee7d`.
2964```solidity
2965function registerOperatorToAVS(address operator, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
2966```*/
2967    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2968    #[derive(Clone)]
2969    pub struct registerOperatorToAVSCall {
2970        #[allow(missing_docs)]
2971        pub operator: alloy::sol_types::private::Address,
2972        #[allow(missing_docs)]
2973        pub operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
2974    }
2975    ///Container type for the return parameters of the [`registerOperatorToAVS(address,(bytes,bytes32,uint256))`](registerOperatorToAVSCall) function.
2976    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2977    #[derive(Clone)]
2978    pub struct registerOperatorToAVSReturn {}
2979    #[allow(
2980        non_camel_case_types,
2981        non_snake_case,
2982        clippy::pub_underscore_fields,
2983        clippy::style
2984    )]
2985    const _: () = {
2986        use alloy::sol_types as alloy_sol_types;
2987        {
2988            #[doc(hidden)]
2989            type UnderlyingSolTuple<'a> = (
2990                alloy::sol_types::sol_data::Address,
2991                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
2992            );
2993            #[doc(hidden)]
2994            type UnderlyingRustTuple<'a> = (
2995                alloy::sol_types::private::Address,
2996                <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
2997            );
2998            #[cfg(test)]
2999            #[allow(dead_code, unreachable_patterns)]
3000            fn _type_assertion(
3001                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3002            ) {
3003                match _t {
3004                    alloy_sol_types::private::AssertTypeEq::<
3005                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3006                    >(_) => {}
3007                }
3008            }
3009            #[automatically_derived]
3010            #[doc(hidden)]
3011            impl ::core::convert::From<registerOperatorToAVSCall>
3012            for UnderlyingRustTuple<'_> {
3013                fn from(value: registerOperatorToAVSCall) -> Self {
3014                    (value.operator, value.operatorSignature)
3015                }
3016            }
3017            #[automatically_derived]
3018            #[doc(hidden)]
3019            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3020            for registerOperatorToAVSCall {
3021                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3022                    Self {
3023                        operator: tuple.0,
3024                        operatorSignature: tuple.1,
3025                    }
3026                }
3027            }
3028        }
3029        {
3030            #[doc(hidden)]
3031            type UnderlyingSolTuple<'a> = ();
3032            #[doc(hidden)]
3033            type UnderlyingRustTuple<'a> = ();
3034            #[cfg(test)]
3035            #[allow(dead_code, unreachable_patterns)]
3036            fn _type_assertion(
3037                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3038            ) {
3039                match _t {
3040                    alloy_sol_types::private::AssertTypeEq::<
3041                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3042                    >(_) => {}
3043                }
3044            }
3045            #[automatically_derived]
3046            #[doc(hidden)]
3047            impl ::core::convert::From<registerOperatorToAVSReturn>
3048            for UnderlyingRustTuple<'_> {
3049                fn from(value: registerOperatorToAVSReturn) -> Self {
3050                    ()
3051                }
3052            }
3053            #[automatically_derived]
3054            #[doc(hidden)]
3055            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3056            for registerOperatorToAVSReturn {
3057                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3058                    Self {}
3059                }
3060            }
3061        }
3062        impl registerOperatorToAVSReturn {
3063            fn _tokenize(
3064                &self,
3065            ) -> <registerOperatorToAVSCall as alloy_sol_types::SolCall>::ReturnToken<
3066                '_,
3067            > {
3068                ()
3069            }
3070        }
3071        #[automatically_derived]
3072        impl alloy_sol_types::SolCall for registerOperatorToAVSCall {
3073            type Parameters<'a> = (
3074                alloy::sol_types::sol_data::Address,
3075                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
3076            );
3077            type Token<'a> = <Self::Parameters<
3078                'a,
3079            > as alloy_sol_types::SolType>::Token<'a>;
3080            type Return = registerOperatorToAVSReturn;
3081            type ReturnTuple<'a> = ();
3082            type ReturnToken<'a> = <Self::ReturnTuple<
3083                'a,
3084            > as alloy_sol_types::SolType>::Token<'a>;
3085            const SIGNATURE: &'static str = "registerOperatorToAVS(address,(bytes,bytes32,uint256))";
3086            const SELECTOR: [u8; 4] = [153u8, 38u8, 238u8, 125u8];
3087            #[inline]
3088            fn new<'a>(
3089                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3090            ) -> Self {
3091                tuple.into()
3092            }
3093            #[inline]
3094            fn tokenize(&self) -> Self::Token<'_> {
3095                (
3096                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3097                        &self.operator,
3098                    ),
3099                    <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy_sol_types::SolType>::tokenize(
3100                        &self.operatorSignature,
3101                    ),
3102                )
3103            }
3104            #[inline]
3105            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3106                registerOperatorToAVSReturn::_tokenize(ret)
3107            }
3108            #[inline]
3109            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3110                <Self::ReturnTuple<
3111                    '_,
3112                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3113                    .map(Into::into)
3114            }
3115            #[inline]
3116            fn abi_decode_returns_validate(
3117                data: &[u8],
3118            ) -> alloy_sol_types::Result<Self::Return> {
3119                <Self::ReturnTuple<
3120                    '_,
3121                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3122                    .map(Into::into)
3123            }
3124        }
3125    };
3126    #[derive(serde::Serialize, serde::Deserialize)]
3127    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3128    /**Function with signature `removeAdmin(address)` and selector `0x1785f53c`.
3129```solidity
3130function removeAdmin(address admin) external;
3131```*/
3132    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3133    #[derive(Clone)]
3134    pub struct removeAdminCall {
3135        #[allow(missing_docs)]
3136        pub admin: alloy::sol_types::private::Address,
3137    }
3138    ///Container type for the return parameters of the [`removeAdmin(address)`](removeAdminCall) function.
3139    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3140    #[derive(Clone)]
3141    pub struct removeAdminReturn {}
3142    #[allow(
3143        non_camel_case_types,
3144        non_snake_case,
3145        clippy::pub_underscore_fields,
3146        clippy::style
3147    )]
3148    const _: () = {
3149        use alloy::sol_types as alloy_sol_types;
3150        {
3151            #[doc(hidden)]
3152            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3153            #[doc(hidden)]
3154            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3155            #[cfg(test)]
3156            #[allow(dead_code, unreachable_patterns)]
3157            fn _type_assertion(
3158                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3159            ) {
3160                match _t {
3161                    alloy_sol_types::private::AssertTypeEq::<
3162                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3163                    >(_) => {}
3164                }
3165            }
3166            #[automatically_derived]
3167            #[doc(hidden)]
3168            impl ::core::convert::From<removeAdminCall> for UnderlyingRustTuple<'_> {
3169                fn from(value: removeAdminCall) -> Self {
3170                    (value.admin,)
3171                }
3172            }
3173            #[automatically_derived]
3174            #[doc(hidden)]
3175            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminCall {
3176                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3177                    Self { admin: tuple.0 }
3178                }
3179            }
3180        }
3181        {
3182            #[doc(hidden)]
3183            type UnderlyingSolTuple<'a> = ();
3184            #[doc(hidden)]
3185            type UnderlyingRustTuple<'a> = ();
3186            #[cfg(test)]
3187            #[allow(dead_code, unreachable_patterns)]
3188            fn _type_assertion(
3189                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3190            ) {
3191                match _t {
3192                    alloy_sol_types::private::AssertTypeEq::<
3193                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3194                    >(_) => {}
3195                }
3196            }
3197            #[automatically_derived]
3198            #[doc(hidden)]
3199            impl ::core::convert::From<removeAdminReturn> for UnderlyingRustTuple<'_> {
3200                fn from(value: removeAdminReturn) -> Self {
3201                    ()
3202                }
3203            }
3204            #[automatically_derived]
3205            #[doc(hidden)]
3206            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminReturn {
3207                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3208                    Self {}
3209                }
3210            }
3211        }
3212        impl removeAdminReturn {
3213            fn _tokenize(
3214                &self,
3215            ) -> <removeAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3216                ()
3217            }
3218        }
3219        #[automatically_derived]
3220        impl alloy_sol_types::SolCall for removeAdminCall {
3221            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3222            type Token<'a> = <Self::Parameters<
3223                'a,
3224            > as alloy_sol_types::SolType>::Token<'a>;
3225            type Return = removeAdminReturn;
3226            type ReturnTuple<'a> = ();
3227            type ReturnToken<'a> = <Self::ReturnTuple<
3228                'a,
3229            > as alloy_sol_types::SolType>::Token<'a>;
3230            const SIGNATURE: &'static str = "removeAdmin(address)";
3231            const SELECTOR: [u8; 4] = [23u8, 133u8, 245u8, 60u8];
3232            #[inline]
3233            fn new<'a>(
3234                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3235            ) -> Self {
3236                tuple.into()
3237            }
3238            #[inline]
3239            fn tokenize(&self) -> Self::Token<'_> {
3240                (
3241                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3242                        &self.admin,
3243                    ),
3244                )
3245            }
3246            #[inline]
3247            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3248                removeAdminReturn::_tokenize(ret)
3249            }
3250            #[inline]
3251            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3252                <Self::ReturnTuple<
3253                    '_,
3254                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3255                    .map(Into::into)
3256            }
3257            #[inline]
3258            fn abi_decode_returns_validate(
3259                data: &[u8],
3260            ) -> alloy_sol_types::Result<Self::Return> {
3261                <Self::ReturnTuple<
3262                    '_,
3263                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3264                    .map(Into::into)
3265            }
3266        }
3267    };
3268    #[derive(serde::Serialize, serde::Deserialize)]
3269    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3270    /**Function with signature `removeAppointee(address,address,bytes4)` and selector `0xba550880`.
3271```solidity
3272function removeAppointee(address appointee, address target, bytes4 selector) external;
3273```*/
3274    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3275    #[derive(Clone)]
3276    pub struct removeAppointeeCall {
3277        #[allow(missing_docs)]
3278        pub appointee: alloy::sol_types::private::Address,
3279        #[allow(missing_docs)]
3280        pub target: alloy::sol_types::private::Address,
3281        #[allow(missing_docs)]
3282        pub selector: alloy::sol_types::private::FixedBytes<4>,
3283    }
3284    ///Container type for the return parameters of the [`removeAppointee(address,address,bytes4)`](removeAppointeeCall) function.
3285    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3286    #[derive(Clone)]
3287    pub struct removeAppointeeReturn {}
3288    #[allow(
3289        non_camel_case_types,
3290        non_snake_case,
3291        clippy::pub_underscore_fields,
3292        clippy::style
3293    )]
3294    const _: () = {
3295        use alloy::sol_types as alloy_sol_types;
3296        {
3297            #[doc(hidden)]
3298            type UnderlyingSolTuple<'a> = (
3299                alloy::sol_types::sol_data::Address,
3300                alloy::sol_types::sol_data::Address,
3301                alloy::sol_types::sol_data::FixedBytes<4>,
3302            );
3303            #[doc(hidden)]
3304            type UnderlyingRustTuple<'a> = (
3305                alloy::sol_types::private::Address,
3306                alloy::sol_types::private::Address,
3307                alloy::sol_types::private::FixedBytes<4>,
3308            );
3309            #[cfg(test)]
3310            #[allow(dead_code, unreachable_patterns)]
3311            fn _type_assertion(
3312                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3313            ) {
3314                match _t {
3315                    alloy_sol_types::private::AssertTypeEq::<
3316                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3317                    >(_) => {}
3318                }
3319            }
3320            #[automatically_derived]
3321            #[doc(hidden)]
3322            impl ::core::convert::From<removeAppointeeCall> for UnderlyingRustTuple<'_> {
3323                fn from(value: removeAppointeeCall) -> Self {
3324                    (value.appointee, value.target, value.selector)
3325                }
3326            }
3327            #[automatically_derived]
3328            #[doc(hidden)]
3329            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAppointeeCall {
3330                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3331                    Self {
3332                        appointee: tuple.0,
3333                        target: tuple.1,
3334                        selector: tuple.2,
3335                    }
3336                }
3337            }
3338        }
3339        {
3340            #[doc(hidden)]
3341            type UnderlyingSolTuple<'a> = ();
3342            #[doc(hidden)]
3343            type UnderlyingRustTuple<'a> = ();
3344            #[cfg(test)]
3345            #[allow(dead_code, unreachable_patterns)]
3346            fn _type_assertion(
3347                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3348            ) {
3349                match _t {
3350                    alloy_sol_types::private::AssertTypeEq::<
3351                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3352                    >(_) => {}
3353                }
3354            }
3355            #[automatically_derived]
3356            #[doc(hidden)]
3357            impl ::core::convert::From<removeAppointeeReturn>
3358            for UnderlyingRustTuple<'_> {
3359                fn from(value: removeAppointeeReturn) -> Self {
3360                    ()
3361                }
3362            }
3363            #[automatically_derived]
3364            #[doc(hidden)]
3365            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3366            for removeAppointeeReturn {
3367                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3368                    Self {}
3369                }
3370            }
3371        }
3372        impl removeAppointeeReturn {
3373            fn _tokenize(
3374                &self,
3375            ) -> <removeAppointeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3376                ()
3377            }
3378        }
3379        #[automatically_derived]
3380        impl alloy_sol_types::SolCall for removeAppointeeCall {
3381            type Parameters<'a> = (
3382                alloy::sol_types::sol_data::Address,
3383                alloy::sol_types::sol_data::Address,
3384                alloy::sol_types::sol_data::FixedBytes<4>,
3385            );
3386            type Token<'a> = <Self::Parameters<
3387                'a,
3388            > as alloy_sol_types::SolType>::Token<'a>;
3389            type Return = removeAppointeeReturn;
3390            type ReturnTuple<'a> = ();
3391            type ReturnToken<'a> = <Self::ReturnTuple<
3392                'a,
3393            > as alloy_sol_types::SolType>::Token<'a>;
3394            const SIGNATURE: &'static str = "removeAppointee(address,address,bytes4)";
3395            const SELECTOR: [u8; 4] = [186u8, 85u8, 8u8, 128u8];
3396            #[inline]
3397            fn new<'a>(
3398                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3399            ) -> Self {
3400                tuple.into()
3401            }
3402            #[inline]
3403            fn tokenize(&self) -> Self::Token<'_> {
3404                (
3405                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3406                        &self.appointee,
3407                    ),
3408                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3409                        &self.target,
3410                    ),
3411                    <alloy::sol_types::sol_data::FixedBytes<
3412                        4,
3413                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
3414                )
3415            }
3416            #[inline]
3417            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3418                removeAppointeeReturn::_tokenize(ret)
3419            }
3420            #[inline]
3421            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3422                <Self::ReturnTuple<
3423                    '_,
3424                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3425                    .map(Into::into)
3426            }
3427            #[inline]
3428            fn abi_decode_returns_validate(
3429                data: &[u8],
3430            ) -> alloy_sol_types::Result<Self::Return> {
3431                <Self::ReturnTuple<
3432                    '_,
3433                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3434                    .map(Into::into)
3435            }
3436        }
3437    };
3438    #[derive(serde::Serialize, serde::Deserialize)]
3439    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3440    /**Function with signature `removePendingAdmin(address)` and selector `0x9da16d8e`.
3441```solidity
3442function removePendingAdmin(address pendingAdmin) external;
3443```*/
3444    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3445    #[derive(Clone)]
3446    pub struct removePendingAdminCall {
3447        #[allow(missing_docs)]
3448        pub pendingAdmin: alloy::sol_types::private::Address,
3449    }
3450    ///Container type for the return parameters of the [`removePendingAdmin(address)`](removePendingAdminCall) function.
3451    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3452    #[derive(Clone)]
3453    pub struct removePendingAdminReturn {}
3454    #[allow(
3455        non_camel_case_types,
3456        non_snake_case,
3457        clippy::pub_underscore_fields,
3458        clippy::style
3459    )]
3460    const _: () = {
3461        use alloy::sol_types as alloy_sol_types;
3462        {
3463            #[doc(hidden)]
3464            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3465            #[doc(hidden)]
3466            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3467            #[cfg(test)]
3468            #[allow(dead_code, unreachable_patterns)]
3469            fn _type_assertion(
3470                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3471            ) {
3472                match _t {
3473                    alloy_sol_types::private::AssertTypeEq::<
3474                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3475                    >(_) => {}
3476                }
3477            }
3478            #[automatically_derived]
3479            #[doc(hidden)]
3480            impl ::core::convert::From<removePendingAdminCall>
3481            for UnderlyingRustTuple<'_> {
3482                fn from(value: removePendingAdminCall) -> Self {
3483                    (value.pendingAdmin,)
3484                }
3485            }
3486            #[automatically_derived]
3487            #[doc(hidden)]
3488            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3489            for removePendingAdminCall {
3490                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3491                    Self { pendingAdmin: tuple.0 }
3492                }
3493            }
3494        }
3495        {
3496            #[doc(hidden)]
3497            type UnderlyingSolTuple<'a> = ();
3498            #[doc(hidden)]
3499            type UnderlyingRustTuple<'a> = ();
3500            #[cfg(test)]
3501            #[allow(dead_code, unreachable_patterns)]
3502            fn _type_assertion(
3503                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3504            ) {
3505                match _t {
3506                    alloy_sol_types::private::AssertTypeEq::<
3507                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3508                    >(_) => {}
3509                }
3510            }
3511            #[automatically_derived]
3512            #[doc(hidden)]
3513            impl ::core::convert::From<removePendingAdminReturn>
3514            for UnderlyingRustTuple<'_> {
3515                fn from(value: removePendingAdminReturn) -> Self {
3516                    ()
3517                }
3518            }
3519            #[automatically_derived]
3520            #[doc(hidden)]
3521            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3522            for removePendingAdminReturn {
3523                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3524                    Self {}
3525                }
3526            }
3527        }
3528        impl removePendingAdminReturn {
3529            fn _tokenize(
3530                &self,
3531            ) -> <removePendingAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3532                ()
3533            }
3534        }
3535        #[automatically_derived]
3536        impl alloy_sol_types::SolCall for removePendingAdminCall {
3537            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3538            type Token<'a> = <Self::Parameters<
3539                'a,
3540            > as alloy_sol_types::SolType>::Token<'a>;
3541            type Return = removePendingAdminReturn;
3542            type ReturnTuple<'a> = ();
3543            type ReturnToken<'a> = <Self::ReturnTuple<
3544                'a,
3545            > as alloy_sol_types::SolType>::Token<'a>;
3546            const SIGNATURE: &'static str = "removePendingAdmin(address)";
3547            const SELECTOR: [u8; 4] = [157u8, 161u8, 109u8, 142u8];
3548            #[inline]
3549            fn new<'a>(
3550                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3551            ) -> Self {
3552                tuple.into()
3553            }
3554            #[inline]
3555            fn tokenize(&self) -> Self::Token<'_> {
3556                (
3557                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3558                        &self.pendingAdmin,
3559                    ),
3560                )
3561            }
3562            #[inline]
3563            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3564                removePendingAdminReturn::_tokenize(ret)
3565            }
3566            #[inline]
3567            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3568                <Self::ReturnTuple<
3569                    '_,
3570                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3571                    .map(Into::into)
3572            }
3573            #[inline]
3574            fn abi_decode_returns_validate(
3575                data: &[u8],
3576            ) -> alloy_sol_types::Result<Self::Return> {
3577                <Self::ReturnTuple<
3578                    '_,
3579                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3580                    .map(Into::into)
3581            }
3582        }
3583    };
3584    #[derive(serde::Serialize, serde::Deserialize)]
3585    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3586    /**Function with signature `setAppointee(address,address,bytes4)` and selector `0x1fdb0cfd`.
3587```solidity
3588function setAppointee(address appointee, address target, bytes4 selector) external;
3589```*/
3590    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3591    #[derive(Clone)]
3592    pub struct setAppointeeCall {
3593        #[allow(missing_docs)]
3594        pub appointee: alloy::sol_types::private::Address,
3595        #[allow(missing_docs)]
3596        pub target: alloy::sol_types::private::Address,
3597        #[allow(missing_docs)]
3598        pub selector: alloy::sol_types::private::FixedBytes<4>,
3599    }
3600    ///Container type for the return parameters of the [`setAppointee(address,address,bytes4)`](setAppointeeCall) function.
3601    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3602    #[derive(Clone)]
3603    pub struct setAppointeeReturn {}
3604    #[allow(
3605        non_camel_case_types,
3606        non_snake_case,
3607        clippy::pub_underscore_fields,
3608        clippy::style
3609    )]
3610    const _: () = {
3611        use alloy::sol_types as alloy_sol_types;
3612        {
3613            #[doc(hidden)]
3614            type UnderlyingSolTuple<'a> = (
3615                alloy::sol_types::sol_data::Address,
3616                alloy::sol_types::sol_data::Address,
3617                alloy::sol_types::sol_data::FixedBytes<4>,
3618            );
3619            #[doc(hidden)]
3620            type UnderlyingRustTuple<'a> = (
3621                alloy::sol_types::private::Address,
3622                alloy::sol_types::private::Address,
3623                alloy::sol_types::private::FixedBytes<4>,
3624            );
3625            #[cfg(test)]
3626            #[allow(dead_code, unreachable_patterns)]
3627            fn _type_assertion(
3628                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3629            ) {
3630                match _t {
3631                    alloy_sol_types::private::AssertTypeEq::<
3632                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3633                    >(_) => {}
3634                }
3635            }
3636            #[automatically_derived]
3637            #[doc(hidden)]
3638            impl ::core::convert::From<setAppointeeCall> for UnderlyingRustTuple<'_> {
3639                fn from(value: setAppointeeCall) -> Self {
3640                    (value.appointee, value.target, value.selector)
3641                }
3642            }
3643            #[automatically_derived]
3644            #[doc(hidden)]
3645            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeCall {
3646                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3647                    Self {
3648                        appointee: tuple.0,
3649                        target: tuple.1,
3650                        selector: tuple.2,
3651                    }
3652                }
3653            }
3654        }
3655        {
3656            #[doc(hidden)]
3657            type UnderlyingSolTuple<'a> = ();
3658            #[doc(hidden)]
3659            type UnderlyingRustTuple<'a> = ();
3660            #[cfg(test)]
3661            #[allow(dead_code, unreachable_patterns)]
3662            fn _type_assertion(
3663                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3664            ) {
3665                match _t {
3666                    alloy_sol_types::private::AssertTypeEq::<
3667                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3668                    >(_) => {}
3669                }
3670            }
3671            #[automatically_derived]
3672            #[doc(hidden)]
3673            impl ::core::convert::From<setAppointeeReturn> for UnderlyingRustTuple<'_> {
3674                fn from(value: setAppointeeReturn) -> Self {
3675                    ()
3676                }
3677            }
3678            #[automatically_derived]
3679            #[doc(hidden)]
3680            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeReturn {
3681                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3682                    Self {}
3683                }
3684            }
3685        }
3686        impl setAppointeeReturn {
3687            fn _tokenize(
3688                &self,
3689            ) -> <setAppointeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3690                ()
3691            }
3692        }
3693        #[automatically_derived]
3694        impl alloy_sol_types::SolCall for setAppointeeCall {
3695            type Parameters<'a> = (
3696                alloy::sol_types::sol_data::Address,
3697                alloy::sol_types::sol_data::Address,
3698                alloy::sol_types::sol_data::FixedBytes<4>,
3699            );
3700            type Token<'a> = <Self::Parameters<
3701                'a,
3702            > as alloy_sol_types::SolType>::Token<'a>;
3703            type Return = setAppointeeReturn;
3704            type ReturnTuple<'a> = ();
3705            type ReturnToken<'a> = <Self::ReturnTuple<
3706                'a,
3707            > as alloy_sol_types::SolType>::Token<'a>;
3708            const SIGNATURE: &'static str = "setAppointee(address,address,bytes4)";
3709            const SELECTOR: [u8; 4] = [31u8, 219u8, 12u8, 253u8];
3710            #[inline]
3711            fn new<'a>(
3712                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3713            ) -> Self {
3714                tuple.into()
3715            }
3716            #[inline]
3717            fn tokenize(&self) -> Self::Token<'_> {
3718                (
3719                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3720                        &self.appointee,
3721                    ),
3722                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3723                        &self.target,
3724                    ),
3725                    <alloy::sol_types::sol_data::FixedBytes<
3726                        4,
3727                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
3728                )
3729            }
3730            #[inline]
3731            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3732                setAppointeeReturn::_tokenize(ret)
3733            }
3734            #[inline]
3735            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3736                <Self::ReturnTuple<
3737                    '_,
3738                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3739                    .map(Into::into)
3740            }
3741            #[inline]
3742            fn abi_decode_returns_validate(
3743                data: &[u8],
3744            ) -> alloy_sol_types::Result<Self::Return> {
3745                <Self::ReturnTuple<
3746                    '_,
3747                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3748                    .map(Into::into)
3749            }
3750        }
3751    };
3752    #[derive(serde::Serialize, serde::Deserialize)]
3753    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3754    /**Function with signature `updateAVSMetadataURI(string)` and selector `0xa98fb355`.
3755```solidity
3756function updateAVSMetadataURI(string memory metadataURI) external;
3757```*/
3758    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3759    #[derive(Clone)]
3760    pub struct updateAVSMetadataURICall {
3761        #[allow(missing_docs)]
3762        pub metadataURI: alloy::sol_types::private::String,
3763    }
3764    ///Container type for the return parameters of the [`updateAVSMetadataURI(string)`](updateAVSMetadataURICall) function.
3765    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3766    #[derive(Clone)]
3767    pub struct updateAVSMetadataURIReturn {}
3768    #[allow(
3769        non_camel_case_types,
3770        non_snake_case,
3771        clippy::pub_underscore_fields,
3772        clippy::style
3773    )]
3774    const _: () = {
3775        use alloy::sol_types as alloy_sol_types;
3776        {
3777            #[doc(hidden)]
3778            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
3779            #[doc(hidden)]
3780            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
3781            #[cfg(test)]
3782            #[allow(dead_code, unreachable_patterns)]
3783            fn _type_assertion(
3784                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3785            ) {
3786                match _t {
3787                    alloy_sol_types::private::AssertTypeEq::<
3788                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3789                    >(_) => {}
3790                }
3791            }
3792            #[automatically_derived]
3793            #[doc(hidden)]
3794            impl ::core::convert::From<updateAVSMetadataURICall>
3795            for UnderlyingRustTuple<'_> {
3796                fn from(value: updateAVSMetadataURICall) -> Self {
3797                    (value.metadataURI,)
3798                }
3799            }
3800            #[automatically_derived]
3801            #[doc(hidden)]
3802            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3803            for updateAVSMetadataURICall {
3804                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3805                    Self { metadataURI: tuple.0 }
3806                }
3807            }
3808        }
3809        {
3810            #[doc(hidden)]
3811            type UnderlyingSolTuple<'a> = ();
3812            #[doc(hidden)]
3813            type UnderlyingRustTuple<'a> = ();
3814            #[cfg(test)]
3815            #[allow(dead_code, unreachable_patterns)]
3816            fn _type_assertion(
3817                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3818            ) {
3819                match _t {
3820                    alloy_sol_types::private::AssertTypeEq::<
3821                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3822                    >(_) => {}
3823                }
3824            }
3825            #[automatically_derived]
3826            #[doc(hidden)]
3827            impl ::core::convert::From<updateAVSMetadataURIReturn>
3828            for UnderlyingRustTuple<'_> {
3829                fn from(value: updateAVSMetadataURIReturn) -> Self {
3830                    ()
3831                }
3832            }
3833            #[automatically_derived]
3834            #[doc(hidden)]
3835            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3836            for updateAVSMetadataURIReturn {
3837                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3838                    Self {}
3839                }
3840            }
3841        }
3842        impl updateAVSMetadataURIReturn {
3843            fn _tokenize(
3844                &self,
3845            ) -> <updateAVSMetadataURICall as alloy_sol_types::SolCall>::ReturnToken<
3846                '_,
3847            > {
3848                ()
3849            }
3850        }
3851        #[automatically_derived]
3852        impl alloy_sol_types::SolCall for updateAVSMetadataURICall {
3853            type Parameters<'a> = (alloy::sol_types::sol_data::String,);
3854            type Token<'a> = <Self::Parameters<
3855                'a,
3856            > as alloy_sol_types::SolType>::Token<'a>;
3857            type Return = updateAVSMetadataURIReturn;
3858            type ReturnTuple<'a> = ();
3859            type ReturnToken<'a> = <Self::ReturnTuple<
3860                'a,
3861            > as alloy_sol_types::SolType>::Token<'a>;
3862            const SIGNATURE: &'static str = "updateAVSMetadataURI(string)";
3863            const SELECTOR: [u8; 4] = [169u8, 143u8, 179u8, 85u8];
3864            #[inline]
3865            fn new<'a>(
3866                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3867            ) -> Self {
3868                tuple.into()
3869            }
3870            #[inline]
3871            fn tokenize(&self) -> Self::Token<'_> {
3872                (
3873                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
3874                        &self.metadataURI,
3875                    ),
3876                )
3877            }
3878            #[inline]
3879            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3880                updateAVSMetadataURIReturn::_tokenize(ret)
3881            }
3882            #[inline]
3883            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3884                <Self::ReturnTuple<
3885                    '_,
3886                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3887                    .map(Into::into)
3888            }
3889            #[inline]
3890            fn abi_decode_returns_validate(
3891                data: &[u8],
3892            ) -> alloy_sol_types::Result<Self::Return> {
3893                <Self::ReturnTuple<
3894                    '_,
3895                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3896                    .map(Into::into)
3897            }
3898        }
3899    };
3900    ///Container for all the [`IServiceManager`](self) function calls.
3901    #[derive(serde::Serialize, serde::Deserialize)]
3902    #[derive()]
3903    pub enum IServiceManagerCalls {
3904        #[allow(missing_docs)]
3905        addPendingAdmin(addPendingAdminCall),
3906        #[allow(missing_docs)]
3907        avsDirectory(avsDirectoryCall),
3908        #[allow(missing_docs)]
3909        createAVSRewardsSubmission(createAVSRewardsSubmissionCall),
3910        #[allow(missing_docs)]
3911        deregisterOperatorFromAVS(deregisterOperatorFromAVSCall),
3912        #[allow(missing_docs)]
3913        deregisterOperatorFromOperatorSets(deregisterOperatorFromOperatorSetsCall),
3914        #[allow(missing_docs)]
3915        getOperatorRestakedStrategies(getOperatorRestakedStrategiesCall),
3916        #[allow(missing_docs)]
3917        getRestakeableStrategies(getRestakeableStrategiesCall),
3918        #[allow(missing_docs)]
3919        registerOperatorToAVS(registerOperatorToAVSCall),
3920        #[allow(missing_docs)]
3921        removeAdmin(removeAdminCall),
3922        #[allow(missing_docs)]
3923        removeAppointee(removeAppointeeCall),
3924        #[allow(missing_docs)]
3925        removePendingAdmin(removePendingAdminCall),
3926        #[allow(missing_docs)]
3927        setAppointee(setAppointeeCall),
3928        #[allow(missing_docs)]
3929        updateAVSMetadataURI(updateAVSMetadataURICall),
3930    }
3931    #[automatically_derived]
3932    impl IServiceManagerCalls {
3933        /// All the selectors of this enum.
3934        ///
3935        /// Note that the selectors might not be in the same order as the variants.
3936        /// No guarantees are made about the order of the selectors.
3937        ///
3938        /// Prefer using `SolInterface` methods instead.
3939        pub const SELECTORS: &'static [[u8; 4usize]] = &[
3940            [23u8, 133u8, 245u8, 60u8],
3941            [31u8, 219u8, 12u8, 253u8],
3942            [39u8, 148u8, 50u8, 235u8],
3943            [51u8, 207u8, 183u8, 183u8],
3944            [107u8, 58u8, 167u8, 46u8],
3945            [153u8, 38u8, 238u8, 125u8],
3946            [157u8, 161u8, 109u8, 142u8],
3947            [163u8, 100u8, 244u8, 218u8],
3948            [169u8, 143u8, 179u8, 85u8],
3949            [186u8, 85u8, 8u8, 128u8],
3950            [193u8, 168u8, 226u8, 197u8],
3951            [228u8, 129u8, 175u8, 157u8],
3952            [252u8, 227u8, 108u8, 125u8],
3953        ];
3954    }
3955    #[automatically_derived]
3956    impl alloy_sol_types::SolInterface for IServiceManagerCalls {
3957        const NAME: &'static str = "IServiceManagerCalls";
3958        const MIN_DATA_LENGTH: usize = 0usize;
3959        const COUNT: usize = 13usize;
3960        #[inline]
3961        fn selector(&self) -> [u8; 4] {
3962            match self {
3963                Self::addPendingAdmin(_) => {
3964                    <addPendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
3965                }
3966                Self::avsDirectory(_) => {
3967                    <avsDirectoryCall as alloy_sol_types::SolCall>::SELECTOR
3968                }
3969                Self::createAVSRewardsSubmission(_) => {
3970                    <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::SELECTOR
3971                }
3972                Self::deregisterOperatorFromAVS(_) => {
3973                    <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::SELECTOR
3974                }
3975                Self::deregisterOperatorFromOperatorSets(_) => {
3976                    <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
3977                }
3978                Self::getOperatorRestakedStrategies(_) => {
3979                    <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::SELECTOR
3980                }
3981                Self::getRestakeableStrategies(_) => {
3982                    <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::SELECTOR
3983                }
3984                Self::registerOperatorToAVS(_) => {
3985                    <registerOperatorToAVSCall as alloy_sol_types::SolCall>::SELECTOR
3986                }
3987                Self::removeAdmin(_) => {
3988                    <removeAdminCall as alloy_sol_types::SolCall>::SELECTOR
3989                }
3990                Self::removeAppointee(_) => {
3991                    <removeAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
3992                }
3993                Self::removePendingAdmin(_) => {
3994                    <removePendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
3995                }
3996                Self::setAppointee(_) => {
3997                    <setAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
3998                }
3999                Self::updateAVSMetadataURI(_) => {
4000                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::SELECTOR
4001                }
4002            }
4003        }
4004        #[inline]
4005        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4006            Self::SELECTORS.get(i).copied()
4007        }
4008        #[inline]
4009        fn valid_selector(selector: [u8; 4]) -> bool {
4010            Self::SELECTORS.binary_search(&selector).is_ok()
4011        }
4012        #[inline]
4013        #[allow(non_snake_case)]
4014        fn abi_decode_raw(
4015            selector: [u8; 4],
4016            data: &[u8],
4017        ) -> alloy_sol_types::Result<Self> {
4018            static DECODE_SHIMS: &[fn(
4019                &[u8],
4020            ) -> alloy_sol_types::Result<IServiceManagerCalls>] = &[
4021                {
4022                    fn removeAdmin(
4023                        data: &[u8],
4024                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4025                        <removeAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4026                                data,
4027                            )
4028                            .map(IServiceManagerCalls::removeAdmin)
4029                    }
4030                    removeAdmin
4031                },
4032                {
4033                    fn setAppointee(
4034                        data: &[u8],
4035                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4036                        <setAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4037                                data,
4038                            )
4039                            .map(IServiceManagerCalls::setAppointee)
4040                    }
4041                    setAppointee
4042                },
4043                {
4044                    fn addPendingAdmin(
4045                        data: &[u8],
4046                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4047                        <addPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4048                                data,
4049                            )
4050                            .map(IServiceManagerCalls::addPendingAdmin)
4051                    }
4052                    addPendingAdmin
4053                },
4054                {
4055                    fn getOperatorRestakedStrategies(
4056                        data: &[u8],
4057                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4058                        <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
4059                                data,
4060                            )
4061                            .map(IServiceManagerCalls::getOperatorRestakedStrategies)
4062                    }
4063                    getOperatorRestakedStrategies
4064                },
4065                {
4066                    fn avsDirectory(
4067                        data: &[u8],
4068                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4069                        <avsDirectoryCall as alloy_sol_types::SolCall>::abi_decode_raw(
4070                                data,
4071                            )
4072                            .map(IServiceManagerCalls::avsDirectory)
4073                    }
4074                    avsDirectory
4075                },
4076                {
4077                    fn registerOperatorToAVS(
4078                        data: &[u8],
4079                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4080                        <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
4081                                data,
4082                            )
4083                            .map(IServiceManagerCalls::registerOperatorToAVS)
4084                    }
4085                    registerOperatorToAVS
4086                },
4087                {
4088                    fn removePendingAdmin(
4089                        data: &[u8],
4090                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4091                        <removePendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4092                                data,
4093                            )
4094                            .map(IServiceManagerCalls::removePendingAdmin)
4095                    }
4096                    removePendingAdmin
4097                },
4098                {
4099                    fn deregisterOperatorFromAVS(
4100                        data: &[u8],
4101                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4102                        <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
4103                                data,
4104                            )
4105                            .map(IServiceManagerCalls::deregisterOperatorFromAVS)
4106                    }
4107                    deregisterOperatorFromAVS
4108                },
4109                {
4110                    fn updateAVSMetadataURI(
4111                        data: &[u8],
4112                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4113                        <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw(
4114                                data,
4115                            )
4116                            .map(IServiceManagerCalls::updateAVSMetadataURI)
4117                    }
4118                    updateAVSMetadataURI
4119                },
4120                {
4121                    fn removeAppointee(
4122                        data: &[u8],
4123                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4124                        <removeAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4125                                data,
4126                            )
4127                            .map(IServiceManagerCalls::removeAppointee)
4128                    }
4129                    removeAppointee
4130                },
4131                {
4132                    fn deregisterOperatorFromOperatorSets(
4133                        data: &[u8],
4134                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4135                        <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4136                                data,
4137                            )
4138                            .map(
4139                                IServiceManagerCalls::deregisterOperatorFromOperatorSets,
4140                            )
4141                    }
4142                    deregisterOperatorFromOperatorSets
4143                },
4144                {
4145                    fn getRestakeableStrategies(
4146                        data: &[u8],
4147                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4148                        <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
4149                                data,
4150                            )
4151                            .map(IServiceManagerCalls::getRestakeableStrategies)
4152                    }
4153                    getRestakeableStrategies
4154                },
4155                {
4156                    fn createAVSRewardsSubmission(
4157                        data: &[u8],
4158                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4159                        <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_decode_raw(
4160                                data,
4161                            )
4162                            .map(IServiceManagerCalls::createAVSRewardsSubmission)
4163                    }
4164                    createAVSRewardsSubmission
4165                },
4166            ];
4167            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4168                return Err(
4169                    alloy_sol_types::Error::unknown_selector(
4170                        <Self as alloy_sol_types::SolInterface>::NAME,
4171                        selector,
4172                    ),
4173                );
4174            };
4175            DECODE_SHIMS[idx](data)
4176        }
4177        #[inline]
4178        #[allow(non_snake_case)]
4179        fn abi_decode_raw_validate(
4180            selector: [u8; 4],
4181            data: &[u8],
4182        ) -> alloy_sol_types::Result<Self> {
4183            static DECODE_VALIDATE_SHIMS: &[fn(
4184                &[u8],
4185            ) -> alloy_sol_types::Result<IServiceManagerCalls>] = &[
4186                {
4187                    fn removeAdmin(
4188                        data: &[u8],
4189                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4190                        <removeAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4191                                data,
4192                            )
4193                            .map(IServiceManagerCalls::removeAdmin)
4194                    }
4195                    removeAdmin
4196                },
4197                {
4198                    fn setAppointee(
4199                        data: &[u8],
4200                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4201                        <setAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4202                                data,
4203                            )
4204                            .map(IServiceManagerCalls::setAppointee)
4205                    }
4206                    setAppointee
4207                },
4208                {
4209                    fn addPendingAdmin(
4210                        data: &[u8],
4211                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4212                        <addPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4213                                data,
4214                            )
4215                            .map(IServiceManagerCalls::addPendingAdmin)
4216                    }
4217                    addPendingAdmin
4218                },
4219                {
4220                    fn getOperatorRestakedStrategies(
4221                        data: &[u8],
4222                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4223                        <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4224                                data,
4225                            )
4226                            .map(IServiceManagerCalls::getOperatorRestakedStrategies)
4227                    }
4228                    getOperatorRestakedStrategies
4229                },
4230                {
4231                    fn avsDirectory(
4232                        data: &[u8],
4233                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4234                        <avsDirectoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4235                                data,
4236                            )
4237                            .map(IServiceManagerCalls::avsDirectory)
4238                    }
4239                    avsDirectory
4240                },
4241                {
4242                    fn registerOperatorToAVS(
4243                        data: &[u8],
4244                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4245                        <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4246                                data,
4247                            )
4248                            .map(IServiceManagerCalls::registerOperatorToAVS)
4249                    }
4250                    registerOperatorToAVS
4251                },
4252                {
4253                    fn removePendingAdmin(
4254                        data: &[u8],
4255                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4256                        <removePendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4257                                data,
4258                            )
4259                            .map(IServiceManagerCalls::removePendingAdmin)
4260                    }
4261                    removePendingAdmin
4262                },
4263                {
4264                    fn deregisterOperatorFromAVS(
4265                        data: &[u8],
4266                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4267                        <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4268                                data,
4269                            )
4270                            .map(IServiceManagerCalls::deregisterOperatorFromAVS)
4271                    }
4272                    deregisterOperatorFromAVS
4273                },
4274                {
4275                    fn updateAVSMetadataURI(
4276                        data: &[u8],
4277                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4278                        <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4279                                data,
4280                            )
4281                            .map(IServiceManagerCalls::updateAVSMetadataURI)
4282                    }
4283                    updateAVSMetadataURI
4284                },
4285                {
4286                    fn removeAppointee(
4287                        data: &[u8],
4288                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4289                        <removeAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4290                                data,
4291                            )
4292                            .map(IServiceManagerCalls::removeAppointee)
4293                    }
4294                    removeAppointee
4295                },
4296                {
4297                    fn deregisterOperatorFromOperatorSets(
4298                        data: &[u8],
4299                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4300                        <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4301                                data,
4302                            )
4303                            .map(
4304                                IServiceManagerCalls::deregisterOperatorFromOperatorSets,
4305                            )
4306                    }
4307                    deregisterOperatorFromOperatorSets
4308                },
4309                {
4310                    fn getRestakeableStrategies(
4311                        data: &[u8],
4312                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4313                        <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4314                                data,
4315                            )
4316                            .map(IServiceManagerCalls::getRestakeableStrategies)
4317                    }
4318                    getRestakeableStrategies
4319                },
4320                {
4321                    fn createAVSRewardsSubmission(
4322                        data: &[u8],
4323                    ) -> alloy_sol_types::Result<IServiceManagerCalls> {
4324                        <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4325                                data,
4326                            )
4327                            .map(IServiceManagerCalls::createAVSRewardsSubmission)
4328                    }
4329                    createAVSRewardsSubmission
4330                },
4331            ];
4332            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4333                return Err(
4334                    alloy_sol_types::Error::unknown_selector(
4335                        <Self as alloy_sol_types::SolInterface>::NAME,
4336                        selector,
4337                    ),
4338                );
4339            };
4340            DECODE_VALIDATE_SHIMS[idx](data)
4341        }
4342        #[inline]
4343        fn abi_encoded_size(&self) -> usize {
4344            match self {
4345                Self::addPendingAdmin(inner) => {
4346                    <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4347                        inner,
4348                    )
4349                }
4350                Self::avsDirectory(inner) => {
4351                    <avsDirectoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
4352                        inner,
4353                    )
4354                }
4355                Self::createAVSRewardsSubmission(inner) => {
4356                    <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_encoded_size(
4357                        inner,
4358                    )
4359                }
4360                Self::deregisterOperatorFromAVS(inner) => {
4361                    <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(
4362                        inner,
4363                    )
4364                }
4365                Self::deregisterOperatorFromOperatorSets(inner) => {
4366                    <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
4367                        inner,
4368                    )
4369                }
4370                Self::getOperatorRestakedStrategies(inner) => {
4371                    <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
4372                        inner,
4373                    )
4374                }
4375                Self::getRestakeableStrategies(inner) => {
4376                    <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
4377                        inner,
4378                    )
4379                }
4380                Self::registerOperatorToAVS(inner) => {
4381                    <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(
4382                        inner,
4383                    )
4384                }
4385                Self::removeAdmin(inner) => {
4386                    <removeAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4387                        inner,
4388                    )
4389                }
4390                Self::removeAppointee(inner) => {
4391                    <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
4392                        inner,
4393                    )
4394                }
4395                Self::removePendingAdmin(inner) => {
4396                    <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
4397                        inner,
4398                    )
4399                }
4400                Self::setAppointee(inner) => {
4401                    <setAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
4402                        inner,
4403                    )
4404                }
4405                Self::updateAVSMetadataURI(inner) => {
4406                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encoded_size(
4407                        inner,
4408                    )
4409                }
4410            }
4411        }
4412        #[inline]
4413        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4414            match self {
4415                Self::addPendingAdmin(inner) => {
4416                    <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4417                        inner,
4418                        out,
4419                    )
4420                }
4421                Self::avsDirectory(inner) => {
4422                    <avsDirectoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
4423                        inner,
4424                        out,
4425                    )
4426                }
4427                Self::createAVSRewardsSubmission(inner) => {
4428                    <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_encode_raw(
4429                        inner,
4430                        out,
4431                    )
4432                }
4433                Self::deregisterOperatorFromAVS(inner) => {
4434                    <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(
4435                        inner,
4436                        out,
4437                    )
4438                }
4439                Self::deregisterOperatorFromOperatorSets(inner) => {
4440                    <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
4441                        inner,
4442                        out,
4443                    )
4444                }
4445                Self::getOperatorRestakedStrategies(inner) => {
4446                    <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
4447                        inner,
4448                        out,
4449                    )
4450                }
4451                Self::getRestakeableStrategies(inner) => {
4452                    <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
4453                        inner,
4454                        out,
4455                    )
4456                }
4457                Self::registerOperatorToAVS(inner) => {
4458                    <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(
4459                        inner,
4460                        out,
4461                    )
4462                }
4463                Self::removeAdmin(inner) => {
4464                    <removeAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4465                        inner,
4466                        out,
4467                    )
4468                }
4469                Self::removeAppointee(inner) => {
4470                    <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4471                        inner,
4472                        out,
4473                    )
4474                }
4475                Self::removePendingAdmin(inner) => {
4476                    <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
4477                        inner,
4478                        out,
4479                    )
4480                }
4481                Self::setAppointee(inner) => {
4482                    <setAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4483                        inner,
4484                        out,
4485                    )
4486                }
4487                Self::updateAVSMetadataURI(inner) => {
4488                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encode_raw(
4489                        inner,
4490                        out,
4491                    )
4492                }
4493            }
4494        }
4495    }
4496    ///Container for all the [`IServiceManager`](self) custom errors.
4497    #[derive(serde::Serialize, serde::Deserialize)]
4498    #[derive(Debug, PartialEq, Eq, Hash)]
4499    pub enum IServiceManagerErrors {
4500        #[allow(missing_docs)]
4501        DelayPeriodNotPassed(DelayPeriodNotPassed),
4502        #[allow(missing_docs)]
4503        OnlyRegistryCoordinator(OnlyRegistryCoordinator),
4504        #[allow(missing_docs)]
4505        OnlyRewardsInitiator(OnlyRewardsInitiator),
4506        #[allow(missing_docs)]
4507        OnlyStakeRegistry(OnlyStakeRegistry),
4508    }
4509    #[automatically_derived]
4510    impl IServiceManagerErrors {
4511        /// All the selectors of this enum.
4512        ///
4513        /// Note that the selectors might not be in the same order as the variants.
4514        /// No guarantees are made about the order of the selectors.
4515        ///
4516        /// Prefer using `SolInterface` methods instead.
4517        pub const SELECTORS: &'static [[u8; 4usize]] = &[
4518            [70u8, 191u8, 34u8, 129u8],
4519            [135u8, 41u8, 183u8, 190u8],
4520            [142u8, 121u8, 253u8, 181u8],
4521            [251u8, 98u8, 59u8, 4u8],
4522        ];
4523    }
4524    #[automatically_derived]
4525    impl alloy_sol_types::SolInterface for IServiceManagerErrors {
4526        const NAME: &'static str = "IServiceManagerErrors";
4527        const MIN_DATA_LENGTH: usize = 0usize;
4528        const COUNT: usize = 4usize;
4529        #[inline]
4530        fn selector(&self) -> [u8; 4] {
4531            match self {
4532                Self::DelayPeriodNotPassed(_) => {
4533                    <DelayPeriodNotPassed as alloy_sol_types::SolError>::SELECTOR
4534                }
4535                Self::OnlyRegistryCoordinator(_) => {
4536                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::SELECTOR
4537                }
4538                Self::OnlyRewardsInitiator(_) => {
4539                    <OnlyRewardsInitiator as alloy_sol_types::SolError>::SELECTOR
4540                }
4541                Self::OnlyStakeRegistry(_) => {
4542                    <OnlyStakeRegistry as alloy_sol_types::SolError>::SELECTOR
4543                }
4544            }
4545        }
4546        #[inline]
4547        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4548            Self::SELECTORS.get(i).copied()
4549        }
4550        #[inline]
4551        fn valid_selector(selector: [u8; 4]) -> bool {
4552            Self::SELECTORS.binary_search(&selector).is_ok()
4553        }
4554        #[inline]
4555        #[allow(non_snake_case)]
4556        fn abi_decode_raw(
4557            selector: [u8; 4],
4558            data: &[u8],
4559        ) -> alloy_sol_types::Result<Self> {
4560            static DECODE_SHIMS: &[fn(
4561                &[u8],
4562            ) -> alloy_sol_types::Result<IServiceManagerErrors>] = &[
4563                {
4564                    fn OnlyStakeRegistry(
4565                        data: &[u8],
4566                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4567                        <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_decode_raw(
4568                                data,
4569                            )
4570                            .map(IServiceManagerErrors::OnlyStakeRegistry)
4571                    }
4572                    OnlyStakeRegistry
4573                },
4574                {
4575                    fn OnlyRegistryCoordinator(
4576                        data: &[u8],
4577                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4578                        <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw(
4579                                data,
4580                            )
4581                            .map(IServiceManagerErrors::OnlyRegistryCoordinator)
4582                    }
4583                    OnlyRegistryCoordinator
4584                },
4585                {
4586                    fn OnlyRewardsInitiator(
4587                        data: &[u8],
4588                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4589                        <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_decode_raw(
4590                                data,
4591                            )
4592                            .map(IServiceManagerErrors::OnlyRewardsInitiator)
4593                    }
4594                    OnlyRewardsInitiator
4595                },
4596                {
4597                    fn DelayPeriodNotPassed(
4598                        data: &[u8],
4599                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4600                        <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_decode_raw(
4601                                data,
4602                            )
4603                            .map(IServiceManagerErrors::DelayPeriodNotPassed)
4604                    }
4605                    DelayPeriodNotPassed
4606                },
4607            ];
4608            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4609                return Err(
4610                    alloy_sol_types::Error::unknown_selector(
4611                        <Self as alloy_sol_types::SolInterface>::NAME,
4612                        selector,
4613                    ),
4614                );
4615            };
4616            DECODE_SHIMS[idx](data)
4617        }
4618        #[inline]
4619        #[allow(non_snake_case)]
4620        fn abi_decode_raw_validate(
4621            selector: [u8; 4],
4622            data: &[u8],
4623        ) -> alloy_sol_types::Result<Self> {
4624            static DECODE_VALIDATE_SHIMS: &[fn(
4625                &[u8],
4626            ) -> alloy_sol_types::Result<IServiceManagerErrors>] = &[
4627                {
4628                    fn OnlyStakeRegistry(
4629                        data: &[u8],
4630                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4631                        <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_decode_raw_validate(
4632                                data,
4633                            )
4634                            .map(IServiceManagerErrors::OnlyStakeRegistry)
4635                    }
4636                    OnlyStakeRegistry
4637                },
4638                {
4639                    fn OnlyRegistryCoordinator(
4640                        data: &[u8],
4641                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4642                        <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw_validate(
4643                                data,
4644                            )
4645                            .map(IServiceManagerErrors::OnlyRegistryCoordinator)
4646                    }
4647                    OnlyRegistryCoordinator
4648                },
4649                {
4650                    fn OnlyRewardsInitiator(
4651                        data: &[u8],
4652                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4653                        <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_decode_raw_validate(
4654                                data,
4655                            )
4656                            .map(IServiceManagerErrors::OnlyRewardsInitiator)
4657                    }
4658                    OnlyRewardsInitiator
4659                },
4660                {
4661                    fn DelayPeriodNotPassed(
4662                        data: &[u8],
4663                    ) -> alloy_sol_types::Result<IServiceManagerErrors> {
4664                        <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_decode_raw_validate(
4665                                data,
4666                            )
4667                            .map(IServiceManagerErrors::DelayPeriodNotPassed)
4668                    }
4669                    DelayPeriodNotPassed
4670                },
4671            ];
4672            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4673                return Err(
4674                    alloy_sol_types::Error::unknown_selector(
4675                        <Self as alloy_sol_types::SolInterface>::NAME,
4676                        selector,
4677                    ),
4678                );
4679            };
4680            DECODE_VALIDATE_SHIMS[idx](data)
4681        }
4682        #[inline]
4683        fn abi_encoded_size(&self) -> usize {
4684            match self {
4685                Self::DelayPeriodNotPassed(inner) => {
4686                    <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_encoded_size(
4687                        inner,
4688                    )
4689                }
4690                Self::OnlyRegistryCoordinator(inner) => {
4691                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_encoded_size(
4692                        inner,
4693                    )
4694                }
4695                Self::OnlyRewardsInitiator(inner) => {
4696                    <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_encoded_size(
4697                        inner,
4698                    )
4699                }
4700                Self::OnlyStakeRegistry(inner) => {
4701                    <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_encoded_size(
4702                        inner,
4703                    )
4704                }
4705            }
4706        }
4707        #[inline]
4708        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4709            match self {
4710                Self::DelayPeriodNotPassed(inner) => {
4711                    <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_encode_raw(
4712                        inner,
4713                        out,
4714                    )
4715                }
4716                Self::OnlyRegistryCoordinator(inner) => {
4717                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_encode_raw(
4718                        inner,
4719                        out,
4720                    )
4721                }
4722                Self::OnlyRewardsInitiator(inner) => {
4723                    <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_encode_raw(
4724                        inner,
4725                        out,
4726                    )
4727                }
4728                Self::OnlyStakeRegistry(inner) => {
4729                    <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_encode_raw(
4730                        inner,
4731                        out,
4732                    )
4733                }
4734            }
4735        }
4736    }
4737    ///Container for all the [`IServiceManager`](self) events.
4738    #[derive(serde::Serialize, serde::Deserialize)]
4739    #[derive(Debug, PartialEq, Eq, Hash)]
4740    pub enum IServiceManagerEvents {
4741        #[allow(missing_docs)]
4742        RewardsInitiatorUpdated(RewardsInitiatorUpdated),
4743    }
4744    #[automatically_derived]
4745    impl IServiceManagerEvents {
4746        /// All the selectors of this enum.
4747        ///
4748        /// Note that the selectors might not be in the same order as the variants.
4749        /// No guarantees are made about the order of the selectors.
4750        ///
4751        /// Prefer using `SolInterface` methods instead.
4752        pub const SELECTORS: &'static [[u8; 32usize]] = &[
4753            [
4754                225u8, 28u8, 221u8, 241u8, 129u8, 106u8, 67u8, 49u8, 140u8, 161u8, 117u8,
4755                187u8, 197u8, 44u8, 208u8, 24u8, 84u8, 54u8, 233u8, 203u8, 234u8, 215u8,
4756                200u8, 58u8, 204u8, 84u8, 167u8, 62u8, 70u8, 23u8, 23u8, 227u8,
4757            ],
4758        ];
4759    }
4760    #[automatically_derived]
4761    impl alloy_sol_types::SolEventInterface for IServiceManagerEvents {
4762        const NAME: &'static str = "IServiceManagerEvents";
4763        const COUNT: usize = 1usize;
4764        fn decode_raw_log(
4765            topics: &[alloy_sol_types::Word],
4766            data: &[u8],
4767        ) -> alloy_sol_types::Result<Self> {
4768            match topics.first().copied() {
4769                Some(
4770                    <RewardsInitiatorUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
4771                ) => {
4772                    <RewardsInitiatorUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
4773                            topics,
4774                            data,
4775                        )
4776                        .map(Self::RewardsInitiatorUpdated)
4777                }
4778                _ => {
4779                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
4780                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
4781                        log: alloy_sol_types::private::Box::new(
4782                            alloy_sol_types::private::LogData::new_unchecked(
4783                                topics.to_vec(),
4784                                data.to_vec().into(),
4785                            ),
4786                        ),
4787                    })
4788                }
4789            }
4790        }
4791    }
4792    #[automatically_derived]
4793    impl alloy_sol_types::private::IntoLogData for IServiceManagerEvents {
4794        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4795            match self {
4796                Self::RewardsInitiatorUpdated(inner) => {
4797                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
4798                }
4799            }
4800        }
4801        fn into_log_data(self) -> alloy_sol_types::private::LogData {
4802            match self {
4803                Self::RewardsInitiatorUpdated(inner) => {
4804                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
4805                }
4806            }
4807        }
4808    }
4809    use alloy::contract as alloy_contract;
4810    /**Creates a new wrapper around an on-chain [`IServiceManager`](self) contract instance.
4811
4812See the [wrapper's documentation](`IServiceManagerInstance`) for more details.*/
4813    #[inline]
4814    pub const fn new<
4815        P: alloy_contract::private::Provider<N>,
4816        N: alloy_contract::private::Network,
4817    >(
4818        address: alloy_sol_types::private::Address,
4819        provider: P,
4820    ) -> IServiceManagerInstance<P, N> {
4821        IServiceManagerInstance::<P, N>::new(address, provider)
4822    }
4823    /**Deploys this contract using the given `provider` and constructor arguments, if any.
4824
4825Returns a new instance of the contract, if the deployment was successful.
4826
4827For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
4828    #[inline]
4829    pub fn deploy<
4830        P: alloy_contract::private::Provider<N>,
4831        N: alloy_contract::private::Network,
4832    >(
4833        provider: P,
4834    ) -> impl ::core::future::Future<
4835        Output = alloy_contract::Result<IServiceManagerInstance<P, N>>,
4836    > {
4837        IServiceManagerInstance::<P, N>::deploy(provider)
4838    }
4839    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
4840and constructor arguments, if any.
4841
4842This is a simple wrapper around creating a `RawCallBuilder` with the data set to
4843the bytecode concatenated with the constructor's ABI-encoded arguments.*/
4844    #[inline]
4845    pub fn deploy_builder<
4846        P: alloy_contract::private::Provider<N>,
4847        N: alloy_contract::private::Network,
4848    >(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
4849        IServiceManagerInstance::<P, N>::deploy_builder(provider)
4850    }
4851    /**A [`IServiceManager`](self) instance.
4852
4853Contains type-safe methods for interacting with an on-chain instance of the
4854[`IServiceManager`](self) contract located at a given `address`, using a given
4855provider `P`.
4856
4857If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
4858documentation on how to provide it), the `deploy` and `deploy_builder` methods can
4859be used to deploy a new instance of the contract.
4860
4861See the [module-level documentation](self) for all the available methods.*/
4862    #[derive(Clone)]
4863    pub struct IServiceManagerInstance<P, N = alloy_contract::private::Ethereum> {
4864        address: alloy_sol_types::private::Address,
4865        provider: P,
4866        _network: ::core::marker::PhantomData<N>,
4867    }
4868    #[automatically_derived]
4869    impl<P, N> ::core::fmt::Debug for IServiceManagerInstance<P, N> {
4870        #[inline]
4871        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4872            f.debug_tuple("IServiceManagerInstance").field(&self.address).finish()
4873        }
4874    }
4875    /// Instantiation and getters/setters.
4876    #[automatically_derived]
4877    impl<
4878        P: alloy_contract::private::Provider<N>,
4879        N: alloy_contract::private::Network,
4880    > IServiceManagerInstance<P, N> {
4881        /**Creates a new wrapper around an on-chain [`IServiceManager`](self) contract instance.
4882
4883See the [wrapper's documentation](`IServiceManagerInstance`) for more details.*/
4884        #[inline]
4885        pub const fn new(
4886            address: alloy_sol_types::private::Address,
4887            provider: P,
4888        ) -> Self {
4889            Self {
4890                address,
4891                provider,
4892                _network: ::core::marker::PhantomData,
4893            }
4894        }
4895        /**Deploys this contract using the given `provider` and constructor arguments, if any.
4896
4897Returns a new instance of the contract, if the deployment was successful.
4898
4899For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
4900        #[inline]
4901        pub async fn deploy(
4902            provider: P,
4903        ) -> alloy_contract::Result<IServiceManagerInstance<P, N>> {
4904            let call_builder = Self::deploy_builder(provider);
4905            let contract_address = call_builder.deploy().await?;
4906            Ok(Self::new(contract_address, call_builder.provider))
4907        }
4908        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
4909and constructor arguments, if any.
4910
4911This is a simple wrapper around creating a `RawCallBuilder` with the data set to
4912the bytecode concatenated with the constructor's ABI-encoded arguments.*/
4913        #[inline]
4914        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
4915            alloy_contract::RawCallBuilder::new_raw_deploy(
4916                provider,
4917                ::core::clone::Clone::clone(&BYTECODE),
4918            )
4919        }
4920        /// Returns a reference to the address.
4921        #[inline]
4922        pub const fn address(&self) -> &alloy_sol_types::private::Address {
4923            &self.address
4924        }
4925        /// Sets the address.
4926        #[inline]
4927        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
4928            self.address = address;
4929        }
4930        /// Sets the address and returns `self`.
4931        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
4932            self.set_address(address);
4933            self
4934        }
4935        /// Returns a reference to the provider.
4936        #[inline]
4937        pub const fn provider(&self) -> &P {
4938            &self.provider
4939        }
4940    }
4941    impl<P: ::core::clone::Clone, N> IServiceManagerInstance<&P, N> {
4942        /// Clones the provider and returns a new instance with the cloned provider.
4943        #[inline]
4944        pub fn with_cloned_provider(self) -> IServiceManagerInstance<P, N> {
4945            IServiceManagerInstance {
4946                address: self.address,
4947                provider: ::core::clone::Clone::clone(&self.provider),
4948                _network: ::core::marker::PhantomData,
4949            }
4950        }
4951    }
4952    /// Function calls.
4953    #[automatically_derived]
4954    impl<
4955        P: alloy_contract::private::Provider<N>,
4956        N: alloy_contract::private::Network,
4957    > IServiceManagerInstance<P, N> {
4958        /// Creates a new call builder using this contract instance's provider and address.
4959        ///
4960        /// Note that the call can be any function call, not just those defined in this
4961        /// contract. Prefer using the other methods for building type-safe contract calls.
4962        pub fn call_builder<C: alloy_sol_types::SolCall>(
4963            &self,
4964            call: &C,
4965        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
4966            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
4967        }
4968        ///Creates a new call builder for the [`addPendingAdmin`] function.
4969        pub fn addPendingAdmin(
4970            &self,
4971            admin: alloy::sol_types::private::Address,
4972        ) -> alloy_contract::SolCallBuilder<&P, addPendingAdminCall, N> {
4973            self.call_builder(&addPendingAdminCall { admin })
4974        }
4975        ///Creates a new call builder for the [`avsDirectory`] function.
4976        pub fn avsDirectory(
4977            &self,
4978        ) -> alloy_contract::SolCallBuilder<&P, avsDirectoryCall, N> {
4979            self.call_builder(&avsDirectoryCall)
4980        }
4981        ///Creates a new call builder for the [`createAVSRewardsSubmission`] function.
4982        pub fn createAVSRewardsSubmission(
4983            &self,
4984            rewardsSubmissions: alloy::sol_types::private::Vec<
4985                <IRewardsCoordinatorTypes::RewardsSubmission as alloy::sol_types::SolType>::RustType,
4986            >,
4987        ) -> alloy_contract::SolCallBuilder<&P, createAVSRewardsSubmissionCall, N> {
4988            self.call_builder(
4989                &createAVSRewardsSubmissionCall {
4990                    rewardsSubmissions,
4991                },
4992            )
4993        }
4994        ///Creates a new call builder for the [`deregisterOperatorFromAVS`] function.
4995        pub fn deregisterOperatorFromAVS(
4996            &self,
4997            operator: alloy::sol_types::private::Address,
4998        ) -> alloy_contract::SolCallBuilder<&P, deregisterOperatorFromAVSCall, N> {
4999            self.call_builder(
5000                &deregisterOperatorFromAVSCall {
5001                    operator,
5002                },
5003            )
5004        }
5005        ///Creates a new call builder for the [`deregisterOperatorFromOperatorSets`] function.
5006        pub fn deregisterOperatorFromOperatorSets(
5007            &self,
5008            operator: alloy::sol_types::private::Address,
5009            operatorSetIds: alloy::sol_types::private::Vec<u32>,
5010        ) -> alloy_contract::SolCallBuilder<
5011            &P,
5012            deregisterOperatorFromOperatorSetsCall,
5013            N,
5014        > {
5015            self.call_builder(
5016                &deregisterOperatorFromOperatorSetsCall {
5017                    operator,
5018                    operatorSetIds,
5019                },
5020            )
5021        }
5022        ///Creates a new call builder for the [`getOperatorRestakedStrategies`] function.
5023        pub fn getOperatorRestakedStrategies(
5024            &self,
5025            operator: alloy::sol_types::private::Address,
5026        ) -> alloy_contract::SolCallBuilder<&P, getOperatorRestakedStrategiesCall, N> {
5027            self.call_builder(
5028                &getOperatorRestakedStrategiesCall {
5029                    operator,
5030                },
5031            )
5032        }
5033        ///Creates a new call builder for the [`getRestakeableStrategies`] function.
5034        pub fn getRestakeableStrategies(
5035            &self,
5036        ) -> alloy_contract::SolCallBuilder<&P, getRestakeableStrategiesCall, N> {
5037            self.call_builder(&getRestakeableStrategiesCall)
5038        }
5039        ///Creates a new call builder for the [`registerOperatorToAVS`] function.
5040        pub fn registerOperatorToAVS(
5041            &self,
5042            operator: alloy::sol_types::private::Address,
5043            operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
5044        ) -> alloy_contract::SolCallBuilder<&P, registerOperatorToAVSCall, N> {
5045            self.call_builder(
5046                &registerOperatorToAVSCall {
5047                    operator,
5048                    operatorSignature,
5049                },
5050            )
5051        }
5052        ///Creates a new call builder for the [`removeAdmin`] function.
5053        pub fn removeAdmin(
5054            &self,
5055            admin: alloy::sol_types::private::Address,
5056        ) -> alloy_contract::SolCallBuilder<&P, removeAdminCall, N> {
5057            self.call_builder(&removeAdminCall { admin })
5058        }
5059        ///Creates a new call builder for the [`removeAppointee`] function.
5060        pub fn removeAppointee(
5061            &self,
5062            appointee: alloy::sol_types::private::Address,
5063            target: alloy::sol_types::private::Address,
5064            selector: alloy::sol_types::private::FixedBytes<4>,
5065        ) -> alloy_contract::SolCallBuilder<&P, removeAppointeeCall, N> {
5066            self.call_builder(
5067                &removeAppointeeCall {
5068                    appointee,
5069                    target,
5070                    selector,
5071                },
5072            )
5073        }
5074        ///Creates a new call builder for the [`removePendingAdmin`] function.
5075        pub fn removePendingAdmin(
5076            &self,
5077            pendingAdmin: alloy::sol_types::private::Address,
5078        ) -> alloy_contract::SolCallBuilder<&P, removePendingAdminCall, N> {
5079            self.call_builder(
5080                &removePendingAdminCall {
5081                    pendingAdmin,
5082                },
5083            )
5084        }
5085        ///Creates a new call builder for the [`setAppointee`] function.
5086        pub fn setAppointee(
5087            &self,
5088            appointee: alloy::sol_types::private::Address,
5089            target: alloy::sol_types::private::Address,
5090            selector: alloy::sol_types::private::FixedBytes<4>,
5091        ) -> alloy_contract::SolCallBuilder<&P, setAppointeeCall, N> {
5092            self.call_builder(
5093                &setAppointeeCall {
5094                    appointee,
5095                    target,
5096                    selector,
5097                },
5098            )
5099        }
5100        ///Creates a new call builder for the [`updateAVSMetadataURI`] function.
5101        pub fn updateAVSMetadataURI(
5102            &self,
5103            metadataURI: alloy::sol_types::private::String,
5104        ) -> alloy_contract::SolCallBuilder<&P, updateAVSMetadataURICall, N> {
5105            self.call_builder(
5106                &updateAVSMetadataURICall {
5107                    metadataURI,
5108                },
5109            )
5110        }
5111    }
5112    /// Event filters.
5113    #[automatically_derived]
5114    impl<
5115        P: alloy_contract::private::Provider<N>,
5116        N: alloy_contract::private::Network,
5117    > IServiceManagerInstance<P, N> {
5118        /// Creates a new event filter using this contract instance's provider and address.
5119        ///
5120        /// Note that the type can be any event, not just those defined in this contract.
5121        /// Prefer using the other methods for building type-safe event filters.
5122        pub fn event_filter<E: alloy_sol_types::SolEvent>(
5123            &self,
5124        ) -> alloy_contract::Event<&P, E, N> {
5125            alloy_contract::Event::new_sol(&self.provider, &self.address)
5126        }
5127        ///Creates a new event filter for the [`RewardsInitiatorUpdated`] event.
5128        pub fn RewardsInitiatorUpdated_filter(
5129            &self,
5130        ) -> alloy_contract::Event<&P, RewardsInitiatorUpdated, N> {
5131            self.event_filter::<RewardsInitiatorUpdated>()
5132        }
5133    }
5134}
eigenlayer_contract_deployer/bindings/core/i_service_manager.rs

eigenlayer_contract_deployer/bindings/core/
i_service_manager.rs
