eigen_utils/slashing/middleware/
service_manager_base.rs

1///Module containing a contract's types and functions.
2/**
3
4```solidity
5library IRewardsCoordinatorTypes {
6    struct OperatorDirectedRewardsSubmission { StrategyAndMultiplier[] strategiesAndMultipliers; address token; OperatorReward[] operatorRewards; uint32 startTimestamp; uint32 duration; string description; }
7    struct OperatorReward { address operator; uint256 amount; }
8    struct RewardsSubmission { StrategyAndMultiplier[] strategiesAndMultipliers; address token; uint256 amount; uint32 startTimestamp; uint32 duration; }
9    struct StrategyAndMultiplier { address strategy; uint96 multiplier; }
10}
11```*/
12#[allow(
13    non_camel_case_types,
14    non_snake_case,
15    clippy::pub_underscore_fields,
16    clippy::style,
17    clippy::empty_structs_with_brackets
18)]
19pub mod IRewardsCoordinatorTypes {
20    use super::*;
21    use alloy::sol_types as alloy_sol_types;
22    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
23    /**```solidity
24    struct OperatorDirectedRewardsSubmission { StrategyAndMultiplier[] strategiesAndMultipliers; address token; OperatorReward[] operatorRewards; uint32 startTimestamp; uint32 duration; string description; }
25    ```*/
26    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
27    #[derive(Clone)]
28    pub struct OperatorDirectedRewardsSubmission {
29        #[allow(missing_docs)]
30        pub strategiesAndMultipliers: alloy::sol_types::private::Vec<
31            <StrategyAndMultiplier as alloy::sol_types::SolType>::RustType,
32        >,
33        #[allow(missing_docs)]
34        pub token: alloy::sol_types::private::Address,
35        #[allow(missing_docs)]
36        pub operatorRewards:
37            alloy::sol_types::private::Vec<<OperatorReward as alloy::sol_types::SolType>::RustType>,
38        #[allow(missing_docs)]
39        pub startTimestamp: u32,
40        #[allow(missing_docs)]
41        pub duration: u32,
42        #[allow(missing_docs)]
43        pub description: alloy::sol_types::private::String,
44    }
45    #[allow(
46        non_camel_case_types,
47        non_snake_case,
48        clippy::pub_underscore_fields,
49        clippy::style
50    )]
51    const _: () = {
52        use alloy::sol_types as alloy_sol_types;
53        #[doc(hidden)]
54        type UnderlyingSolTuple<'a> = (
55            alloy::sol_types::sol_data::Array<StrategyAndMultiplier>,
56            alloy::sol_types::sol_data::Address,
57            alloy::sol_types::sol_data::Array<OperatorReward>,
58            alloy::sol_types::sol_data::Uint<32>,
59            alloy::sol_types::sol_data::Uint<32>,
60            alloy::sol_types::sol_data::String,
61        );
62        #[doc(hidden)]
63        type UnderlyingRustTuple<'a> = (
64            alloy::sol_types::private::Vec<
65                <StrategyAndMultiplier as alloy::sol_types::SolType>::RustType,
66            >,
67            alloy::sol_types::private::Address,
68            alloy::sol_types::private::Vec<<OperatorReward as alloy::sol_types::SolType>::RustType>,
69            u32,
70            u32,
71            alloy::sol_types::private::String,
72        );
73        #[cfg(test)]
74        #[allow(dead_code, unreachable_patterns)]
75        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
76            match _t {
77                alloy_sol_types::private::AssertTypeEq::<
78                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
79                >(_) => {}
80            }
81        }
82        #[automatically_derived]
83        #[doc(hidden)]
84        impl ::core::convert::From<OperatorDirectedRewardsSubmission> for UnderlyingRustTuple<'_> {
85            fn from(value: OperatorDirectedRewardsSubmission) -> Self {
86                (
87                    value.strategiesAndMultipliers,
88                    value.token,
89                    value.operatorRewards,
90                    value.startTimestamp,
91                    value.duration,
92                    value.description,
93                )
94            }
95        }
96        #[automatically_derived]
97        #[doc(hidden)]
98        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorDirectedRewardsSubmission {
99            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
100                Self {
101                    strategiesAndMultipliers: tuple.0,
102                    token: tuple.1,
103                    operatorRewards: tuple.2,
104                    startTimestamp: tuple.3,
105                    duration: tuple.4,
106                    description: tuple.5,
107                }
108            }
109        }
110        #[automatically_derived]
111        impl alloy_sol_types::SolValue for OperatorDirectedRewardsSubmission {
112            type SolType = Self;
113        }
114        #[automatically_derived]
115        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorDirectedRewardsSubmission {
116            #[inline]
117            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
118                (
119                    <alloy::sol_types::sol_data::Array<
120                        StrategyAndMultiplier,
121                    > as alloy_sol_types::SolType>::tokenize(
122                        &self.strategiesAndMultipliers,
123                    ),
124                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
125                        &self.token,
126                    ),
127                    <alloy::sol_types::sol_data::Array<
128                        OperatorReward,
129                    > as alloy_sol_types::SolType>::tokenize(&self.operatorRewards),
130                    <alloy::sol_types::sol_data::Uint<
131                        32,
132                    > as alloy_sol_types::SolType>::tokenize(&self.startTimestamp),
133                    <alloy::sol_types::sol_data::Uint<
134                        32,
135                    > as alloy_sol_types::SolType>::tokenize(&self.duration),
136                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
137                        &self.description,
138                    ),
139                )
140            }
141            #[inline]
142            fn stv_abi_encoded_size(&self) -> usize {
143                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
144                    return size;
145                }
146                let tuple =
147                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
148                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
149            }
150            #[inline]
151            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
152                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
153            }
154            #[inline]
155            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
156                let tuple =
157                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
158                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
159                    &tuple, out,
160                )
161            }
162            #[inline]
163            fn stv_abi_packed_encoded_size(&self) -> usize {
164                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
165                    return size;
166                }
167                let tuple =
168                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
169                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
170                    &tuple,
171                )
172            }
173        }
174        #[automatically_derived]
175        impl alloy_sol_types::SolType for OperatorDirectedRewardsSubmission {
176            type RustType = Self;
177            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
178            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
179            const ENCODED_SIZE: Option<usize> =
180                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
181            const PACKED_ENCODED_SIZE: Option<usize> =
182                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
183            #[inline]
184            fn valid_token(token: &Self::Token<'_>) -> bool {
185                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
186            }
187            #[inline]
188            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
189                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
190                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
191            }
192        }
193        #[automatically_derived]
194        impl alloy_sol_types::SolStruct for OperatorDirectedRewardsSubmission {
195            const NAME: &'static str = "OperatorDirectedRewardsSubmission";
196            #[inline]
197            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
198                alloy_sol_types::private::Cow::Borrowed(
199                    "OperatorDirectedRewardsSubmission(StrategyAndMultiplier[] strategiesAndMultipliers,address token,OperatorReward[] operatorRewards,uint32 startTimestamp,uint32 duration,string description)",
200                )
201            }
202            #[inline]
203            fn eip712_components(
204            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
205            {
206                let mut components = alloy_sol_types::private::Vec::with_capacity(2);
207                components.push(
208                    <StrategyAndMultiplier as alloy_sol_types::SolStruct>::eip712_root_type(),
209                );
210                components.extend(
211                    <StrategyAndMultiplier as alloy_sol_types::SolStruct>::eip712_components(),
212                );
213                components.push(<OperatorReward as alloy_sol_types::SolStruct>::eip712_root_type());
214                components
215                    .extend(<OperatorReward as alloy_sol_types::SolStruct>::eip712_components());
216                components
217            }
218            #[inline]
219            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
220                [
221                    <alloy::sol_types::sol_data::Array<
222                        StrategyAndMultiplier,
223                    > as alloy_sol_types::SolType>::eip712_data_word(
224                            &self.strategiesAndMultipliers,
225                        )
226                        .0,
227                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
228                            &self.token,
229                        )
230                        .0,
231                    <alloy::sol_types::sol_data::Array<
232                        OperatorReward,
233                    > as alloy_sol_types::SolType>::eip712_data_word(
234                            &self.operatorRewards,
235                        )
236                        .0,
237                    <alloy::sol_types::sol_data::Uint<
238                        32,
239                    > as alloy_sol_types::SolType>::eip712_data_word(
240                            &self.startTimestamp,
241                        )
242                        .0,
243                    <alloy::sol_types::sol_data::Uint<
244                        32,
245                    > as alloy_sol_types::SolType>::eip712_data_word(&self.duration)
246                        .0,
247                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
248                            &self.description,
249                        )
250                        .0,
251                ]
252                    .concat()
253            }
254        }
255        #[automatically_derived]
256        impl alloy_sol_types::EventTopic for OperatorDirectedRewardsSubmission {
257            #[inline]
258            fn topic_preimage_length(rust: &Self::RustType) -> usize {
259                0usize
260                    + <alloy::sol_types::sol_data::Array<
261                        StrategyAndMultiplier,
262                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
263                        &rust.strategiesAndMultipliers,
264                    )
265                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
266                        &rust.token,
267                    )
268                    + <alloy::sol_types::sol_data::Array<
269                        OperatorReward,
270                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
271                        &rust.operatorRewards,
272                    )
273                    + <alloy::sol_types::sol_data::Uint<
274                        32,
275                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
276                        &rust.startTimestamp,
277                    )
278                    + <alloy::sol_types::sol_data::Uint<
279                        32,
280                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
281                        &rust.duration,
282                    )
283                    + <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
284                        &rust.description,
285                    )
286            }
287            #[inline]
288            fn encode_topic_preimage(
289                rust: &Self::RustType,
290                out: &mut alloy_sol_types::private::Vec<u8>,
291            ) {
292                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
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::Array<
304                    OperatorReward,
305                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
306                    &rust.operatorRewards,
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                <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
322                    &rust.description,
323                    out,
324                );
325            }
326            #[inline]
327            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
328                let mut out = alloy_sol_types::private::Vec::new();
329                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
330                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
331            }
332        }
333    };
334    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
335    /**```solidity
336    struct OperatorReward { address operator; uint256 amount; }
337    ```*/
338    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
339    #[derive(Clone)]
340    pub struct OperatorReward {
341        #[allow(missing_docs)]
342        pub operator: alloy::sol_types::private::Address,
343        #[allow(missing_docs)]
344        pub amount: alloy::sol_types::private::primitives::aliases::U256,
345    }
346    #[allow(
347        non_camel_case_types,
348        non_snake_case,
349        clippy::pub_underscore_fields,
350        clippy::style
351    )]
352    const _: () = {
353        use alloy::sol_types as alloy_sol_types;
354        #[doc(hidden)]
355        type UnderlyingSolTuple<'a> = (
356            alloy::sol_types::sol_data::Address,
357            alloy::sol_types::sol_data::Uint<256>,
358        );
359        #[doc(hidden)]
360        type UnderlyingRustTuple<'a> = (
361            alloy::sol_types::private::Address,
362            alloy::sol_types::private::primitives::aliases::U256,
363        );
364        #[cfg(test)]
365        #[allow(dead_code, unreachable_patterns)]
366        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
367            match _t {
368                alloy_sol_types::private::AssertTypeEq::<
369                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
370                >(_) => {}
371            }
372        }
373        #[automatically_derived]
374        #[doc(hidden)]
375        impl ::core::convert::From<OperatorReward> for UnderlyingRustTuple<'_> {
376            fn from(value: OperatorReward) -> Self {
377                (value.operator, value.amount)
378            }
379        }
380        #[automatically_derived]
381        #[doc(hidden)]
382        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorReward {
383            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
384                Self {
385                    operator: tuple.0,
386                    amount: tuple.1,
387                }
388            }
389        }
390        #[automatically_derived]
391        impl alloy_sol_types::SolValue for OperatorReward {
392            type SolType = Self;
393        }
394        #[automatically_derived]
395        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorReward {
396            #[inline]
397            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
398                (
399                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
400                        &self.operator,
401                    ),
402                    <alloy::sol_types::sol_data::Uint<256> as alloy_sol_types::SolType>::tokenize(
403                        &self.amount,
404                    ),
405                )
406            }
407            #[inline]
408            fn stv_abi_encoded_size(&self) -> usize {
409                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
410                    return size;
411                }
412                let tuple =
413                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
414                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
415            }
416            #[inline]
417            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
418                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
419            }
420            #[inline]
421            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
422                let tuple =
423                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
424                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
425                    &tuple, out,
426                )
427            }
428            #[inline]
429            fn stv_abi_packed_encoded_size(&self) -> usize {
430                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
431                    return size;
432                }
433                let tuple =
434                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
435                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
436                    &tuple,
437                )
438            }
439        }
440        #[automatically_derived]
441        impl alloy_sol_types::SolType for OperatorReward {
442            type RustType = Self;
443            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
444            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
445            const ENCODED_SIZE: Option<usize> =
446                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
447            const PACKED_ENCODED_SIZE: Option<usize> =
448                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
449            #[inline]
450            fn valid_token(token: &Self::Token<'_>) -> bool {
451                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
452            }
453            #[inline]
454            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
455                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
456                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
457            }
458        }
459        #[automatically_derived]
460        impl alloy_sol_types::SolStruct for OperatorReward {
461            const NAME: &'static str = "OperatorReward";
462            #[inline]
463            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
464                alloy_sol_types::private::Cow::Borrowed(
465                    "OperatorReward(address operator,uint256 amount)",
466                )
467            }
468            #[inline]
469            fn eip712_components(
470            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
471            {
472                alloy_sol_types::private::Vec::new()
473            }
474            #[inline]
475            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
476                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
477            }
478            #[inline]
479            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
480                [
481                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
482                            &self.operator,
483                        )
484                        .0,
485                    <alloy::sol_types::sol_data::Uint<
486                        256,
487                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
488                        .0,
489                ]
490                    .concat()
491            }
492        }
493        #[automatically_derived]
494        impl alloy_sol_types::EventTopic for OperatorReward {
495            #[inline]
496            fn topic_preimage_length(rust: &Self::RustType) -> usize {
497                0usize
498                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
499                        &rust.operator,
500                    )
501                    + <alloy::sol_types::sol_data::Uint<
502                        256,
503                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
504                        &rust.amount,
505                    )
506            }
507            #[inline]
508            fn encode_topic_preimage(
509                rust: &Self::RustType,
510                out: &mut alloy_sol_types::private::Vec<u8>,
511            ) {
512                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
513                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
514                    &rust.operator,
515                    out,
516                );
517                <alloy::sol_types::sol_data::Uint<
518                    256,
519                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
520                    &rust.amount,
521                    out,
522                );
523            }
524            #[inline]
525            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
526                let mut out = alloy_sol_types::private::Vec::new();
527                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
528                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
529            }
530        }
531    };
532    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
533    /**```solidity
534    struct RewardsSubmission { StrategyAndMultiplier[] strategiesAndMultipliers; address token; uint256 amount; uint32 startTimestamp; uint32 duration; }
535    ```*/
536    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
537    #[derive(Clone)]
538    pub struct RewardsSubmission {
539        #[allow(missing_docs)]
540        pub strategiesAndMultipliers: alloy::sol_types::private::Vec<
541            <StrategyAndMultiplier as alloy::sol_types::SolType>::RustType,
542        >,
543        #[allow(missing_docs)]
544        pub token: alloy::sol_types::private::Address,
545        #[allow(missing_docs)]
546        pub amount: alloy::sol_types::private::primitives::aliases::U256,
547        #[allow(missing_docs)]
548        pub startTimestamp: u32,
549        #[allow(missing_docs)]
550        pub duration: u32,
551    }
552    #[allow(
553        non_camel_case_types,
554        non_snake_case,
555        clippy::pub_underscore_fields,
556        clippy::style
557    )]
558    const _: () = {
559        use alloy::sol_types as alloy_sol_types;
560        #[doc(hidden)]
561        type UnderlyingSolTuple<'a> = (
562            alloy::sol_types::sol_data::Array<StrategyAndMultiplier>,
563            alloy::sol_types::sol_data::Address,
564            alloy::sol_types::sol_data::Uint<256>,
565            alloy::sol_types::sol_data::Uint<32>,
566            alloy::sol_types::sol_data::Uint<32>,
567        );
568        #[doc(hidden)]
569        type UnderlyingRustTuple<'a> = (
570            alloy::sol_types::private::Vec<
571                <StrategyAndMultiplier as alloy::sol_types::SolType>::RustType,
572            >,
573            alloy::sol_types::private::Address,
574            alloy::sol_types::private::primitives::aliases::U256,
575            u32,
576            u32,
577        );
578        #[cfg(test)]
579        #[allow(dead_code, unreachable_patterns)]
580        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
581            match _t {
582                alloy_sol_types::private::AssertTypeEq::<
583                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
584                >(_) => {}
585            }
586        }
587        #[automatically_derived]
588        #[doc(hidden)]
589        impl ::core::convert::From<RewardsSubmission> for UnderlyingRustTuple<'_> {
590            fn from(value: RewardsSubmission) -> Self {
591                (
592                    value.strategiesAndMultipliers,
593                    value.token,
594                    value.amount,
595                    value.startTimestamp,
596                    value.duration,
597                )
598            }
599        }
600        #[automatically_derived]
601        #[doc(hidden)]
602        impl ::core::convert::From<UnderlyingRustTuple<'_>> for RewardsSubmission {
603            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
604                Self {
605                    strategiesAndMultipliers: tuple.0,
606                    token: tuple.1,
607                    amount: tuple.2,
608                    startTimestamp: tuple.3,
609                    duration: tuple.4,
610                }
611            }
612        }
613        #[automatically_derived]
614        impl alloy_sol_types::SolValue for RewardsSubmission {
615            type SolType = Self;
616        }
617        #[automatically_derived]
618        impl alloy_sol_types::private::SolTypeValue<Self> for RewardsSubmission {
619            #[inline]
620            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
621                (
622                    <alloy::sol_types::sol_data::Array<
623                        StrategyAndMultiplier,
624                    > as alloy_sol_types::SolType>::tokenize(
625                        &self.strategiesAndMultipliers,
626                    ),
627                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
628                        &self.token,
629                    ),
630                    <alloy::sol_types::sol_data::Uint<
631                        256,
632                    > as alloy_sol_types::SolType>::tokenize(&self.amount),
633                    <alloy::sol_types::sol_data::Uint<
634                        32,
635                    > as alloy_sol_types::SolType>::tokenize(&self.startTimestamp),
636                    <alloy::sol_types::sol_data::Uint<
637                        32,
638                    > as alloy_sol_types::SolType>::tokenize(&self.duration),
639                )
640            }
641            #[inline]
642            fn stv_abi_encoded_size(&self) -> usize {
643                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
644                    return size;
645                }
646                let tuple =
647                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
648                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
649            }
650            #[inline]
651            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
652                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
653            }
654            #[inline]
655            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
656                let tuple =
657                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
658                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
659                    &tuple, out,
660                )
661            }
662            #[inline]
663            fn stv_abi_packed_encoded_size(&self) -> usize {
664                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
665                    return size;
666                }
667                let tuple =
668                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
669                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
670                    &tuple,
671                )
672            }
673        }
674        #[automatically_derived]
675        impl alloy_sol_types::SolType for RewardsSubmission {
676            type RustType = Self;
677            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
678            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
679            const ENCODED_SIZE: Option<usize> =
680                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
681            const PACKED_ENCODED_SIZE: Option<usize> =
682                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
683            #[inline]
684            fn valid_token(token: &Self::Token<'_>) -> bool {
685                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
686            }
687            #[inline]
688            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
689                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
690                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
691            }
692        }
693        #[automatically_derived]
694        impl alloy_sol_types::SolStruct for RewardsSubmission {
695            const NAME: &'static str = "RewardsSubmission";
696            #[inline]
697            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
698                alloy_sol_types::private::Cow::Borrowed(
699                    "RewardsSubmission(StrategyAndMultiplier[] strategiesAndMultipliers,address token,uint256 amount,uint32 startTimestamp,uint32 duration)",
700                )
701            }
702            #[inline]
703            fn eip712_components(
704            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
705            {
706                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
707                components.push(
708                    <StrategyAndMultiplier as alloy_sol_types::SolStruct>::eip712_root_type(),
709                );
710                components.extend(
711                    <StrategyAndMultiplier as alloy_sol_types::SolStruct>::eip712_components(),
712                );
713                components
714            }
715            #[inline]
716            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
717                [
718                    <alloy::sol_types::sol_data::Array<
719                        StrategyAndMultiplier,
720                    > as alloy_sol_types::SolType>::eip712_data_word(
721                            &self.strategiesAndMultipliers,
722                        )
723                        .0,
724                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
725                            &self.token,
726                        )
727                        .0,
728                    <alloy::sol_types::sol_data::Uint<
729                        256,
730                    > as alloy_sol_types::SolType>::eip712_data_word(&self.amount)
731                        .0,
732                    <alloy::sol_types::sol_data::Uint<
733                        32,
734                    > as alloy_sol_types::SolType>::eip712_data_word(
735                            &self.startTimestamp,
736                        )
737                        .0,
738                    <alloy::sol_types::sol_data::Uint<
739                        32,
740                    > as alloy_sol_types::SolType>::eip712_data_word(&self.duration)
741                        .0,
742                ]
743                    .concat()
744            }
745        }
746        #[automatically_derived]
747        impl alloy_sol_types::EventTopic for RewardsSubmission {
748            #[inline]
749            fn topic_preimage_length(rust: &Self::RustType) -> usize {
750                0usize
751                    + <alloy::sol_types::sol_data::Array<
752                        StrategyAndMultiplier,
753                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
754                        &rust.strategiesAndMultipliers,
755                    )
756                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
757                        &rust.token,
758                    )
759                    + <alloy::sol_types::sol_data::Uint<
760                        256,
761                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
762                        &rust.amount,
763                    )
764                    + <alloy::sol_types::sol_data::Uint<
765                        32,
766                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
767                        &rust.startTimestamp,
768                    )
769                    + <alloy::sol_types::sol_data::Uint<
770                        32,
771                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
772                        &rust.duration,
773                    )
774            }
775            #[inline]
776            fn encode_topic_preimage(
777                rust: &Self::RustType,
778                out: &mut alloy_sol_types::private::Vec<u8>,
779            ) {
780                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
781                <alloy::sol_types::sol_data::Array<
782                    StrategyAndMultiplier,
783                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
784                    &rust.strategiesAndMultipliers,
785                    out,
786                );
787                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
788                    &rust.token,
789                    out,
790                );
791                <alloy::sol_types::sol_data::Uint<
792                    256,
793                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
794                    &rust.amount,
795                    out,
796                );
797                <alloy::sol_types::sol_data::Uint<
798                    32,
799                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
800                    &rust.startTimestamp,
801                    out,
802                );
803                <alloy::sol_types::sol_data::Uint<
804                    32,
805                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
806                    &rust.duration,
807                    out,
808                );
809            }
810            #[inline]
811            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
812                let mut out = alloy_sol_types::private::Vec::new();
813                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
814                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
815            }
816        }
817    };
818    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
819    /**```solidity
820    struct StrategyAndMultiplier { address strategy; uint96 multiplier; }
821    ```*/
822    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
823    #[derive(Clone)]
824    pub struct StrategyAndMultiplier {
825        #[allow(missing_docs)]
826        pub strategy: alloy::sol_types::private::Address,
827        #[allow(missing_docs)]
828        pub multiplier: alloy::sol_types::private::primitives::aliases::U96,
829    }
830    #[allow(
831        non_camel_case_types,
832        non_snake_case,
833        clippy::pub_underscore_fields,
834        clippy::style
835    )]
836    const _: () = {
837        use alloy::sol_types as alloy_sol_types;
838        #[doc(hidden)]
839        type UnderlyingSolTuple<'a> = (
840            alloy::sol_types::sol_data::Address,
841            alloy::sol_types::sol_data::Uint<96>,
842        );
843        #[doc(hidden)]
844        type UnderlyingRustTuple<'a> = (
845            alloy::sol_types::private::Address,
846            alloy::sol_types::private::primitives::aliases::U96,
847        );
848        #[cfg(test)]
849        #[allow(dead_code, unreachable_patterns)]
850        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
851            match _t {
852                alloy_sol_types::private::AssertTypeEq::<
853                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
854                >(_) => {}
855            }
856        }
857        #[automatically_derived]
858        #[doc(hidden)]
859        impl ::core::convert::From<StrategyAndMultiplier> for UnderlyingRustTuple<'_> {
860            fn from(value: StrategyAndMultiplier) -> Self {
861                (value.strategy, value.multiplier)
862            }
863        }
864        #[automatically_derived]
865        #[doc(hidden)]
866        impl ::core::convert::From<UnderlyingRustTuple<'_>> for StrategyAndMultiplier {
867            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
868                Self {
869                    strategy: tuple.0,
870                    multiplier: tuple.1,
871                }
872            }
873        }
874        #[automatically_derived]
875        impl alloy_sol_types::SolValue for StrategyAndMultiplier {
876            type SolType = Self;
877        }
878        #[automatically_derived]
879        impl alloy_sol_types::private::SolTypeValue<Self> for StrategyAndMultiplier {
880            #[inline]
881            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
882                (
883                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
884                        &self.strategy,
885                    ),
886                    <alloy::sol_types::sol_data::Uint<96> as alloy_sol_types::SolType>::tokenize(
887                        &self.multiplier,
888                    ),
889                )
890            }
891            #[inline]
892            fn stv_abi_encoded_size(&self) -> usize {
893                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
894                    return size;
895                }
896                let tuple =
897                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
898                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
899            }
900            #[inline]
901            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
902                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
903            }
904            #[inline]
905            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
906                let tuple =
907                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
908                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
909                    &tuple, out,
910                )
911            }
912            #[inline]
913            fn stv_abi_packed_encoded_size(&self) -> usize {
914                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
915                    return size;
916                }
917                let tuple =
918                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
919                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
920                    &tuple,
921                )
922            }
923        }
924        #[automatically_derived]
925        impl alloy_sol_types::SolType for StrategyAndMultiplier {
926            type RustType = Self;
927            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
928            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
929            const ENCODED_SIZE: Option<usize> =
930                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
931            const PACKED_ENCODED_SIZE: Option<usize> =
932                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
933            #[inline]
934            fn valid_token(token: &Self::Token<'_>) -> bool {
935                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
936            }
937            #[inline]
938            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
939                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
940                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
941            }
942        }
943        #[automatically_derived]
944        impl alloy_sol_types::SolStruct for StrategyAndMultiplier {
945            const NAME: &'static str = "StrategyAndMultiplier";
946            #[inline]
947            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
948                alloy_sol_types::private::Cow::Borrowed(
949                    "StrategyAndMultiplier(address strategy,uint96 multiplier)",
950                )
951            }
952            #[inline]
953            fn eip712_components(
954            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
955            {
956                alloy_sol_types::private::Vec::new()
957            }
958            #[inline]
959            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
960                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
961            }
962            #[inline]
963            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
964                [
965                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
966                            &self.strategy,
967                        )
968                        .0,
969                    <alloy::sol_types::sol_data::Uint<
970                        96,
971                    > as alloy_sol_types::SolType>::eip712_data_word(&self.multiplier)
972                        .0,
973                ]
974                    .concat()
975            }
976        }
977        #[automatically_derived]
978        impl alloy_sol_types::EventTopic for StrategyAndMultiplier {
979            #[inline]
980            fn topic_preimage_length(rust: &Self::RustType) -> usize {
981                0usize
982                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
983                        &rust.strategy,
984                    )
985                    + <alloy::sol_types::sol_data::Uint<
986                        96,
987                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
988                        &rust.multiplier,
989                    )
990            }
991            #[inline]
992            fn encode_topic_preimage(
993                rust: &Self::RustType,
994                out: &mut alloy_sol_types::private::Vec<u8>,
995            ) {
996                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
997                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
998                    &rust.strategy,
999                    out,
1000                );
1001                <alloy::sol_types::sol_data::Uint<
1002                    96,
1003                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1004                    &rust.multiplier,
1005                    out,
1006                );
1007            }
1008            #[inline]
1009            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
1010                let mut out = alloy_sol_types::private::Vec::new();
1011                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
1012                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
1013            }
1014        }
1015    };
1016    use alloy::contract as alloy_contract;
1017    /**Creates a new wrapper around an on-chain [`IRewardsCoordinatorTypes`](self) contract instance.
1018
1019    See the [wrapper's documentation](`IRewardsCoordinatorTypesInstance`) for more details.*/
1020    #[inline]
1021    pub const fn new<
1022        P: alloy_contract::private::Provider<N>,
1023        N: alloy_contract::private::Network,
1024    >(
1025        address: alloy_sol_types::private::Address,
1026        provider: P,
1027    ) -> IRewardsCoordinatorTypesInstance<P, N> {
1028        IRewardsCoordinatorTypesInstance::<P, N>::new(address, provider)
1029    }
1030    /**A [`IRewardsCoordinatorTypes`](self) instance.
1031
1032    Contains type-safe methods for interacting with an on-chain instance of the
1033    [`IRewardsCoordinatorTypes`](self) contract located at a given `address`, using a given
1034    provider `P`.
1035
1036    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1037    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1038    be used to deploy a new instance of the contract.
1039
1040    See the [module-level documentation](self) for all the available methods.*/
1041    #[derive(Clone)]
1042    pub struct IRewardsCoordinatorTypesInstance<P, N = alloy_contract::private::Ethereum> {
1043        address: alloy_sol_types::private::Address,
1044        provider: P,
1045        _network: ::core::marker::PhantomData<N>,
1046    }
1047    #[automatically_derived]
1048    impl<P, N> ::core::fmt::Debug for IRewardsCoordinatorTypesInstance<P, N> {
1049        #[inline]
1050        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1051            f.debug_tuple("IRewardsCoordinatorTypesInstance")
1052                .field(&self.address)
1053                .finish()
1054        }
1055    }
1056    /// Instantiation and getters/setters.
1057    #[automatically_derived]
1058    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1059        IRewardsCoordinatorTypesInstance<P, N>
1060    {
1061        /**Creates a new wrapper around an on-chain [`IRewardsCoordinatorTypes`](self) contract instance.
1062
1063        See the [wrapper's documentation](`IRewardsCoordinatorTypesInstance`) for more details.*/
1064        #[inline]
1065        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
1066            Self {
1067                address,
1068                provider,
1069                _network: ::core::marker::PhantomData,
1070            }
1071        }
1072        /// Returns a reference to the address.
1073        #[inline]
1074        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1075            &self.address
1076        }
1077        /// Sets the address.
1078        #[inline]
1079        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1080            self.address = address;
1081        }
1082        /// Sets the address and returns `self`.
1083        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1084            self.set_address(address);
1085            self
1086        }
1087        /// Returns a reference to the provider.
1088        #[inline]
1089        pub const fn provider(&self) -> &P {
1090            &self.provider
1091        }
1092    }
1093    impl<P: ::core::clone::Clone, N> IRewardsCoordinatorTypesInstance<&P, N> {
1094        /// Clones the provider and returns a new instance with the cloned provider.
1095        #[inline]
1096        pub fn with_cloned_provider(self) -> IRewardsCoordinatorTypesInstance<P, N> {
1097            IRewardsCoordinatorTypesInstance {
1098                address: self.address,
1099                provider: ::core::clone::Clone::clone(&self.provider),
1100                _network: ::core::marker::PhantomData,
1101            }
1102        }
1103    }
1104    /// Function calls.
1105    #[automatically_derived]
1106    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1107        IRewardsCoordinatorTypesInstance<P, N>
1108    {
1109        /// Creates a new call builder using this contract instance's provider and address.
1110        ///
1111        /// Note that the call can be any function call, not just those defined in this
1112        /// contract. Prefer using the other methods for building type-safe contract calls.
1113        pub fn call_builder<C: alloy_sol_types::SolCall>(
1114            &self,
1115            call: &C,
1116        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1117            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1118        }
1119    }
1120    /// Event filters.
1121    #[automatically_derived]
1122    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1123        IRewardsCoordinatorTypesInstance<P, N>
1124    {
1125        /// Creates a new event filter using this contract instance's provider and address.
1126        ///
1127        /// Note that the type can be any event, not just those defined in this contract.
1128        /// Prefer using the other methods for building type-safe event filters.
1129        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1130            &self,
1131        ) -> alloy_contract::Event<&P, E, N> {
1132            alloy_contract::Event::new_sol(&self.provider, &self.address)
1133        }
1134    }
1135}
1136///Module containing a contract's types and functions.
1137/**
1138
1139```solidity
1140library ISignatureUtilsMixinTypes {
1141    struct SignatureWithSaltAndExpiry { bytes signature; bytes32 salt; uint256 expiry; }
1142}
1143```*/
1144#[allow(
1145    non_camel_case_types,
1146    non_snake_case,
1147    clippy::pub_underscore_fields,
1148    clippy::style,
1149    clippy::empty_structs_with_brackets
1150)]
1151pub mod ISignatureUtilsMixinTypes {
1152    use super::*;
1153    use alloy::sol_types as alloy_sol_types;
1154    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
1155    /**```solidity
1156    struct SignatureWithSaltAndExpiry { bytes signature; bytes32 salt; uint256 expiry; }
1157    ```*/
1158    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1159    #[derive(Clone)]
1160    pub struct SignatureWithSaltAndExpiry {
1161        #[allow(missing_docs)]
1162        pub signature: alloy::sol_types::private::Bytes,
1163        #[allow(missing_docs)]
1164        pub salt: alloy::sol_types::private::FixedBytes<32>,
1165        #[allow(missing_docs)]
1166        pub expiry: alloy::sol_types::private::primitives::aliases::U256,
1167    }
1168    #[allow(
1169        non_camel_case_types,
1170        non_snake_case,
1171        clippy::pub_underscore_fields,
1172        clippy::style
1173    )]
1174    const _: () = {
1175        use alloy::sol_types as alloy_sol_types;
1176        #[doc(hidden)]
1177        type UnderlyingSolTuple<'a> = (
1178            alloy::sol_types::sol_data::Bytes,
1179            alloy::sol_types::sol_data::FixedBytes<32>,
1180            alloy::sol_types::sol_data::Uint<256>,
1181        );
1182        #[doc(hidden)]
1183        type UnderlyingRustTuple<'a> = (
1184            alloy::sol_types::private::Bytes,
1185            alloy::sol_types::private::FixedBytes<32>,
1186            alloy::sol_types::private::primitives::aliases::U256,
1187        );
1188        #[cfg(test)]
1189        #[allow(dead_code, unreachable_patterns)]
1190        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
1191            match _t {
1192                alloy_sol_types::private::AssertTypeEq::<
1193                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1194                >(_) => {}
1195            }
1196        }
1197        #[automatically_derived]
1198        #[doc(hidden)]
1199        impl ::core::convert::From<SignatureWithSaltAndExpiry> for UnderlyingRustTuple<'_> {
1200            fn from(value: SignatureWithSaltAndExpiry) -> Self {
1201                (value.signature, value.salt, value.expiry)
1202            }
1203        }
1204        #[automatically_derived]
1205        #[doc(hidden)]
1206        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SignatureWithSaltAndExpiry {
1207            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1208                Self {
1209                    signature: tuple.0,
1210                    salt: tuple.1,
1211                    expiry: tuple.2,
1212                }
1213            }
1214        }
1215        #[automatically_derived]
1216        impl alloy_sol_types::SolValue for SignatureWithSaltAndExpiry {
1217            type SolType = Self;
1218        }
1219        #[automatically_derived]
1220        impl alloy_sol_types::private::SolTypeValue<Self> for SignatureWithSaltAndExpiry {
1221            #[inline]
1222            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1223                (
1224                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1225                        &self.signature,
1226                    ),
1227                    <alloy::sol_types::sol_data::FixedBytes<
1228                        32,
1229                    > as alloy_sol_types::SolType>::tokenize(&self.salt),
1230                    <alloy::sol_types::sol_data::Uint<
1231                        256,
1232                    > as alloy_sol_types::SolType>::tokenize(&self.expiry),
1233                )
1234            }
1235            #[inline]
1236            fn stv_abi_encoded_size(&self) -> usize {
1237                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1238                    return size;
1239                }
1240                let tuple =
1241                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
1242                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1243            }
1244            #[inline]
1245            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1246                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1247            }
1248            #[inline]
1249            fn stv_abi_encode_packed_to(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1250                let tuple =
1251                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
1252                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_encode_packed_to(
1253                    &tuple, out,
1254                )
1255            }
1256            #[inline]
1257            fn stv_abi_packed_encoded_size(&self) -> usize {
1258                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1259                    return size;
1260                }
1261                let tuple =
1262                    <UnderlyingRustTuple<'_> as ::core::convert::From<Self>>::from(self.clone());
1263                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::abi_packed_encoded_size(
1264                    &tuple,
1265                )
1266            }
1267        }
1268        #[automatically_derived]
1269        impl alloy_sol_types::SolType for SignatureWithSaltAndExpiry {
1270            type RustType = Self;
1271            type Token<'a> = <UnderlyingSolTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
1272            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1273            const ENCODED_SIZE: Option<usize> =
1274                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::ENCODED_SIZE;
1275            const PACKED_ENCODED_SIZE: Option<usize> =
1276                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1277            #[inline]
1278            fn valid_token(token: &Self::Token<'_>) -> bool {
1279                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1280            }
1281            #[inline]
1282            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1283                let tuple = <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::detokenize(token);
1284                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1285            }
1286        }
1287        #[automatically_derived]
1288        impl alloy_sol_types::SolStruct for SignatureWithSaltAndExpiry {
1289            const NAME: &'static str = "SignatureWithSaltAndExpiry";
1290            #[inline]
1291            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1292                alloy_sol_types::private::Cow::Borrowed(
1293                    "SignatureWithSaltAndExpiry(bytes signature,bytes32 salt,uint256 expiry)",
1294                )
1295            }
1296            #[inline]
1297            fn eip712_components(
1298            ) -> alloy_sol_types::private::Vec<alloy_sol_types::private::Cow<'static, str>>
1299            {
1300                alloy_sol_types::private::Vec::new()
1301            }
1302            #[inline]
1303            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1304                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1305            }
1306            #[inline]
1307            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1308                [
1309                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
1310                            &self.signature,
1311                        )
1312                        .0,
1313                    <alloy::sol_types::sol_data::FixedBytes<
1314                        32,
1315                    > as alloy_sol_types::SolType>::eip712_data_word(&self.salt)
1316                        .0,
1317                    <alloy::sol_types::sol_data::Uint<
1318                        256,
1319                    > as alloy_sol_types::SolType>::eip712_data_word(&self.expiry)
1320                        .0,
1321                ]
1322                    .concat()
1323            }
1324        }
1325        #[automatically_derived]
1326        impl alloy_sol_types::EventTopic for SignatureWithSaltAndExpiry {
1327            #[inline]
1328            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1329                0usize
1330                    + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
1331                        &rust.signature,
1332                    )
1333                    + <alloy::sol_types::sol_data::FixedBytes<
1334                        32,
1335                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.salt)
1336                    + <alloy::sol_types::sol_data::Uint<
1337                        256,
1338                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1339                        &rust.expiry,
1340                    )
1341            }
1342            #[inline]
1343            fn encode_topic_preimage(
1344                rust: &Self::RustType,
1345                out: &mut alloy_sol_types::private::Vec<u8>,
1346            ) {
1347                out.reserve(<Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust));
1348                <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
1349                    &rust.signature,
1350                    out,
1351                );
1352                <alloy::sol_types::sol_data::FixedBytes<
1353                    32,
1354                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1355                    &rust.salt,
1356                    out,
1357                );
1358                <alloy::sol_types::sol_data::Uint<
1359                    256,
1360                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1361                    &rust.expiry,
1362                    out,
1363                );
1364            }
1365            #[inline]
1366            fn encode_topic(rust: &Self::RustType) -> alloy_sol_types::abi::token::WordToken {
1367                let mut out = alloy_sol_types::private::Vec::new();
1368                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, &mut out);
1369                alloy_sol_types::abi::token::WordToken(alloy_sol_types::private::keccak256(out))
1370            }
1371        }
1372    };
1373    use alloy::contract as alloy_contract;
1374    /**Creates a new wrapper around an on-chain [`ISignatureUtilsMixinTypes`](self) contract instance.
1375
1376    See the [wrapper's documentation](`ISignatureUtilsMixinTypesInstance`) for more details.*/
1377    #[inline]
1378    pub const fn new<
1379        P: alloy_contract::private::Provider<N>,
1380        N: alloy_contract::private::Network,
1381    >(
1382        address: alloy_sol_types::private::Address,
1383        provider: P,
1384    ) -> ISignatureUtilsMixinTypesInstance<P, N> {
1385        ISignatureUtilsMixinTypesInstance::<P, N>::new(address, provider)
1386    }
1387    /**A [`ISignatureUtilsMixinTypes`](self) instance.
1388
1389    Contains type-safe methods for interacting with an on-chain instance of the
1390    [`ISignatureUtilsMixinTypes`](self) contract located at a given `address`, using a given
1391    provider `P`.
1392
1393    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1394    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1395    be used to deploy a new instance of the contract.
1396
1397    See the [module-level documentation](self) for all the available methods.*/
1398    #[derive(Clone)]
1399    pub struct ISignatureUtilsMixinTypesInstance<P, N = alloy_contract::private::Ethereum> {
1400        address: alloy_sol_types::private::Address,
1401        provider: P,
1402        _network: ::core::marker::PhantomData<N>,
1403    }
1404    #[automatically_derived]
1405    impl<P, N> ::core::fmt::Debug for ISignatureUtilsMixinTypesInstance<P, N> {
1406        #[inline]
1407        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1408            f.debug_tuple("ISignatureUtilsMixinTypesInstance")
1409                .field(&self.address)
1410                .finish()
1411        }
1412    }
1413    /// Instantiation and getters/setters.
1414    #[automatically_derived]
1415    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1416        ISignatureUtilsMixinTypesInstance<P, N>
1417    {
1418        /**Creates a new wrapper around an on-chain [`ISignatureUtilsMixinTypes`](self) contract instance.
1419
1420        See the [wrapper's documentation](`ISignatureUtilsMixinTypesInstance`) for more details.*/
1421        #[inline]
1422        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
1423            Self {
1424                address,
1425                provider,
1426                _network: ::core::marker::PhantomData,
1427            }
1428        }
1429        /// Returns a reference to the address.
1430        #[inline]
1431        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1432            &self.address
1433        }
1434        /// Sets the address.
1435        #[inline]
1436        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1437            self.address = address;
1438        }
1439        /// Sets the address and returns `self`.
1440        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1441            self.set_address(address);
1442            self
1443        }
1444        /// Returns a reference to the provider.
1445        #[inline]
1446        pub const fn provider(&self) -> &P {
1447            &self.provider
1448        }
1449    }
1450    impl<P: ::core::clone::Clone, N> ISignatureUtilsMixinTypesInstance<&P, N> {
1451        /// Clones the provider and returns a new instance with the cloned provider.
1452        #[inline]
1453        pub fn with_cloned_provider(self) -> ISignatureUtilsMixinTypesInstance<P, N> {
1454            ISignatureUtilsMixinTypesInstance {
1455                address: self.address,
1456                provider: ::core::clone::Clone::clone(&self.provider),
1457                _network: ::core::marker::PhantomData,
1458            }
1459        }
1460    }
1461    /// Function calls.
1462    #[automatically_derived]
1463    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1464        ISignatureUtilsMixinTypesInstance<P, N>
1465    {
1466        /// Creates a new call builder using this contract instance's provider and address.
1467        ///
1468        /// Note that the call can be any function call, not just those defined in this
1469        /// contract. Prefer using the other methods for building type-safe contract calls.
1470        pub fn call_builder<C: alloy_sol_types::SolCall>(
1471            &self,
1472            call: &C,
1473        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1474            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1475        }
1476    }
1477    /// Event filters.
1478    #[automatically_derived]
1479    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
1480        ISignatureUtilsMixinTypesInstance<P, N>
1481    {
1482        /// Creates a new event filter using this contract instance's provider and address.
1483        ///
1484        /// Note that the type can be any event, not just those defined in this contract.
1485        /// Prefer using the other methods for building type-safe event filters.
1486        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1487            &self,
1488        ) -> alloy_contract::Event<&P, E, N> {
1489            alloy_contract::Event::new_sol(&self.provider, &self.address)
1490        }
1491    }
1492}
1493/**
1494
1495Generated by the following Solidity interface...
1496```solidity
1497library IRewardsCoordinatorTypes {
1498    struct OperatorDirectedRewardsSubmission {
1499        StrategyAndMultiplier[] strategiesAndMultipliers;
1500        address token;
1501        OperatorReward[] operatorRewards;
1502        uint32 startTimestamp;
1503        uint32 duration;
1504        string description;
1505    }
1506    struct OperatorReward {
1507        address operator;
1508        uint256 amount;
1509    }
1510    struct RewardsSubmission {
1511        StrategyAndMultiplier[] strategiesAndMultipliers;
1512        address token;
1513        uint256 amount;
1514        uint32 startTimestamp;
1515        uint32 duration;
1516    }
1517    struct StrategyAndMultiplier {
1518        address strategy;
1519        uint96 multiplier;
1520    }
1521}
1522
1523library ISignatureUtilsMixinTypes {
1524    struct SignatureWithSaltAndExpiry {
1525        bytes signature;
1526        bytes32 salt;
1527        uint256 expiry;
1528    }
1529}
1530
1531interface ServiceManagerBase {
1532    error DelayPeriodNotPassed();
1533    error OnlyRegistryCoordinator();
1534    error OnlyRewardsInitiator();
1535    error OnlyStakeRegistry();
1536
1537    event Initialized(uint8 version);
1538    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
1539    event RewardsInitiatorUpdated(address prevRewardsInitiator, address newRewardsInitiator);
1540
1541    function addPendingAdmin(address admin) external;
1542    function avsDirectory() external view returns (address);
1543    function createAVSRewardsSubmission(IRewardsCoordinatorTypes.RewardsSubmission[] memory rewardsSubmissions) external;
1544    function createOperatorDirectedAVSRewardsSubmission(IRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission[] memory operatorDirectedRewardsSubmissions) external;
1545    function deregisterOperatorFromAVS(address operator) external;
1546    function deregisterOperatorFromOperatorSets(address operator, uint32[] memory operatorSetIds) external;
1547    function getOperatorRestakedStrategies(address operator) external view returns (address[] memory);
1548    function getRestakeableStrategies() external view returns (address[] memory);
1549    function owner() external view returns (address);
1550    function registerOperatorToAVS(address operator, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
1551    function removeAdmin(address admin) external;
1552    function removeAppointee(address appointee, address target, bytes4 selector) external;
1553    function removePendingAdmin(address pendingAdmin) external;
1554    function renounceOwnership() external;
1555    function rewardsInitiator() external view returns (address);
1556    function setAppointee(address appointee, address target, bytes4 selector) external;
1557    function setClaimerFor(address claimer) external;
1558    function setRewardsInitiator(address newRewardsInitiator) external;
1559    function transferOwnership(address newOwner) external;
1560    function updateAVSMetadataURI(string memory _metadataURI) external;
1561}
1562```
1563
1564...which was generated by the following JSON ABI:
1565```json
1566[
1567  {
1568    "type": "function",
1569    "name": "addPendingAdmin",
1570    "inputs": [
1571      {
1572        "name": "admin",
1573        "type": "address",
1574        "internalType": "address"
1575      }
1576    ],
1577    "outputs": [],
1578    "stateMutability": "nonpayable"
1579  },
1580  {
1581    "type": "function",
1582    "name": "avsDirectory",
1583    "inputs": [],
1584    "outputs": [
1585      {
1586        "name": "",
1587        "type": "address",
1588        "internalType": "address"
1589      }
1590    ],
1591    "stateMutability": "view"
1592  },
1593  {
1594    "type": "function",
1595    "name": "createAVSRewardsSubmission",
1596    "inputs": [
1597      {
1598        "name": "rewardsSubmissions",
1599        "type": "tuple[]",
1600        "internalType": "struct IRewardsCoordinatorTypes.RewardsSubmission[]",
1601        "components": [
1602          {
1603            "name": "strategiesAndMultipliers",
1604            "type": "tuple[]",
1605            "internalType": "struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]",
1606            "components": [
1607              {
1608                "name": "strategy",
1609                "type": "address",
1610                "internalType": "contract IStrategy"
1611              },
1612              {
1613                "name": "multiplier",
1614                "type": "uint96",
1615                "internalType": "uint96"
1616              }
1617            ]
1618          },
1619          {
1620            "name": "token",
1621            "type": "address",
1622            "internalType": "contract IERC20"
1623          },
1624          {
1625            "name": "amount",
1626            "type": "uint256",
1627            "internalType": "uint256"
1628          },
1629          {
1630            "name": "startTimestamp",
1631            "type": "uint32",
1632            "internalType": "uint32"
1633          },
1634          {
1635            "name": "duration",
1636            "type": "uint32",
1637            "internalType": "uint32"
1638          }
1639        ]
1640      }
1641    ],
1642    "outputs": [],
1643    "stateMutability": "nonpayable"
1644  },
1645  {
1646    "type": "function",
1647    "name": "createOperatorDirectedAVSRewardsSubmission",
1648    "inputs": [
1649      {
1650        "name": "operatorDirectedRewardsSubmissions",
1651        "type": "tuple[]",
1652        "internalType": "struct IRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission[]",
1653        "components": [
1654          {
1655            "name": "strategiesAndMultipliers",
1656            "type": "tuple[]",
1657            "internalType": "struct IRewardsCoordinatorTypes.StrategyAndMultiplier[]",
1658            "components": [
1659              {
1660                "name": "strategy",
1661                "type": "address",
1662                "internalType": "contract IStrategy"
1663              },
1664              {
1665                "name": "multiplier",
1666                "type": "uint96",
1667                "internalType": "uint96"
1668              }
1669            ]
1670          },
1671          {
1672            "name": "token",
1673            "type": "address",
1674            "internalType": "contract IERC20"
1675          },
1676          {
1677            "name": "operatorRewards",
1678            "type": "tuple[]",
1679            "internalType": "struct IRewardsCoordinatorTypes.OperatorReward[]",
1680            "components": [
1681              {
1682                "name": "operator",
1683                "type": "address",
1684                "internalType": "address"
1685              },
1686              {
1687                "name": "amount",
1688                "type": "uint256",
1689                "internalType": "uint256"
1690              }
1691            ]
1692          },
1693          {
1694            "name": "startTimestamp",
1695            "type": "uint32",
1696            "internalType": "uint32"
1697          },
1698          {
1699            "name": "duration",
1700            "type": "uint32",
1701            "internalType": "uint32"
1702          },
1703          {
1704            "name": "description",
1705            "type": "string",
1706            "internalType": "string"
1707          }
1708        ]
1709      }
1710    ],
1711    "outputs": [],
1712    "stateMutability": "nonpayable"
1713  },
1714  {
1715    "type": "function",
1716    "name": "deregisterOperatorFromAVS",
1717    "inputs": [
1718      {
1719        "name": "operator",
1720        "type": "address",
1721        "internalType": "address"
1722      }
1723    ],
1724    "outputs": [],
1725    "stateMutability": "nonpayable"
1726  },
1727  {
1728    "type": "function",
1729    "name": "deregisterOperatorFromOperatorSets",
1730    "inputs": [
1731      {
1732        "name": "operator",
1733        "type": "address",
1734        "internalType": "address"
1735      },
1736      {
1737        "name": "operatorSetIds",
1738        "type": "uint32[]",
1739        "internalType": "uint32[]"
1740      }
1741    ],
1742    "outputs": [],
1743    "stateMutability": "nonpayable"
1744  },
1745  {
1746    "type": "function",
1747    "name": "getOperatorRestakedStrategies",
1748    "inputs": [
1749      {
1750        "name": "operator",
1751        "type": "address",
1752        "internalType": "address"
1753      }
1754    ],
1755    "outputs": [
1756      {
1757        "name": "",
1758        "type": "address[]",
1759        "internalType": "address[]"
1760      }
1761    ],
1762    "stateMutability": "view"
1763  },
1764  {
1765    "type": "function",
1766    "name": "getRestakeableStrategies",
1767    "inputs": [],
1768    "outputs": [
1769      {
1770        "name": "",
1771        "type": "address[]",
1772        "internalType": "address[]"
1773      }
1774    ],
1775    "stateMutability": "view"
1776  },
1777  {
1778    "type": "function",
1779    "name": "owner",
1780    "inputs": [],
1781    "outputs": [
1782      {
1783        "name": "",
1784        "type": "address",
1785        "internalType": "address"
1786      }
1787    ],
1788    "stateMutability": "view"
1789  },
1790  {
1791    "type": "function",
1792    "name": "registerOperatorToAVS",
1793    "inputs": [
1794      {
1795        "name": "operator",
1796        "type": "address",
1797        "internalType": "address"
1798      },
1799      {
1800        "name": "operatorSignature",
1801        "type": "tuple",
1802        "internalType": "struct ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry",
1803        "components": [
1804          {
1805            "name": "signature",
1806            "type": "bytes",
1807            "internalType": "bytes"
1808          },
1809          {
1810            "name": "salt",
1811            "type": "bytes32",
1812            "internalType": "bytes32"
1813          },
1814          {
1815            "name": "expiry",
1816            "type": "uint256",
1817            "internalType": "uint256"
1818          }
1819        ]
1820      }
1821    ],
1822    "outputs": [],
1823    "stateMutability": "nonpayable"
1824  },
1825  {
1826    "type": "function",
1827    "name": "removeAdmin",
1828    "inputs": [
1829      {
1830        "name": "admin",
1831        "type": "address",
1832        "internalType": "address"
1833      }
1834    ],
1835    "outputs": [],
1836    "stateMutability": "nonpayable"
1837  },
1838  {
1839    "type": "function",
1840    "name": "removeAppointee",
1841    "inputs": [
1842      {
1843        "name": "appointee",
1844        "type": "address",
1845        "internalType": "address"
1846      },
1847      {
1848        "name": "target",
1849        "type": "address",
1850        "internalType": "address"
1851      },
1852      {
1853        "name": "selector",
1854        "type": "bytes4",
1855        "internalType": "bytes4"
1856      }
1857    ],
1858    "outputs": [],
1859    "stateMutability": "nonpayable"
1860  },
1861  {
1862    "type": "function",
1863    "name": "removePendingAdmin",
1864    "inputs": [
1865      {
1866        "name": "pendingAdmin",
1867        "type": "address",
1868        "internalType": "address"
1869      }
1870    ],
1871    "outputs": [],
1872    "stateMutability": "nonpayable"
1873  },
1874  {
1875    "type": "function",
1876    "name": "renounceOwnership",
1877    "inputs": [],
1878    "outputs": [],
1879    "stateMutability": "nonpayable"
1880  },
1881  {
1882    "type": "function",
1883    "name": "rewardsInitiator",
1884    "inputs": [],
1885    "outputs": [
1886      {
1887        "name": "",
1888        "type": "address",
1889        "internalType": "address"
1890      }
1891    ],
1892    "stateMutability": "view"
1893  },
1894  {
1895    "type": "function",
1896    "name": "setAppointee",
1897    "inputs": [
1898      {
1899        "name": "appointee",
1900        "type": "address",
1901        "internalType": "address"
1902      },
1903      {
1904        "name": "target",
1905        "type": "address",
1906        "internalType": "address"
1907      },
1908      {
1909        "name": "selector",
1910        "type": "bytes4",
1911        "internalType": "bytes4"
1912      }
1913    ],
1914    "outputs": [],
1915    "stateMutability": "nonpayable"
1916  },
1917  {
1918    "type": "function",
1919    "name": "setClaimerFor",
1920    "inputs": [
1921      {
1922        "name": "claimer",
1923        "type": "address",
1924        "internalType": "address"
1925      }
1926    ],
1927    "outputs": [],
1928    "stateMutability": "nonpayable"
1929  },
1930  {
1931    "type": "function",
1932    "name": "setRewardsInitiator",
1933    "inputs": [
1934      {
1935        "name": "newRewardsInitiator",
1936        "type": "address",
1937        "internalType": "address"
1938      }
1939    ],
1940    "outputs": [],
1941    "stateMutability": "nonpayable"
1942  },
1943  {
1944    "type": "function",
1945    "name": "transferOwnership",
1946    "inputs": [
1947      {
1948        "name": "newOwner",
1949        "type": "address",
1950        "internalType": "address"
1951      }
1952    ],
1953    "outputs": [],
1954    "stateMutability": "nonpayable"
1955  },
1956  {
1957    "type": "function",
1958    "name": "updateAVSMetadataURI",
1959    "inputs": [
1960      {
1961        "name": "_metadataURI",
1962        "type": "string",
1963        "internalType": "string"
1964      }
1965    ],
1966    "outputs": [],
1967    "stateMutability": "nonpayable"
1968  },
1969  {
1970    "type": "event",
1971    "name": "Initialized",
1972    "inputs": [
1973      {
1974        "name": "version",
1975        "type": "uint8",
1976        "indexed": false,
1977        "internalType": "uint8"
1978      }
1979    ],
1980    "anonymous": false
1981  },
1982  {
1983    "type": "event",
1984    "name": "OwnershipTransferred",
1985    "inputs": [
1986      {
1987        "name": "previousOwner",
1988        "type": "address",
1989        "indexed": true,
1990        "internalType": "address"
1991      },
1992      {
1993        "name": "newOwner",
1994        "type": "address",
1995        "indexed": true,
1996        "internalType": "address"
1997      }
1998    ],
1999    "anonymous": false
2000  },
2001  {
2002    "type": "event",
2003    "name": "RewardsInitiatorUpdated",
2004    "inputs": [
2005      {
2006        "name": "prevRewardsInitiator",
2007        "type": "address",
2008        "indexed": false,
2009        "internalType": "address"
2010      },
2011      {
2012        "name": "newRewardsInitiator",
2013        "type": "address",
2014        "indexed": false,
2015        "internalType": "address"
2016      }
2017    ],
2018    "anonymous": false
2019  },
2020  {
2021    "type": "error",
2022    "name": "DelayPeriodNotPassed",
2023    "inputs": []
2024  },
2025  {
2026    "type": "error",
2027    "name": "OnlyRegistryCoordinator",
2028    "inputs": []
2029  },
2030  {
2031    "type": "error",
2032    "name": "OnlyRewardsInitiator",
2033    "inputs": []
2034  },
2035  {
2036    "type": "error",
2037    "name": "OnlyStakeRegistry",
2038    "inputs": []
2039  }
2040]
2041```*/
2042#[allow(
2043    non_camel_case_types,
2044    non_snake_case,
2045    clippy::pub_underscore_fields,
2046    clippy::style,
2047    clippy::empty_structs_with_brackets
2048)]
2049pub mod ServiceManagerBase {
2050    use super::*;
2051    use alloy::sol_types as alloy_sol_types;
2052    /// The creation / init bytecode of the contract.
2053    ///
2054    /// ```text
2055    ///0x
2056    /// ```
2057    #[rustfmt::skip]
2058    #[allow(clippy::all)]
2059    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2060        b"",
2061    );
2062    /// The runtime bytecode of the contract, as deployed on the network.
2063    ///
2064    /// ```text
2065    ///0x
2066    /// ```
2067    #[rustfmt::skip]
2068    #[allow(clippy::all)]
2069    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
2070        b"",
2071    );
2072    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2073    /**Custom error with signature `DelayPeriodNotPassed()` and selector `0xfb623b04`.
2074    ```solidity
2075    error DelayPeriodNotPassed();
2076    ```*/
2077    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2078    #[derive(Clone)]
2079    pub struct DelayPeriodNotPassed;
2080    #[allow(
2081        non_camel_case_types,
2082        non_snake_case,
2083        clippy::pub_underscore_fields,
2084        clippy::style
2085    )]
2086    const _: () = {
2087        use alloy::sol_types as alloy_sol_types;
2088        #[doc(hidden)]
2089        type UnderlyingSolTuple<'a> = ();
2090        #[doc(hidden)]
2091        type UnderlyingRustTuple<'a> = ();
2092        #[cfg(test)]
2093        #[allow(dead_code, unreachable_patterns)]
2094        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2095            match _t {
2096                alloy_sol_types::private::AssertTypeEq::<
2097                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2098                >(_) => {}
2099            }
2100        }
2101        #[automatically_derived]
2102        #[doc(hidden)]
2103        impl ::core::convert::From<DelayPeriodNotPassed> for UnderlyingRustTuple<'_> {
2104            fn from(value: DelayPeriodNotPassed) -> Self {
2105                ()
2106            }
2107        }
2108        #[automatically_derived]
2109        #[doc(hidden)]
2110        impl ::core::convert::From<UnderlyingRustTuple<'_>> for DelayPeriodNotPassed {
2111            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2112                Self
2113            }
2114        }
2115        #[automatically_derived]
2116        impl alloy_sol_types::SolError for DelayPeriodNotPassed {
2117            type Parameters<'a> = UnderlyingSolTuple<'a>;
2118            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2119            const SIGNATURE: &'static str = "DelayPeriodNotPassed()";
2120            const SELECTOR: [u8; 4] = [251u8, 98u8, 59u8, 4u8];
2121            #[inline]
2122            fn new<'a>(
2123                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2124            ) -> Self {
2125                tuple.into()
2126            }
2127            #[inline]
2128            fn tokenize(&self) -> Self::Token<'_> {
2129                ()
2130            }
2131            #[inline]
2132            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2133                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2134                    data,
2135                )
2136                .map(Self::new)
2137            }
2138        }
2139    };
2140    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2141    /**Custom error with signature `OnlyRegistryCoordinator()` and selector `0x8729b7be`.
2142    ```solidity
2143    error OnlyRegistryCoordinator();
2144    ```*/
2145    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2146    #[derive(Clone)]
2147    pub struct OnlyRegistryCoordinator;
2148    #[allow(
2149        non_camel_case_types,
2150        non_snake_case,
2151        clippy::pub_underscore_fields,
2152        clippy::style
2153    )]
2154    const _: () = {
2155        use alloy::sol_types as alloy_sol_types;
2156        #[doc(hidden)]
2157        type UnderlyingSolTuple<'a> = ();
2158        #[doc(hidden)]
2159        type UnderlyingRustTuple<'a> = ();
2160        #[cfg(test)]
2161        #[allow(dead_code, unreachable_patterns)]
2162        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2163            match _t {
2164                alloy_sol_types::private::AssertTypeEq::<
2165                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2166                >(_) => {}
2167            }
2168        }
2169        #[automatically_derived]
2170        #[doc(hidden)]
2171        impl ::core::convert::From<OnlyRegistryCoordinator> for UnderlyingRustTuple<'_> {
2172            fn from(value: OnlyRegistryCoordinator) -> Self {
2173                ()
2174            }
2175        }
2176        #[automatically_derived]
2177        #[doc(hidden)]
2178        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyRegistryCoordinator {
2179            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2180                Self
2181            }
2182        }
2183        #[automatically_derived]
2184        impl alloy_sol_types::SolError for OnlyRegistryCoordinator {
2185            type Parameters<'a> = UnderlyingSolTuple<'a>;
2186            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2187            const SIGNATURE: &'static str = "OnlyRegistryCoordinator()";
2188            const SELECTOR: [u8; 4] = [135u8, 41u8, 183u8, 190u8];
2189            #[inline]
2190            fn new<'a>(
2191                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2192            ) -> Self {
2193                tuple.into()
2194            }
2195            #[inline]
2196            fn tokenize(&self) -> Self::Token<'_> {
2197                ()
2198            }
2199            #[inline]
2200            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2201                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2202                    data,
2203                )
2204                .map(Self::new)
2205            }
2206        }
2207    };
2208    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2209    /**Custom error with signature `OnlyRewardsInitiator()` and selector `0x8e79fdb5`.
2210    ```solidity
2211    error OnlyRewardsInitiator();
2212    ```*/
2213    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2214    #[derive(Clone)]
2215    pub struct OnlyRewardsInitiator;
2216    #[allow(
2217        non_camel_case_types,
2218        non_snake_case,
2219        clippy::pub_underscore_fields,
2220        clippy::style
2221    )]
2222    const _: () = {
2223        use alloy::sol_types as alloy_sol_types;
2224        #[doc(hidden)]
2225        type UnderlyingSolTuple<'a> = ();
2226        #[doc(hidden)]
2227        type UnderlyingRustTuple<'a> = ();
2228        #[cfg(test)]
2229        #[allow(dead_code, unreachable_patterns)]
2230        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2231            match _t {
2232                alloy_sol_types::private::AssertTypeEq::<
2233                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2234                >(_) => {}
2235            }
2236        }
2237        #[automatically_derived]
2238        #[doc(hidden)]
2239        impl ::core::convert::From<OnlyRewardsInitiator> for UnderlyingRustTuple<'_> {
2240            fn from(value: OnlyRewardsInitiator) -> Self {
2241                ()
2242            }
2243        }
2244        #[automatically_derived]
2245        #[doc(hidden)]
2246        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyRewardsInitiator {
2247            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2248                Self
2249            }
2250        }
2251        #[automatically_derived]
2252        impl alloy_sol_types::SolError for OnlyRewardsInitiator {
2253            type Parameters<'a> = UnderlyingSolTuple<'a>;
2254            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2255            const SIGNATURE: &'static str = "OnlyRewardsInitiator()";
2256            const SELECTOR: [u8; 4] = [142u8, 121u8, 253u8, 181u8];
2257            #[inline]
2258            fn new<'a>(
2259                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2260            ) -> Self {
2261                tuple.into()
2262            }
2263            #[inline]
2264            fn tokenize(&self) -> Self::Token<'_> {
2265                ()
2266            }
2267            #[inline]
2268            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2269                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2270                    data,
2271                )
2272                .map(Self::new)
2273            }
2274        }
2275    };
2276    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2277    /**Custom error with signature `OnlyStakeRegistry()` and selector `0x46bf2281`.
2278    ```solidity
2279    error OnlyStakeRegistry();
2280    ```*/
2281    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2282    #[derive(Clone)]
2283    pub struct OnlyStakeRegistry;
2284    #[allow(
2285        non_camel_case_types,
2286        non_snake_case,
2287        clippy::pub_underscore_fields,
2288        clippy::style
2289    )]
2290    const _: () = {
2291        use alloy::sol_types as alloy_sol_types;
2292        #[doc(hidden)]
2293        type UnderlyingSolTuple<'a> = ();
2294        #[doc(hidden)]
2295        type UnderlyingRustTuple<'a> = ();
2296        #[cfg(test)]
2297        #[allow(dead_code, unreachable_patterns)]
2298        fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2299            match _t {
2300                alloy_sol_types::private::AssertTypeEq::<
2301                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2302                >(_) => {}
2303            }
2304        }
2305        #[automatically_derived]
2306        #[doc(hidden)]
2307        impl ::core::convert::From<OnlyStakeRegistry> for UnderlyingRustTuple<'_> {
2308            fn from(value: OnlyStakeRegistry) -> Self {
2309                ()
2310            }
2311        }
2312        #[automatically_derived]
2313        #[doc(hidden)]
2314        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyStakeRegistry {
2315            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2316                Self
2317            }
2318        }
2319        #[automatically_derived]
2320        impl alloy_sol_types::SolError for OnlyStakeRegistry {
2321            type Parameters<'a> = UnderlyingSolTuple<'a>;
2322            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2323            const SIGNATURE: &'static str = "OnlyStakeRegistry()";
2324            const SELECTOR: [u8; 4] = [70u8, 191u8, 34u8, 129u8];
2325            #[inline]
2326            fn new<'a>(
2327                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2328            ) -> Self {
2329                tuple.into()
2330            }
2331            #[inline]
2332            fn tokenize(&self) -> Self::Token<'_> {
2333                ()
2334            }
2335            #[inline]
2336            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
2337                <Self::Parameters<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2338                    data,
2339                )
2340                .map(Self::new)
2341            }
2342        }
2343    };
2344    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2345    /**Event with signature `Initialized(uint8)` and selector `0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498`.
2346    ```solidity
2347    event Initialized(uint8 version);
2348    ```*/
2349    #[allow(
2350        non_camel_case_types,
2351        non_snake_case,
2352        clippy::pub_underscore_fields,
2353        clippy::style
2354    )]
2355    #[derive(Clone)]
2356    pub struct Initialized {
2357        #[allow(missing_docs)]
2358        pub version: u8,
2359    }
2360    #[allow(
2361        non_camel_case_types,
2362        non_snake_case,
2363        clippy::pub_underscore_fields,
2364        clippy::style
2365    )]
2366    const _: () = {
2367        use alloy::sol_types as alloy_sol_types;
2368        #[automatically_derived]
2369        impl alloy_sol_types::SolEvent for Initialized {
2370            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
2371            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2372            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2373            const SIGNATURE: &'static str = "Initialized(uint8)";
2374            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2375                alloy_sol_types::private::B256::new([
2376                    127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, 19u8,
2377                    56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, 146u8, 20u8,
2378                    96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
2379                ]);
2380            const ANONYMOUS: bool = false;
2381            #[allow(unused_variables)]
2382            #[inline]
2383            fn new(
2384                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2385                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2386            ) -> Self {
2387                Self { version: data.0 }
2388            }
2389            #[inline]
2390            fn check_signature(
2391                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2392            ) -> alloy_sol_types::Result<()> {
2393                if topics.0 != Self::SIGNATURE_HASH {
2394                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2395                        Self::SIGNATURE,
2396                        topics.0,
2397                        Self::SIGNATURE_HASH,
2398                    ));
2399                }
2400                Ok(())
2401            }
2402            #[inline]
2403            fn tokenize_body(&self) -> Self::DataToken<'_> {
2404                (
2405                    <alloy::sol_types::sol_data::Uint<8> as alloy_sol_types::SolType>::tokenize(
2406                        &self.version,
2407                    ),
2408                )
2409            }
2410            #[inline]
2411            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2412                (Self::SIGNATURE_HASH.into(),)
2413            }
2414            #[inline]
2415            fn encode_topics_raw(
2416                &self,
2417                out: &mut [alloy_sol_types::abi::token::WordToken],
2418            ) -> alloy_sol_types::Result<()> {
2419                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2420                    return Err(alloy_sol_types::Error::Overrun);
2421                }
2422                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2423                Ok(())
2424            }
2425        }
2426        #[automatically_derived]
2427        impl alloy_sol_types::private::IntoLogData for Initialized {
2428            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2429                From::from(self)
2430            }
2431            fn into_log_data(self) -> alloy_sol_types::private::LogData {
2432                From::from(&self)
2433            }
2434        }
2435        #[automatically_derived]
2436        impl From<&Initialized> for alloy_sol_types::private::LogData {
2437            #[inline]
2438            fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
2439                alloy_sol_types::SolEvent::encode_log_data(this)
2440            }
2441        }
2442    };
2443    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2444    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
2445    ```solidity
2446    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
2447    ```*/
2448    #[allow(
2449        non_camel_case_types,
2450        non_snake_case,
2451        clippy::pub_underscore_fields,
2452        clippy::style
2453    )]
2454    #[derive(Clone)]
2455    pub struct OwnershipTransferred {
2456        #[allow(missing_docs)]
2457        pub previousOwner: alloy::sol_types::private::Address,
2458        #[allow(missing_docs)]
2459        pub newOwner: alloy::sol_types::private::Address,
2460    }
2461    #[allow(
2462        non_camel_case_types,
2463        non_snake_case,
2464        clippy::pub_underscore_fields,
2465        clippy::style
2466    )]
2467    const _: () = {
2468        use alloy::sol_types as alloy_sol_types;
2469        #[automatically_derived]
2470        impl alloy_sol_types::SolEvent for OwnershipTransferred {
2471            type DataTuple<'a> = ();
2472            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2473            type TopicList = (
2474                alloy_sol_types::sol_data::FixedBytes<32>,
2475                alloy::sol_types::sol_data::Address,
2476                alloy::sol_types::sol_data::Address,
2477            );
2478            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
2479            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2480                alloy_sol_types::private::B256::new([
2481                    139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8,
2482                    208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8,
2483                    175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
2484                ]);
2485            const ANONYMOUS: bool = false;
2486            #[allow(unused_variables)]
2487            #[inline]
2488            fn new(
2489                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2490                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2491            ) -> Self {
2492                Self {
2493                    previousOwner: topics.1,
2494                    newOwner: topics.2,
2495                }
2496            }
2497            #[inline]
2498            fn check_signature(
2499                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2500            ) -> alloy_sol_types::Result<()> {
2501                if topics.0 != Self::SIGNATURE_HASH {
2502                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2503                        Self::SIGNATURE,
2504                        topics.0,
2505                        Self::SIGNATURE_HASH,
2506                    ));
2507                }
2508                Ok(())
2509            }
2510            #[inline]
2511            fn tokenize_body(&self) -> Self::DataToken<'_> {
2512                ()
2513            }
2514            #[inline]
2515            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2516                (
2517                    Self::SIGNATURE_HASH.into(),
2518                    self.previousOwner.clone(),
2519                    self.newOwner.clone(),
2520                )
2521            }
2522            #[inline]
2523            fn encode_topics_raw(
2524                &self,
2525                out: &mut [alloy_sol_types::abi::token::WordToken],
2526            ) -> alloy_sol_types::Result<()> {
2527                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2528                    return Err(alloy_sol_types::Error::Overrun);
2529                }
2530                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2531                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2532                    &self.previousOwner,
2533                );
2534                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2535                    &self.newOwner,
2536                );
2537                Ok(())
2538            }
2539        }
2540        #[automatically_derived]
2541        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
2542            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2543                From::from(self)
2544            }
2545            fn into_log_data(self) -> alloy_sol_types::private::LogData {
2546                From::from(&self)
2547            }
2548        }
2549        #[automatically_derived]
2550        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
2551            #[inline]
2552            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
2553                alloy_sol_types::SolEvent::encode_log_data(this)
2554            }
2555        }
2556    };
2557    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2558    /**Event with signature `RewardsInitiatorUpdated(address,address)` and selector `0xe11cddf1816a43318ca175bbc52cd0185436e9cbead7c83acc54a73e461717e3`.
2559    ```solidity
2560    event RewardsInitiatorUpdated(address prevRewardsInitiator, address newRewardsInitiator);
2561    ```*/
2562    #[allow(
2563        non_camel_case_types,
2564        non_snake_case,
2565        clippy::pub_underscore_fields,
2566        clippy::style
2567    )]
2568    #[derive(Clone)]
2569    pub struct RewardsInitiatorUpdated {
2570        #[allow(missing_docs)]
2571        pub prevRewardsInitiator: alloy::sol_types::private::Address,
2572        #[allow(missing_docs)]
2573        pub newRewardsInitiator: alloy::sol_types::private::Address,
2574    }
2575    #[allow(
2576        non_camel_case_types,
2577        non_snake_case,
2578        clippy::pub_underscore_fields,
2579        clippy::style
2580    )]
2581    const _: () = {
2582        use alloy::sol_types as alloy_sol_types;
2583        #[automatically_derived]
2584        impl alloy_sol_types::SolEvent for RewardsInitiatorUpdated {
2585            type DataTuple<'a> = (
2586                alloy::sol_types::sol_data::Address,
2587                alloy::sol_types::sol_data::Address,
2588            );
2589            type DataToken<'a> = <Self::DataTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2590            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2591            const SIGNATURE: &'static str = "RewardsInitiatorUpdated(address,address)";
2592            const SIGNATURE_HASH: alloy_sol_types::private::B256 =
2593                alloy_sol_types::private::B256::new([
2594                    225u8, 28u8, 221u8, 241u8, 129u8, 106u8, 67u8, 49u8, 140u8, 161u8, 117u8,
2595                    187u8, 197u8, 44u8, 208u8, 24u8, 84u8, 54u8, 233u8, 203u8, 234u8, 215u8, 200u8,
2596                    58u8, 204u8, 84u8, 167u8, 62u8, 70u8, 23u8, 23u8, 227u8,
2597                ]);
2598            const ANONYMOUS: bool = false;
2599            #[allow(unused_variables)]
2600            #[inline]
2601            fn new(
2602                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2603                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2604            ) -> Self {
2605                Self {
2606                    prevRewardsInitiator: data.0,
2607                    newRewardsInitiator: data.1,
2608                }
2609            }
2610            #[inline]
2611            fn check_signature(
2612                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2613            ) -> alloy_sol_types::Result<()> {
2614                if topics.0 != Self::SIGNATURE_HASH {
2615                    return Err(alloy_sol_types::Error::invalid_event_signature_hash(
2616                        Self::SIGNATURE,
2617                        topics.0,
2618                        Self::SIGNATURE_HASH,
2619                    ));
2620                }
2621                Ok(())
2622            }
2623            #[inline]
2624            fn tokenize_body(&self) -> Self::DataToken<'_> {
2625                (
2626                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2627                        &self.prevRewardsInitiator,
2628                    ),
2629                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2630                        &self.newRewardsInitiator,
2631                    ),
2632                )
2633            }
2634            #[inline]
2635            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2636                (Self::SIGNATURE_HASH.into(),)
2637            }
2638            #[inline]
2639            fn encode_topics_raw(
2640                &self,
2641                out: &mut [alloy_sol_types::abi::token::WordToken],
2642            ) -> alloy_sol_types::Result<()> {
2643                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2644                    return Err(alloy_sol_types::Error::Overrun);
2645                }
2646                out[0usize] = alloy_sol_types::abi::token::WordToken(Self::SIGNATURE_HASH);
2647                Ok(())
2648            }
2649        }
2650        #[automatically_derived]
2651        impl alloy_sol_types::private::IntoLogData for RewardsInitiatorUpdated {
2652            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2653                From::from(self)
2654            }
2655            fn into_log_data(self) -> alloy_sol_types::private::LogData {
2656                From::from(&self)
2657            }
2658        }
2659        #[automatically_derived]
2660        impl From<&RewardsInitiatorUpdated> for alloy_sol_types::private::LogData {
2661            #[inline]
2662            fn from(this: &RewardsInitiatorUpdated) -> alloy_sol_types::private::LogData {
2663                alloy_sol_types::SolEvent::encode_log_data(this)
2664            }
2665        }
2666    };
2667    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2668    /**Function with signature `addPendingAdmin(address)` and selector `0x279432eb`.
2669    ```solidity
2670    function addPendingAdmin(address admin) external;
2671    ```*/
2672    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2673    #[derive(Clone)]
2674    pub struct addPendingAdminCall {
2675        #[allow(missing_docs)]
2676        pub admin: alloy::sol_types::private::Address,
2677    }
2678    ///Container type for the return parameters of the [`addPendingAdmin(address)`](addPendingAdminCall) function.
2679    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2680    #[derive(Clone)]
2681    pub struct addPendingAdminReturn {}
2682    #[allow(
2683        non_camel_case_types,
2684        non_snake_case,
2685        clippy::pub_underscore_fields,
2686        clippy::style
2687    )]
2688    const _: () = {
2689        use alloy::sol_types as alloy_sol_types;
2690        {
2691            #[doc(hidden)]
2692            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2693            #[doc(hidden)]
2694            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2695            #[cfg(test)]
2696            #[allow(dead_code, unreachable_patterns)]
2697            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2698                match _t {
2699                    alloy_sol_types::private::AssertTypeEq::<
2700                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2701                    >(_) => {}
2702                }
2703            }
2704            #[automatically_derived]
2705            #[doc(hidden)]
2706            impl ::core::convert::From<addPendingAdminCall> for UnderlyingRustTuple<'_> {
2707                fn from(value: addPendingAdminCall) -> Self {
2708                    (value.admin,)
2709                }
2710            }
2711            #[automatically_derived]
2712            #[doc(hidden)]
2713            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addPendingAdminCall {
2714                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2715                    Self { admin: tuple.0 }
2716                }
2717            }
2718        }
2719        {
2720            #[doc(hidden)]
2721            type UnderlyingSolTuple<'a> = ();
2722            #[doc(hidden)]
2723            type UnderlyingRustTuple<'a> = ();
2724            #[cfg(test)]
2725            #[allow(dead_code, unreachable_patterns)]
2726            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2727                match _t {
2728                    alloy_sol_types::private::AssertTypeEq::<
2729                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2730                    >(_) => {}
2731                }
2732            }
2733            #[automatically_derived]
2734            #[doc(hidden)]
2735            impl ::core::convert::From<addPendingAdminReturn> for UnderlyingRustTuple<'_> {
2736                fn from(value: addPendingAdminReturn) -> Self {
2737                    ()
2738                }
2739            }
2740            #[automatically_derived]
2741            #[doc(hidden)]
2742            impl ::core::convert::From<UnderlyingRustTuple<'_>> for addPendingAdminReturn {
2743                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2744                    Self {}
2745                }
2746            }
2747        }
2748        impl addPendingAdminReturn {
2749            fn _tokenize(
2750                &self,
2751            ) -> <addPendingAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2752                ()
2753            }
2754        }
2755        #[automatically_derived]
2756        impl alloy_sol_types::SolCall for addPendingAdminCall {
2757            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2758            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2759            type Return = addPendingAdminReturn;
2760            type ReturnTuple<'a> = ();
2761            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2762            const SIGNATURE: &'static str = "addPendingAdmin(address)";
2763            const SELECTOR: [u8; 4] = [39u8, 148u8, 50u8, 235u8];
2764            #[inline]
2765            fn new<'a>(
2766                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2767            ) -> Self {
2768                tuple.into()
2769            }
2770            #[inline]
2771            fn tokenize(&self) -> Self::Token<'_> {
2772                (
2773                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2774                        &self.admin,
2775                    ),
2776                )
2777            }
2778            #[inline]
2779            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2780                addPendingAdminReturn::_tokenize(ret)
2781            }
2782            #[inline]
2783            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2784                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
2785                    .map(Into::into)
2786            }
2787            #[inline]
2788            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2789                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2790                    data,
2791                )
2792                .map(Into::into)
2793            }
2794        }
2795    };
2796    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2797    /**Function with signature `avsDirectory()` and selector `0x6b3aa72e`.
2798    ```solidity
2799    function avsDirectory() external view returns (address);
2800    ```*/
2801    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2802    #[derive(Clone)]
2803    pub struct avsDirectoryCall;
2804    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
2805    ///Container type for the return parameters of the [`avsDirectory()`](avsDirectoryCall) function.
2806    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2807    #[derive(Clone)]
2808    pub struct avsDirectoryReturn {
2809        #[allow(missing_docs)]
2810        pub _0: alloy::sol_types::private::Address,
2811    }
2812    #[allow(
2813        non_camel_case_types,
2814        non_snake_case,
2815        clippy::pub_underscore_fields,
2816        clippy::style
2817    )]
2818    const _: () = {
2819        use alloy::sol_types as alloy_sol_types;
2820        {
2821            #[doc(hidden)]
2822            type UnderlyingSolTuple<'a> = ();
2823            #[doc(hidden)]
2824            type UnderlyingRustTuple<'a> = ();
2825            #[cfg(test)]
2826            #[allow(dead_code, unreachable_patterns)]
2827            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2828                match _t {
2829                    alloy_sol_types::private::AssertTypeEq::<
2830                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2831                    >(_) => {}
2832                }
2833            }
2834            #[automatically_derived]
2835            #[doc(hidden)]
2836            impl ::core::convert::From<avsDirectoryCall> for UnderlyingRustTuple<'_> {
2837                fn from(value: avsDirectoryCall) -> Self {
2838                    ()
2839                }
2840            }
2841            #[automatically_derived]
2842            #[doc(hidden)]
2843            impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsDirectoryCall {
2844                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2845                    Self
2846                }
2847            }
2848        }
2849        {
2850            #[doc(hidden)]
2851            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2852            #[doc(hidden)]
2853            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2854            #[cfg(test)]
2855            #[allow(dead_code, unreachable_patterns)]
2856            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2857                match _t {
2858                    alloy_sol_types::private::AssertTypeEq::<
2859                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2860                    >(_) => {}
2861                }
2862            }
2863            #[automatically_derived]
2864            #[doc(hidden)]
2865            impl ::core::convert::From<avsDirectoryReturn> for UnderlyingRustTuple<'_> {
2866                fn from(value: avsDirectoryReturn) -> Self {
2867                    (value._0,)
2868                }
2869            }
2870            #[automatically_derived]
2871            #[doc(hidden)]
2872            impl ::core::convert::From<UnderlyingRustTuple<'_>> for avsDirectoryReturn {
2873                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2874                    Self { _0: tuple.0 }
2875                }
2876            }
2877        }
2878        #[automatically_derived]
2879        impl alloy_sol_types::SolCall for avsDirectoryCall {
2880            type Parameters<'a> = ();
2881            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
2882            type Return = alloy::sol_types::private::Address;
2883            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2884            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
2885            const SIGNATURE: &'static str = "avsDirectory()";
2886            const SELECTOR: [u8; 4] = [107u8, 58u8, 167u8, 46u8];
2887            #[inline]
2888            fn new<'a>(
2889                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2890            ) -> Self {
2891                tuple.into()
2892            }
2893            #[inline]
2894            fn tokenize(&self) -> Self::Token<'_> {
2895                ()
2896            }
2897            #[inline]
2898            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2899                (
2900                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2901                        ret,
2902                    ),
2903                )
2904            }
2905            #[inline]
2906            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2907                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
2908                    |r| {
2909                        let r: avsDirectoryReturn = r.into();
2910                        r._0
2911                    },
2912                )
2913            }
2914            #[inline]
2915            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2916                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
2917                    data,
2918                )
2919                .map(|r| {
2920                    let r: avsDirectoryReturn = r.into();
2921                    r._0
2922                })
2923            }
2924        }
2925    };
2926    #[derive(serde::Serialize, serde::Deserialize)]
2927    /**Function with signature `createAVSRewardsSubmission(((address,uint96)[],address,uint256,uint32,uint32)[])` and selector `0xfce36c7d`.
2928    ```solidity
2929    function createAVSRewardsSubmission(IRewardsCoordinatorTypes.RewardsSubmission[] memory rewardsSubmissions) external;
2930    ```*/
2931    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2932    #[derive(Clone)]
2933    pub struct createAVSRewardsSubmissionCall {
2934        #[allow(missing_docs)]
2935        pub rewardsSubmissions: alloy::sol_types::private::Vec<
2936            <IRewardsCoordinatorTypes::RewardsSubmission as alloy::sol_types::SolType>::RustType,
2937        >,
2938    }
2939    ///Container type for the return parameters of the [`createAVSRewardsSubmission(((address,uint96)[],address,uint256,uint32,uint32)[])`](createAVSRewardsSubmissionCall) function.
2940    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2941    #[derive(Clone)]
2942    pub struct createAVSRewardsSubmissionReturn {}
2943    #[allow(
2944        non_camel_case_types,
2945        non_snake_case,
2946        clippy::pub_underscore_fields,
2947        clippy::style
2948    )]
2949    const _: () = {
2950        use alloy::sol_types as alloy_sol_types;
2951        {
2952            #[doc(hidden)]
2953            type UnderlyingSolTuple<'a> =
2954                (alloy::sol_types::sol_data::Array<IRewardsCoordinatorTypes::RewardsSubmission>,);
2955            #[doc(hidden)]
2956            type UnderlyingRustTuple<'a> = (
2957                alloy::sol_types::private::Vec<
2958                    <IRewardsCoordinatorTypes::RewardsSubmission as alloy::sol_types::SolType>::RustType,
2959                >,
2960            );
2961            #[cfg(test)]
2962            #[allow(dead_code, unreachable_patterns)]
2963            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2964                match _t {
2965                    alloy_sol_types::private::AssertTypeEq::<
2966                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2967                    >(_) => {}
2968                }
2969            }
2970            #[automatically_derived]
2971            #[doc(hidden)]
2972            impl ::core::convert::From<createAVSRewardsSubmissionCall> for UnderlyingRustTuple<'_> {
2973                fn from(value: createAVSRewardsSubmissionCall) -> Self {
2974                    (value.rewardsSubmissions,)
2975                }
2976            }
2977            #[automatically_derived]
2978            #[doc(hidden)]
2979            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createAVSRewardsSubmissionCall {
2980                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2981                    Self {
2982                        rewardsSubmissions: tuple.0,
2983                    }
2984                }
2985            }
2986        }
2987        {
2988            #[doc(hidden)]
2989            type UnderlyingSolTuple<'a> = ();
2990            #[doc(hidden)]
2991            type UnderlyingRustTuple<'a> = ();
2992            #[cfg(test)]
2993            #[allow(dead_code, unreachable_patterns)]
2994            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
2995                match _t {
2996                    alloy_sol_types::private::AssertTypeEq::<
2997                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2998                    >(_) => {}
2999                }
3000            }
3001            #[automatically_derived]
3002            #[doc(hidden)]
3003            impl ::core::convert::From<createAVSRewardsSubmissionReturn> for UnderlyingRustTuple<'_> {
3004                fn from(value: createAVSRewardsSubmissionReturn) -> Self {
3005                    ()
3006                }
3007            }
3008            #[automatically_derived]
3009            #[doc(hidden)]
3010            impl ::core::convert::From<UnderlyingRustTuple<'_>> for createAVSRewardsSubmissionReturn {
3011                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3012                    Self {}
3013                }
3014            }
3015        }
3016        impl createAVSRewardsSubmissionReturn {
3017            fn _tokenize(
3018                &self,
3019            ) -> <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::ReturnToken<'_>
3020            {
3021                ()
3022            }
3023        }
3024        #[automatically_derived]
3025        impl alloy_sol_types::SolCall for createAVSRewardsSubmissionCall {
3026            type Parameters<'a> =
3027                (alloy::sol_types::sol_data::Array<IRewardsCoordinatorTypes::RewardsSubmission>,);
3028            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3029            type Return = createAVSRewardsSubmissionReturn;
3030            type ReturnTuple<'a> = ();
3031            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3032            const SIGNATURE: &'static str =
3033                "createAVSRewardsSubmission(((address,uint96)[],address,uint256,uint32,uint32)[])";
3034            const SELECTOR: [u8; 4] = [252u8, 227u8, 108u8, 125u8];
3035            #[inline]
3036            fn new<'a>(
3037                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3038            ) -> Self {
3039                tuple.into()
3040            }
3041            #[inline]
3042            fn tokenize(&self) -> Self::Token<'_> {
3043                (<alloy::sol_types::sol_data::Array<
3044                    IRewardsCoordinatorTypes::RewardsSubmission,
3045                > as alloy_sol_types::SolType>::tokenize(
3046                    &self.rewardsSubmissions,
3047                ),)
3048            }
3049            #[inline]
3050            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3051                createAVSRewardsSubmissionReturn::_tokenize(ret)
3052            }
3053            #[inline]
3054            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3055                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
3056                    .map(Into::into)
3057            }
3058            #[inline]
3059            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3060                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3061                    data,
3062                )
3063                .map(Into::into)
3064            }
3065        }
3066    };
3067    #[derive(serde::Serialize, serde::Deserialize)]
3068    /**Function with signature `createOperatorDirectedAVSRewardsSubmission(((address,uint96)[],address,(address,uint256)[],uint32,uint32,string)[])` and selector `0xa20b99bf`.
3069    ```solidity
3070    function createOperatorDirectedAVSRewardsSubmission(IRewardsCoordinatorTypes.OperatorDirectedRewardsSubmission[] memory operatorDirectedRewardsSubmissions) external;
3071    ```*/
3072    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3073    #[derive(Clone)]
3074    pub struct createOperatorDirectedAVSRewardsSubmissionCall {
3075        #[allow(missing_docs)]
3076        pub operatorDirectedRewardsSubmissions: alloy::sol_types::private::Vec<
3077            <IRewardsCoordinatorTypes::OperatorDirectedRewardsSubmission as alloy::sol_types::SolType>::RustType,
3078        >,
3079    }
3080    ///Container type for the return parameters of the [`createOperatorDirectedAVSRewardsSubmission(((address,uint96)[],address,(address,uint256)[],uint32,uint32,string)[])`](createOperatorDirectedAVSRewardsSubmissionCall) function.
3081    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3082    #[derive(Clone)]
3083    pub struct createOperatorDirectedAVSRewardsSubmissionReturn {}
3084    #[allow(
3085        non_camel_case_types,
3086        non_snake_case,
3087        clippy::pub_underscore_fields,
3088        clippy::style
3089    )]
3090    const _: () = {
3091        use alloy::sol_types as alloy_sol_types;
3092        {
3093            #[doc(hidden)]
3094            type UnderlyingSolTuple<'a> = (
3095                alloy::sol_types::sol_data::Array<
3096                    IRewardsCoordinatorTypes::OperatorDirectedRewardsSubmission,
3097                >,
3098            );
3099            #[doc(hidden)]
3100            type UnderlyingRustTuple<'a> = (
3101                alloy::sol_types::private::Vec<
3102                    <IRewardsCoordinatorTypes::OperatorDirectedRewardsSubmission as alloy::sol_types::SolType>::RustType,
3103                >,
3104            );
3105            #[cfg(test)]
3106            #[allow(dead_code, unreachable_patterns)]
3107            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3108                match _t {
3109                    alloy_sol_types::private::AssertTypeEq::<
3110                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3111                    >(_) => {}
3112                }
3113            }
3114            #[automatically_derived]
3115            #[doc(hidden)]
3116            impl ::core::convert::From<createOperatorDirectedAVSRewardsSubmissionCall>
3117                for UnderlyingRustTuple<'_>
3118            {
3119                fn from(value: createOperatorDirectedAVSRewardsSubmissionCall) -> Self {
3120                    (value.operatorDirectedRewardsSubmissions,)
3121                }
3122            }
3123            #[automatically_derived]
3124            #[doc(hidden)]
3125            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3126                for createOperatorDirectedAVSRewardsSubmissionCall
3127            {
3128                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3129                    Self {
3130                        operatorDirectedRewardsSubmissions: tuple.0,
3131                    }
3132                }
3133            }
3134        }
3135        {
3136            #[doc(hidden)]
3137            type UnderlyingSolTuple<'a> = ();
3138            #[doc(hidden)]
3139            type UnderlyingRustTuple<'a> = ();
3140            #[cfg(test)]
3141            #[allow(dead_code, unreachable_patterns)]
3142            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3143                match _t {
3144                    alloy_sol_types::private::AssertTypeEq::<
3145                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3146                    >(_) => {}
3147                }
3148            }
3149            #[automatically_derived]
3150            #[doc(hidden)]
3151            impl ::core::convert::From<createOperatorDirectedAVSRewardsSubmissionReturn>
3152                for UnderlyingRustTuple<'_>
3153            {
3154                fn from(value: createOperatorDirectedAVSRewardsSubmissionReturn) -> Self {
3155                    ()
3156                }
3157            }
3158            #[automatically_derived]
3159            #[doc(hidden)]
3160            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3161                for createOperatorDirectedAVSRewardsSubmissionReturn
3162            {
3163                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3164                    Self {}
3165                }
3166            }
3167        }
3168        impl createOperatorDirectedAVSRewardsSubmissionReturn {
3169            fn _tokenize(
3170                &self,
3171            ) -> <createOperatorDirectedAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::ReturnToken<
3172                '_,
3173            >{
3174                ()
3175            }
3176        }
3177        #[automatically_derived]
3178        impl alloy_sol_types::SolCall for createOperatorDirectedAVSRewardsSubmissionCall {
3179            type Parameters<'a> = (
3180                alloy::sol_types::sol_data::Array<
3181                    IRewardsCoordinatorTypes::OperatorDirectedRewardsSubmission,
3182                >,
3183            );
3184            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3185            type Return = createOperatorDirectedAVSRewardsSubmissionReturn;
3186            type ReturnTuple<'a> = ();
3187            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3188            const SIGNATURE: &'static str = "createOperatorDirectedAVSRewardsSubmission(((address,uint96)[],address,(address,uint256)[],uint32,uint32,string)[])";
3189            const SELECTOR: [u8; 4] = [162u8, 11u8, 153u8, 191u8];
3190            #[inline]
3191            fn new<'a>(
3192                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3193            ) -> Self {
3194                tuple.into()
3195            }
3196            #[inline]
3197            fn tokenize(&self) -> Self::Token<'_> {
3198                (<alloy::sol_types::sol_data::Array<
3199                    IRewardsCoordinatorTypes::OperatorDirectedRewardsSubmission,
3200                > as alloy_sol_types::SolType>::tokenize(
3201                    &self.operatorDirectedRewardsSubmissions,
3202                ),)
3203            }
3204            #[inline]
3205            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3206                createOperatorDirectedAVSRewardsSubmissionReturn::_tokenize(ret)
3207            }
3208            #[inline]
3209            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3210                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
3211                    .map(Into::into)
3212            }
3213            #[inline]
3214            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3215                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3216                    data,
3217                )
3218                .map(Into::into)
3219            }
3220        }
3221    };
3222    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3223    /**Function with signature `deregisterOperatorFromAVS(address)` and selector `0xa364f4da`.
3224    ```solidity
3225    function deregisterOperatorFromAVS(address operator) external;
3226    ```*/
3227    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3228    #[derive(Clone)]
3229    pub struct deregisterOperatorFromAVSCall {
3230        #[allow(missing_docs)]
3231        pub operator: alloy::sol_types::private::Address,
3232    }
3233    ///Container type for the return parameters of the [`deregisterOperatorFromAVS(address)`](deregisterOperatorFromAVSCall) function.
3234    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3235    #[derive(Clone)]
3236    pub struct deregisterOperatorFromAVSReturn {}
3237    #[allow(
3238        non_camel_case_types,
3239        non_snake_case,
3240        clippy::pub_underscore_fields,
3241        clippy::style
3242    )]
3243    const _: () = {
3244        use alloy::sol_types as alloy_sol_types;
3245        {
3246            #[doc(hidden)]
3247            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3248            #[doc(hidden)]
3249            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3250            #[cfg(test)]
3251            #[allow(dead_code, unreachable_patterns)]
3252            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3253                match _t {
3254                    alloy_sol_types::private::AssertTypeEq::<
3255                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3256                    >(_) => {}
3257                }
3258            }
3259            #[automatically_derived]
3260            #[doc(hidden)]
3261            impl ::core::convert::From<deregisterOperatorFromAVSCall> for UnderlyingRustTuple<'_> {
3262                fn from(value: deregisterOperatorFromAVSCall) -> Self {
3263                    (value.operator,)
3264                }
3265            }
3266            #[automatically_derived]
3267            #[doc(hidden)]
3268            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterOperatorFromAVSCall {
3269                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3270                    Self { operator: tuple.0 }
3271                }
3272            }
3273        }
3274        {
3275            #[doc(hidden)]
3276            type UnderlyingSolTuple<'a> = ();
3277            #[doc(hidden)]
3278            type UnderlyingRustTuple<'a> = ();
3279            #[cfg(test)]
3280            #[allow(dead_code, unreachable_patterns)]
3281            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3282                match _t {
3283                    alloy_sol_types::private::AssertTypeEq::<
3284                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3285                    >(_) => {}
3286                }
3287            }
3288            #[automatically_derived]
3289            #[doc(hidden)]
3290            impl ::core::convert::From<deregisterOperatorFromAVSReturn> for UnderlyingRustTuple<'_> {
3291                fn from(value: deregisterOperatorFromAVSReturn) -> Self {
3292                    ()
3293                }
3294            }
3295            #[automatically_derived]
3296            #[doc(hidden)]
3297            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterOperatorFromAVSReturn {
3298                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3299                    Self {}
3300                }
3301            }
3302        }
3303        impl deregisterOperatorFromAVSReturn {
3304            fn _tokenize(
3305                &self,
3306            ) -> <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::ReturnToken<'_>
3307            {
3308                ()
3309            }
3310        }
3311        #[automatically_derived]
3312        impl alloy_sol_types::SolCall for deregisterOperatorFromAVSCall {
3313            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3314            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3315            type Return = deregisterOperatorFromAVSReturn;
3316            type ReturnTuple<'a> = ();
3317            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3318            const SIGNATURE: &'static str = "deregisterOperatorFromAVS(address)";
3319            const SELECTOR: [u8; 4] = [163u8, 100u8, 244u8, 218u8];
3320            #[inline]
3321            fn new<'a>(
3322                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3323            ) -> Self {
3324                tuple.into()
3325            }
3326            #[inline]
3327            fn tokenize(&self) -> Self::Token<'_> {
3328                (
3329                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3330                        &self.operator,
3331                    ),
3332                )
3333            }
3334            #[inline]
3335            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3336                deregisterOperatorFromAVSReturn::_tokenize(ret)
3337            }
3338            #[inline]
3339            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3340                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
3341                    .map(Into::into)
3342            }
3343            #[inline]
3344            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3345                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3346                    data,
3347                )
3348                .map(Into::into)
3349            }
3350        }
3351    };
3352    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3353    /**Function with signature `deregisterOperatorFromOperatorSets(address,uint32[])` and selector `0xc1a8e2c5`.
3354    ```solidity
3355    function deregisterOperatorFromOperatorSets(address operator, uint32[] memory operatorSetIds) external;
3356    ```*/
3357    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3358    #[derive(Clone)]
3359    pub struct deregisterOperatorFromOperatorSetsCall {
3360        #[allow(missing_docs)]
3361        pub operator: alloy::sol_types::private::Address,
3362        #[allow(missing_docs)]
3363        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
3364    }
3365    ///Container type for the return parameters of the [`deregisterOperatorFromOperatorSets(address,uint32[])`](deregisterOperatorFromOperatorSetsCall) function.
3366    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3367    #[derive(Clone)]
3368    pub struct deregisterOperatorFromOperatorSetsReturn {}
3369    #[allow(
3370        non_camel_case_types,
3371        non_snake_case,
3372        clippy::pub_underscore_fields,
3373        clippy::style
3374    )]
3375    const _: () = {
3376        use alloy::sol_types as alloy_sol_types;
3377        {
3378            #[doc(hidden)]
3379            type UnderlyingSolTuple<'a> = (
3380                alloy::sol_types::sol_data::Address,
3381                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
3382            );
3383            #[doc(hidden)]
3384            type UnderlyingRustTuple<'a> = (
3385                alloy::sol_types::private::Address,
3386                alloy::sol_types::private::Vec<u32>,
3387            );
3388            #[cfg(test)]
3389            #[allow(dead_code, unreachable_patterns)]
3390            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3391                match _t {
3392                    alloy_sol_types::private::AssertTypeEq::<
3393                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3394                    >(_) => {}
3395                }
3396            }
3397            #[automatically_derived]
3398            #[doc(hidden)]
3399            impl ::core::convert::From<deregisterOperatorFromOperatorSetsCall> for UnderlyingRustTuple<'_> {
3400                fn from(value: deregisterOperatorFromOperatorSetsCall) -> Self {
3401                    (value.operator, value.operatorSetIds)
3402                }
3403            }
3404            #[automatically_derived]
3405            #[doc(hidden)]
3406            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterOperatorFromOperatorSetsCall {
3407                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3408                    Self {
3409                        operator: tuple.0,
3410                        operatorSetIds: tuple.1,
3411                    }
3412                }
3413            }
3414        }
3415        {
3416            #[doc(hidden)]
3417            type UnderlyingSolTuple<'a> = ();
3418            #[doc(hidden)]
3419            type UnderlyingRustTuple<'a> = ();
3420            #[cfg(test)]
3421            #[allow(dead_code, unreachable_patterns)]
3422            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3423                match _t {
3424                    alloy_sol_types::private::AssertTypeEq::<
3425                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3426                    >(_) => {}
3427                }
3428            }
3429            #[automatically_derived]
3430            #[doc(hidden)]
3431            impl ::core::convert::From<deregisterOperatorFromOperatorSetsReturn> for UnderlyingRustTuple<'_> {
3432                fn from(value: deregisterOperatorFromOperatorSetsReturn) -> Self {
3433                    ()
3434                }
3435            }
3436            #[automatically_derived]
3437            #[doc(hidden)]
3438            impl ::core::convert::From<UnderlyingRustTuple<'_>> for deregisterOperatorFromOperatorSetsReturn {
3439                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3440                    Self {}
3441                }
3442            }
3443        }
3444        impl deregisterOperatorFromOperatorSetsReturn {
3445            fn _tokenize(
3446                &self,
3447            ) -> <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<'_>
3448            {
3449                ()
3450            }
3451        }
3452        #[automatically_derived]
3453        impl alloy_sol_types::SolCall for deregisterOperatorFromOperatorSetsCall {
3454            type Parameters<'a> = (
3455                alloy::sol_types::sol_data::Address,
3456                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
3457            );
3458            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3459            type Return = deregisterOperatorFromOperatorSetsReturn;
3460            type ReturnTuple<'a> = ();
3461            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3462            const SIGNATURE: &'static str = "deregisterOperatorFromOperatorSets(address,uint32[])";
3463            const SELECTOR: [u8; 4] = [193u8, 168u8, 226u8, 197u8];
3464            #[inline]
3465            fn new<'a>(
3466                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3467            ) -> Self {
3468                tuple.into()
3469            }
3470            #[inline]
3471            fn tokenize(&self) -> Self::Token<'_> {
3472                (
3473                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3474                        &self.operator,
3475                    ),
3476                    <alloy::sol_types::sol_data::Array<
3477                        alloy::sol_types::sol_data::Uint<32>,
3478                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
3479                )
3480            }
3481            #[inline]
3482            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3483                deregisterOperatorFromOperatorSetsReturn::_tokenize(ret)
3484            }
3485            #[inline]
3486            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3487                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
3488                    .map(Into::into)
3489            }
3490            #[inline]
3491            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3492                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3493                    data,
3494                )
3495                .map(Into::into)
3496            }
3497        }
3498    };
3499    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3500    /**Function with signature `getOperatorRestakedStrategies(address)` and selector `0x33cfb7b7`.
3501    ```solidity
3502    function getOperatorRestakedStrategies(address operator) external view returns (address[] memory);
3503    ```*/
3504    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3505    #[derive(Clone)]
3506    pub struct getOperatorRestakedStrategiesCall {
3507        #[allow(missing_docs)]
3508        pub operator: alloy::sol_types::private::Address,
3509    }
3510    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3511    ///Container type for the return parameters of the [`getOperatorRestakedStrategies(address)`](getOperatorRestakedStrategiesCall) function.
3512    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3513    #[derive(Clone)]
3514    pub struct getOperatorRestakedStrategiesReturn {
3515        #[allow(missing_docs)]
3516        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3517    }
3518    #[allow(
3519        non_camel_case_types,
3520        non_snake_case,
3521        clippy::pub_underscore_fields,
3522        clippy::style
3523    )]
3524    const _: () = {
3525        use alloy::sol_types as alloy_sol_types;
3526        {
3527            #[doc(hidden)]
3528            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3529            #[doc(hidden)]
3530            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3531            #[cfg(test)]
3532            #[allow(dead_code, unreachable_patterns)]
3533            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3534                match _t {
3535                    alloy_sol_types::private::AssertTypeEq::<
3536                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3537                    >(_) => {}
3538                }
3539            }
3540            #[automatically_derived]
3541            #[doc(hidden)]
3542            impl ::core::convert::From<getOperatorRestakedStrategiesCall> for UnderlyingRustTuple<'_> {
3543                fn from(value: getOperatorRestakedStrategiesCall) -> Self {
3544                    (value.operator,)
3545                }
3546            }
3547            #[automatically_derived]
3548            #[doc(hidden)]
3549            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorRestakedStrategiesCall {
3550                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3551                    Self { operator: tuple.0 }
3552                }
3553            }
3554        }
3555        {
3556            #[doc(hidden)]
3557            type UnderlyingSolTuple<'a> =
3558                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
3559            #[doc(hidden)]
3560            type UnderlyingRustTuple<'a> =
3561                (alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,);
3562            #[cfg(test)]
3563            #[allow(dead_code, unreachable_patterns)]
3564            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3565                match _t {
3566                    alloy_sol_types::private::AssertTypeEq::<
3567                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3568                    >(_) => {}
3569                }
3570            }
3571            #[automatically_derived]
3572            #[doc(hidden)]
3573            impl ::core::convert::From<getOperatorRestakedStrategiesReturn> for UnderlyingRustTuple<'_> {
3574                fn from(value: getOperatorRestakedStrategiesReturn) -> Self {
3575                    (value._0,)
3576                }
3577            }
3578            #[automatically_derived]
3579            #[doc(hidden)]
3580            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getOperatorRestakedStrategiesReturn {
3581                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3582                    Self { _0: tuple.0 }
3583                }
3584            }
3585        }
3586        #[automatically_derived]
3587        impl alloy_sol_types::SolCall for getOperatorRestakedStrategiesCall {
3588            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3589            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3590            type Return = alloy::sol_types::private::Vec<alloy::sol_types::private::Address>;
3591            type ReturnTuple<'a> =
3592                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
3593            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3594            const SIGNATURE: &'static str = "getOperatorRestakedStrategies(address)";
3595            const SELECTOR: [u8; 4] = [51u8, 207u8, 183u8, 183u8];
3596            #[inline]
3597            fn new<'a>(
3598                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3599            ) -> Self {
3600                tuple.into()
3601            }
3602            #[inline]
3603            fn tokenize(&self) -> Self::Token<'_> {
3604                (
3605                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3606                        &self.operator,
3607                    ),
3608                )
3609            }
3610            #[inline]
3611            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3612                (<alloy::sol_types::sol_data::Array<
3613                    alloy::sol_types::sol_data::Address,
3614                > as alloy_sol_types::SolType>::tokenize(ret),)
3615            }
3616            #[inline]
3617            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3618                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
3619                    |r| {
3620                        let r: getOperatorRestakedStrategiesReturn = r.into();
3621                        r._0
3622                    },
3623                )
3624            }
3625            #[inline]
3626            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3627                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3628                    data,
3629                )
3630                .map(|r| {
3631                    let r: getOperatorRestakedStrategiesReturn = r.into();
3632                    r._0
3633                })
3634            }
3635        }
3636    };
3637    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3638    /**Function with signature `getRestakeableStrategies()` and selector `0xe481af9d`.
3639    ```solidity
3640    function getRestakeableStrategies() external view returns (address[] memory);
3641    ```*/
3642    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3643    #[derive(Clone)]
3644    pub struct getRestakeableStrategiesCall;
3645    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3646    ///Container type for the return parameters of the [`getRestakeableStrategies()`](getRestakeableStrategiesCall) function.
3647    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3648    #[derive(Clone)]
3649    pub struct getRestakeableStrategiesReturn {
3650        #[allow(missing_docs)]
3651        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3652    }
3653    #[allow(
3654        non_camel_case_types,
3655        non_snake_case,
3656        clippy::pub_underscore_fields,
3657        clippy::style
3658    )]
3659    const _: () = {
3660        use alloy::sol_types as alloy_sol_types;
3661        {
3662            #[doc(hidden)]
3663            type UnderlyingSolTuple<'a> = ();
3664            #[doc(hidden)]
3665            type UnderlyingRustTuple<'a> = ();
3666            #[cfg(test)]
3667            #[allow(dead_code, unreachable_patterns)]
3668            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3669                match _t {
3670                    alloy_sol_types::private::AssertTypeEq::<
3671                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3672                    >(_) => {}
3673                }
3674            }
3675            #[automatically_derived]
3676            #[doc(hidden)]
3677            impl ::core::convert::From<getRestakeableStrategiesCall> for UnderlyingRustTuple<'_> {
3678                fn from(value: getRestakeableStrategiesCall) -> Self {
3679                    ()
3680                }
3681            }
3682            #[automatically_derived]
3683            #[doc(hidden)]
3684            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRestakeableStrategiesCall {
3685                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3686                    Self
3687                }
3688            }
3689        }
3690        {
3691            #[doc(hidden)]
3692            type UnderlyingSolTuple<'a> =
3693                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
3694            #[doc(hidden)]
3695            type UnderlyingRustTuple<'a> =
3696                (alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,);
3697            #[cfg(test)]
3698            #[allow(dead_code, unreachable_patterns)]
3699            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3700                match _t {
3701                    alloy_sol_types::private::AssertTypeEq::<
3702                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3703                    >(_) => {}
3704                }
3705            }
3706            #[automatically_derived]
3707            #[doc(hidden)]
3708            impl ::core::convert::From<getRestakeableStrategiesReturn> for UnderlyingRustTuple<'_> {
3709                fn from(value: getRestakeableStrategiesReturn) -> Self {
3710                    (value._0,)
3711                }
3712            }
3713            #[automatically_derived]
3714            #[doc(hidden)]
3715            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getRestakeableStrategiesReturn {
3716                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3717                    Self { _0: tuple.0 }
3718                }
3719            }
3720        }
3721        #[automatically_derived]
3722        impl alloy_sol_types::SolCall for getRestakeableStrategiesCall {
3723            type Parameters<'a> = ();
3724            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3725            type Return = alloy::sol_types::private::Vec<alloy::sol_types::private::Address>;
3726            type ReturnTuple<'a> =
3727                (alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,);
3728            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3729            const SIGNATURE: &'static str = "getRestakeableStrategies()";
3730            const SELECTOR: [u8; 4] = [228u8, 129u8, 175u8, 157u8];
3731            #[inline]
3732            fn new<'a>(
3733                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3734            ) -> Self {
3735                tuple.into()
3736            }
3737            #[inline]
3738            fn tokenize(&self) -> Self::Token<'_> {
3739                ()
3740            }
3741            #[inline]
3742            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3743                (<alloy::sol_types::sol_data::Array<
3744                    alloy::sol_types::sol_data::Address,
3745                > as alloy_sol_types::SolType>::tokenize(ret),)
3746            }
3747            #[inline]
3748            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3749                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
3750                    |r| {
3751                        let r: getRestakeableStrategiesReturn = r.into();
3752                        r._0
3753                    },
3754                )
3755            }
3756            #[inline]
3757            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3758                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3759                    data,
3760                )
3761                .map(|r| {
3762                    let r: getRestakeableStrategiesReturn = r.into();
3763                    r._0
3764                })
3765            }
3766        }
3767    };
3768    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3769    /**Function with signature `owner()` and selector `0x8da5cb5b`.
3770    ```solidity
3771    function owner() external view returns (address);
3772    ```*/
3773    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3774    #[derive(Clone)]
3775    pub struct ownerCall;
3776    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3777    ///Container type for the return parameters of the [`owner()`](ownerCall) function.
3778    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3779    #[derive(Clone)]
3780    pub struct ownerReturn {
3781        #[allow(missing_docs)]
3782        pub _0: alloy::sol_types::private::Address,
3783    }
3784    #[allow(
3785        non_camel_case_types,
3786        non_snake_case,
3787        clippy::pub_underscore_fields,
3788        clippy::style
3789    )]
3790    const _: () = {
3791        use alloy::sol_types as alloy_sol_types;
3792        {
3793            #[doc(hidden)]
3794            type UnderlyingSolTuple<'a> = ();
3795            #[doc(hidden)]
3796            type UnderlyingRustTuple<'a> = ();
3797            #[cfg(test)]
3798            #[allow(dead_code, unreachable_patterns)]
3799            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3800                match _t {
3801                    alloy_sol_types::private::AssertTypeEq::<
3802                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3803                    >(_) => {}
3804                }
3805            }
3806            #[automatically_derived]
3807            #[doc(hidden)]
3808            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3809                fn from(value: ownerCall) -> Self {
3810                    ()
3811                }
3812            }
3813            #[automatically_derived]
3814            #[doc(hidden)]
3815            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3816                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3817                    Self
3818                }
3819            }
3820        }
3821        {
3822            #[doc(hidden)]
3823            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3824            #[doc(hidden)]
3825            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3826            #[cfg(test)]
3827            #[allow(dead_code, unreachable_patterns)]
3828            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3829                match _t {
3830                    alloy_sol_types::private::AssertTypeEq::<
3831                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3832                    >(_) => {}
3833                }
3834            }
3835            #[automatically_derived]
3836            #[doc(hidden)]
3837            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3838                fn from(value: ownerReturn) -> Self {
3839                    (value._0,)
3840                }
3841            }
3842            #[automatically_derived]
3843            #[doc(hidden)]
3844            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3845                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3846                    Self { _0: tuple.0 }
3847                }
3848            }
3849        }
3850        #[automatically_derived]
3851        impl alloy_sol_types::SolCall for ownerCall {
3852            type Parameters<'a> = ();
3853            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
3854            type Return = alloy::sol_types::private::Address;
3855            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3856            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
3857            const SIGNATURE: &'static str = "owner()";
3858            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3859            #[inline]
3860            fn new<'a>(
3861                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3862            ) -> Self {
3863                tuple.into()
3864            }
3865            #[inline]
3866            fn tokenize(&self) -> Self::Token<'_> {
3867                ()
3868            }
3869            #[inline]
3870            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3871                (
3872                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3873                        ret,
3874                    ),
3875                )
3876            }
3877            #[inline]
3878            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3879                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
3880                    |r| {
3881                        let r: ownerReturn = r.into();
3882                        r._0
3883                    },
3884                )
3885            }
3886            #[inline]
3887            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3888                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
3889                    data,
3890                )
3891                .map(|r| {
3892                    let r: ownerReturn = r.into();
3893                    r._0
3894                })
3895            }
3896        }
3897    };
3898    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
3899    /**Function with signature `registerOperatorToAVS(address,(bytes,bytes32,uint256))` and selector `0x9926ee7d`.
3900    ```solidity
3901    function registerOperatorToAVS(address operator, ISignatureUtilsMixinTypes.SignatureWithSaltAndExpiry memory operatorSignature) external;
3902    ```*/
3903    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3904    #[derive(Clone)]
3905    pub struct registerOperatorToAVSCall {
3906        #[allow(missing_docs)]
3907        pub operator: alloy::sol_types::private::Address,
3908        #[allow(missing_docs)]
3909        pub operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
3910    }
3911    ///Container type for the return parameters of the [`registerOperatorToAVS(address,(bytes,bytes32,uint256))`](registerOperatorToAVSCall) function.
3912    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3913    #[derive(Clone)]
3914    pub struct registerOperatorToAVSReturn {}
3915    #[allow(
3916        non_camel_case_types,
3917        non_snake_case,
3918        clippy::pub_underscore_fields,
3919        clippy::style
3920    )]
3921    const _: () = {
3922        use alloy::sol_types as alloy_sol_types;
3923        {
3924            #[doc(hidden)]
3925            type UnderlyingSolTuple<'a> = (
3926                alloy::sol_types::sol_data::Address,
3927                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
3928            );
3929            #[doc(hidden)]
3930            type UnderlyingRustTuple<'a> = (
3931                alloy::sol_types::private::Address,
3932                <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
3933            );
3934            #[cfg(test)]
3935            #[allow(dead_code, unreachable_patterns)]
3936            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3937                match _t {
3938                    alloy_sol_types::private::AssertTypeEq::<
3939                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3940                    >(_) => {}
3941                }
3942            }
3943            #[automatically_derived]
3944            #[doc(hidden)]
3945            impl ::core::convert::From<registerOperatorToAVSCall> for UnderlyingRustTuple<'_> {
3946                fn from(value: registerOperatorToAVSCall) -> Self {
3947                    (value.operator, value.operatorSignature)
3948                }
3949            }
3950            #[automatically_derived]
3951            #[doc(hidden)]
3952            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerOperatorToAVSCall {
3953                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3954                    Self {
3955                        operator: tuple.0,
3956                        operatorSignature: tuple.1,
3957                    }
3958                }
3959            }
3960        }
3961        {
3962            #[doc(hidden)]
3963            type UnderlyingSolTuple<'a> = ();
3964            #[doc(hidden)]
3965            type UnderlyingRustTuple<'a> = ();
3966            #[cfg(test)]
3967            #[allow(dead_code, unreachable_patterns)]
3968            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
3969                match _t {
3970                    alloy_sol_types::private::AssertTypeEq::<
3971                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3972                    >(_) => {}
3973                }
3974            }
3975            #[automatically_derived]
3976            #[doc(hidden)]
3977            impl ::core::convert::From<registerOperatorToAVSReturn> for UnderlyingRustTuple<'_> {
3978                fn from(value: registerOperatorToAVSReturn) -> Self {
3979                    ()
3980                }
3981            }
3982            #[automatically_derived]
3983            #[doc(hidden)]
3984            impl ::core::convert::From<UnderlyingRustTuple<'_>> for registerOperatorToAVSReturn {
3985                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3986                    Self {}
3987                }
3988            }
3989        }
3990        impl registerOperatorToAVSReturn {
3991            fn _tokenize(
3992                &self,
3993            ) -> <registerOperatorToAVSCall as alloy_sol_types::SolCall>::ReturnToken<'_>
3994            {
3995                ()
3996            }
3997        }
3998        #[automatically_derived]
3999        impl alloy_sol_types::SolCall for registerOperatorToAVSCall {
4000            type Parameters<'a> = (
4001                alloy::sol_types::sol_data::Address,
4002                ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry,
4003            );
4004            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4005            type Return = registerOperatorToAVSReturn;
4006            type ReturnTuple<'a> = ();
4007            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4008            const SIGNATURE: &'static str =
4009                "registerOperatorToAVS(address,(bytes,bytes32,uint256))";
4010            const SELECTOR: [u8; 4] = [153u8, 38u8, 238u8, 125u8];
4011            #[inline]
4012            fn new<'a>(
4013                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4014            ) -> Self {
4015                tuple.into()
4016            }
4017            #[inline]
4018            fn tokenize(&self) -> Self::Token<'_> {
4019                (
4020                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4021                        &self.operator,
4022                    ),
4023                    <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy_sol_types::SolType>::tokenize(
4024                        &self.operatorSignature,
4025                    ),
4026                )
4027            }
4028            #[inline]
4029            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4030                registerOperatorToAVSReturn::_tokenize(ret)
4031            }
4032            #[inline]
4033            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4034                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
4035                    .map(Into::into)
4036            }
4037            #[inline]
4038            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4039                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4040                    data,
4041                )
4042                .map(Into::into)
4043            }
4044        }
4045    };
4046    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4047    /**Function with signature `removeAdmin(address)` and selector `0x1785f53c`.
4048    ```solidity
4049    function removeAdmin(address admin) external;
4050    ```*/
4051    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4052    #[derive(Clone)]
4053    pub struct removeAdminCall {
4054        #[allow(missing_docs)]
4055        pub admin: alloy::sol_types::private::Address,
4056    }
4057    ///Container type for the return parameters of the [`removeAdmin(address)`](removeAdminCall) function.
4058    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4059    #[derive(Clone)]
4060    pub struct removeAdminReturn {}
4061    #[allow(
4062        non_camel_case_types,
4063        non_snake_case,
4064        clippy::pub_underscore_fields,
4065        clippy::style
4066    )]
4067    const _: () = {
4068        use alloy::sol_types as alloy_sol_types;
4069        {
4070            #[doc(hidden)]
4071            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4072            #[doc(hidden)]
4073            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4074            #[cfg(test)]
4075            #[allow(dead_code, unreachable_patterns)]
4076            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4077                match _t {
4078                    alloy_sol_types::private::AssertTypeEq::<
4079                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4080                    >(_) => {}
4081                }
4082            }
4083            #[automatically_derived]
4084            #[doc(hidden)]
4085            impl ::core::convert::From<removeAdminCall> for UnderlyingRustTuple<'_> {
4086                fn from(value: removeAdminCall) -> Self {
4087                    (value.admin,)
4088                }
4089            }
4090            #[automatically_derived]
4091            #[doc(hidden)]
4092            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminCall {
4093                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4094                    Self { admin: tuple.0 }
4095                }
4096            }
4097        }
4098        {
4099            #[doc(hidden)]
4100            type UnderlyingSolTuple<'a> = ();
4101            #[doc(hidden)]
4102            type UnderlyingRustTuple<'a> = ();
4103            #[cfg(test)]
4104            #[allow(dead_code, unreachable_patterns)]
4105            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4106                match _t {
4107                    alloy_sol_types::private::AssertTypeEq::<
4108                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4109                    >(_) => {}
4110                }
4111            }
4112            #[automatically_derived]
4113            #[doc(hidden)]
4114            impl ::core::convert::From<removeAdminReturn> for UnderlyingRustTuple<'_> {
4115                fn from(value: removeAdminReturn) -> Self {
4116                    ()
4117                }
4118            }
4119            #[automatically_derived]
4120            #[doc(hidden)]
4121            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminReturn {
4122                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4123                    Self {}
4124                }
4125            }
4126        }
4127        impl removeAdminReturn {
4128            fn _tokenize(&self) -> <removeAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4129                ()
4130            }
4131        }
4132        #[automatically_derived]
4133        impl alloy_sol_types::SolCall for removeAdminCall {
4134            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4135            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4136            type Return = removeAdminReturn;
4137            type ReturnTuple<'a> = ();
4138            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4139            const SIGNATURE: &'static str = "removeAdmin(address)";
4140            const SELECTOR: [u8; 4] = [23u8, 133u8, 245u8, 60u8];
4141            #[inline]
4142            fn new<'a>(
4143                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4144            ) -> Self {
4145                tuple.into()
4146            }
4147            #[inline]
4148            fn tokenize(&self) -> Self::Token<'_> {
4149                (
4150                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4151                        &self.admin,
4152                    ),
4153                )
4154            }
4155            #[inline]
4156            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4157                removeAdminReturn::_tokenize(ret)
4158            }
4159            #[inline]
4160            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4161                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
4162                    .map(Into::into)
4163            }
4164            #[inline]
4165            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4166                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4167                    data,
4168                )
4169                .map(Into::into)
4170            }
4171        }
4172    };
4173    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4174    /**Function with signature `removeAppointee(address,address,bytes4)` and selector `0xba550880`.
4175    ```solidity
4176    function removeAppointee(address appointee, address target, bytes4 selector) external;
4177    ```*/
4178    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4179    #[derive(Clone)]
4180    pub struct removeAppointeeCall {
4181        #[allow(missing_docs)]
4182        pub appointee: alloy::sol_types::private::Address,
4183        #[allow(missing_docs)]
4184        pub target: alloy::sol_types::private::Address,
4185        #[allow(missing_docs)]
4186        pub selector: alloy::sol_types::private::FixedBytes<4>,
4187    }
4188    ///Container type for the return parameters of the [`removeAppointee(address,address,bytes4)`](removeAppointeeCall) function.
4189    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4190    #[derive(Clone)]
4191    pub struct removeAppointeeReturn {}
4192    #[allow(
4193        non_camel_case_types,
4194        non_snake_case,
4195        clippy::pub_underscore_fields,
4196        clippy::style
4197    )]
4198    const _: () = {
4199        use alloy::sol_types as alloy_sol_types;
4200        {
4201            #[doc(hidden)]
4202            type UnderlyingSolTuple<'a> = (
4203                alloy::sol_types::sol_data::Address,
4204                alloy::sol_types::sol_data::Address,
4205                alloy::sol_types::sol_data::FixedBytes<4>,
4206            );
4207            #[doc(hidden)]
4208            type UnderlyingRustTuple<'a> = (
4209                alloy::sol_types::private::Address,
4210                alloy::sol_types::private::Address,
4211                alloy::sol_types::private::FixedBytes<4>,
4212            );
4213            #[cfg(test)]
4214            #[allow(dead_code, unreachable_patterns)]
4215            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4216                match _t {
4217                    alloy_sol_types::private::AssertTypeEq::<
4218                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4219                    >(_) => {}
4220                }
4221            }
4222            #[automatically_derived]
4223            #[doc(hidden)]
4224            impl ::core::convert::From<removeAppointeeCall> for UnderlyingRustTuple<'_> {
4225                fn from(value: removeAppointeeCall) -> Self {
4226                    (value.appointee, value.target, value.selector)
4227                }
4228            }
4229            #[automatically_derived]
4230            #[doc(hidden)]
4231            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAppointeeCall {
4232                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4233                    Self {
4234                        appointee: tuple.0,
4235                        target: tuple.1,
4236                        selector: tuple.2,
4237                    }
4238                }
4239            }
4240        }
4241        {
4242            #[doc(hidden)]
4243            type UnderlyingSolTuple<'a> = ();
4244            #[doc(hidden)]
4245            type UnderlyingRustTuple<'a> = ();
4246            #[cfg(test)]
4247            #[allow(dead_code, unreachable_patterns)]
4248            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4249                match _t {
4250                    alloy_sol_types::private::AssertTypeEq::<
4251                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4252                    >(_) => {}
4253                }
4254            }
4255            #[automatically_derived]
4256            #[doc(hidden)]
4257            impl ::core::convert::From<removeAppointeeReturn> for UnderlyingRustTuple<'_> {
4258                fn from(value: removeAppointeeReturn) -> Self {
4259                    ()
4260                }
4261            }
4262            #[automatically_derived]
4263            #[doc(hidden)]
4264            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAppointeeReturn {
4265                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4266                    Self {}
4267                }
4268            }
4269        }
4270        impl removeAppointeeReturn {
4271            fn _tokenize(
4272                &self,
4273            ) -> <removeAppointeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4274                ()
4275            }
4276        }
4277        #[automatically_derived]
4278        impl alloy_sol_types::SolCall for removeAppointeeCall {
4279            type Parameters<'a> = (
4280                alloy::sol_types::sol_data::Address,
4281                alloy::sol_types::sol_data::Address,
4282                alloy::sol_types::sol_data::FixedBytes<4>,
4283            );
4284            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4285            type Return = removeAppointeeReturn;
4286            type ReturnTuple<'a> = ();
4287            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4288            const SIGNATURE: &'static str = "removeAppointee(address,address,bytes4)";
4289            const SELECTOR: [u8; 4] = [186u8, 85u8, 8u8, 128u8];
4290            #[inline]
4291            fn new<'a>(
4292                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4293            ) -> Self {
4294                tuple.into()
4295            }
4296            #[inline]
4297            fn tokenize(&self) -> Self::Token<'_> {
4298                (
4299                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4300                        &self.appointee,
4301                    ),
4302                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4303                        &self.target,
4304                    ),
4305                    <alloy::sol_types::sol_data::FixedBytes<
4306                        4,
4307                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
4308                )
4309            }
4310            #[inline]
4311            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4312                removeAppointeeReturn::_tokenize(ret)
4313            }
4314            #[inline]
4315            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4316                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
4317                    .map(Into::into)
4318            }
4319            #[inline]
4320            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4321                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4322                    data,
4323                )
4324                .map(Into::into)
4325            }
4326        }
4327    };
4328    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4329    /**Function with signature `removePendingAdmin(address)` and selector `0x9da16d8e`.
4330    ```solidity
4331    function removePendingAdmin(address pendingAdmin) external;
4332    ```*/
4333    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4334    #[derive(Clone)]
4335    pub struct removePendingAdminCall {
4336        #[allow(missing_docs)]
4337        pub pendingAdmin: alloy::sol_types::private::Address,
4338    }
4339    ///Container type for the return parameters of the [`removePendingAdmin(address)`](removePendingAdminCall) function.
4340    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4341    #[derive(Clone)]
4342    pub struct removePendingAdminReturn {}
4343    #[allow(
4344        non_camel_case_types,
4345        non_snake_case,
4346        clippy::pub_underscore_fields,
4347        clippy::style
4348    )]
4349    const _: () = {
4350        use alloy::sol_types as alloy_sol_types;
4351        {
4352            #[doc(hidden)]
4353            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4354            #[doc(hidden)]
4355            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4356            #[cfg(test)]
4357            #[allow(dead_code, unreachable_patterns)]
4358            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4359                match _t {
4360                    alloy_sol_types::private::AssertTypeEq::<
4361                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4362                    >(_) => {}
4363                }
4364            }
4365            #[automatically_derived]
4366            #[doc(hidden)]
4367            impl ::core::convert::From<removePendingAdminCall> for UnderlyingRustTuple<'_> {
4368                fn from(value: removePendingAdminCall) -> Self {
4369                    (value.pendingAdmin,)
4370                }
4371            }
4372            #[automatically_derived]
4373            #[doc(hidden)]
4374            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removePendingAdminCall {
4375                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4376                    Self {
4377                        pendingAdmin: tuple.0,
4378                    }
4379                }
4380            }
4381        }
4382        {
4383            #[doc(hidden)]
4384            type UnderlyingSolTuple<'a> = ();
4385            #[doc(hidden)]
4386            type UnderlyingRustTuple<'a> = ();
4387            #[cfg(test)]
4388            #[allow(dead_code, unreachable_patterns)]
4389            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4390                match _t {
4391                    alloy_sol_types::private::AssertTypeEq::<
4392                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4393                    >(_) => {}
4394                }
4395            }
4396            #[automatically_derived]
4397            #[doc(hidden)]
4398            impl ::core::convert::From<removePendingAdminReturn> for UnderlyingRustTuple<'_> {
4399                fn from(value: removePendingAdminReturn) -> Self {
4400                    ()
4401                }
4402            }
4403            #[automatically_derived]
4404            #[doc(hidden)]
4405            impl ::core::convert::From<UnderlyingRustTuple<'_>> for removePendingAdminReturn {
4406                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4407                    Self {}
4408                }
4409            }
4410        }
4411        impl removePendingAdminReturn {
4412            fn _tokenize(
4413                &self,
4414            ) -> <removePendingAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4415                ()
4416            }
4417        }
4418        #[automatically_derived]
4419        impl alloy_sol_types::SolCall for removePendingAdminCall {
4420            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4421            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4422            type Return = removePendingAdminReturn;
4423            type ReturnTuple<'a> = ();
4424            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4425            const SIGNATURE: &'static str = "removePendingAdmin(address)";
4426            const SELECTOR: [u8; 4] = [157u8, 161u8, 109u8, 142u8];
4427            #[inline]
4428            fn new<'a>(
4429                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4430            ) -> Self {
4431                tuple.into()
4432            }
4433            #[inline]
4434            fn tokenize(&self) -> Self::Token<'_> {
4435                (
4436                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4437                        &self.pendingAdmin,
4438                    ),
4439                )
4440            }
4441            #[inline]
4442            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4443                removePendingAdminReturn::_tokenize(ret)
4444            }
4445            #[inline]
4446            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4447                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
4448                    .map(Into::into)
4449            }
4450            #[inline]
4451            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4452                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4453                    data,
4454                )
4455                .map(Into::into)
4456            }
4457        }
4458    };
4459    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4460    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
4461    ```solidity
4462    function renounceOwnership() external;
4463    ```*/
4464    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4465    #[derive(Clone)]
4466    pub struct renounceOwnershipCall;
4467    ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function.
4468    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4469    #[derive(Clone)]
4470    pub struct renounceOwnershipReturn {}
4471    #[allow(
4472        non_camel_case_types,
4473        non_snake_case,
4474        clippy::pub_underscore_fields,
4475        clippy::style
4476    )]
4477    const _: () = {
4478        use alloy::sol_types as alloy_sol_types;
4479        {
4480            #[doc(hidden)]
4481            type UnderlyingSolTuple<'a> = ();
4482            #[doc(hidden)]
4483            type UnderlyingRustTuple<'a> = ();
4484            #[cfg(test)]
4485            #[allow(dead_code, unreachable_patterns)]
4486            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4487                match _t {
4488                    alloy_sol_types::private::AssertTypeEq::<
4489                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4490                    >(_) => {}
4491                }
4492            }
4493            #[automatically_derived]
4494            #[doc(hidden)]
4495            impl ::core::convert::From<renounceOwnershipCall> for UnderlyingRustTuple<'_> {
4496                fn from(value: renounceOwnershipCall) -> Self {
4497                    ()
4498                }
4499            }
4500            #[automatically_derived]
4501            #[doc(hidden)]
4502            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipCall {
4503                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4504                    Self
4505                }
4506            }
4507        }
4508        {
4509            #[doc(hidden)]
4510            type UnderlyingSolTuple<'a> = ();
4511            #[doc(hidden)]
4512            type UnderlyingRustTuple<'a> = ();
4513            #[cfg(test)]
4514            #[allow(dead_code, unreachable_patterns)]
4515            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4516                match _t {
4517                    alloy_sol_types::private::AssertTypeEq::<
4518                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4519                    >(_) => {}
4520                }
4521            }
4522            #[automatically_derived]
4523            #[doc(hidden)]
4524            impl ::core::convert::From<renounceOwnershipReturn> for UnderlyingRustTuple<'_> {
4525                fn from(value: renounceOwnershipReturn) -> Self {
4526                    ()
4527                }
4528            }
4529            #[automatically_derived]
4530            #[doc(hidden)]
4531            impl ::core::convert::From<UnderlyingRustTuple<'_>> for renounceOwnershipReturn {
4532                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4533                    Self {}
4534                }
4535            }
4536        }
4537        impl renounceOwnershipReturn {
4538            fn _tokenize(
4539                &self,
4540            ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4541                ()
4542            }
4543        }
4544        #[automatically_derived]
4545        impl alloy_sol_types::SolCall for renounceOwnershipCall {
4546            type Parameters<'a> = ();
4547            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4548            type Return = renounceOwnershipReturn;
4549            type ReturnTuple<'a> = ();
4550            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4551            const SIGNATURE: &'static str = "renounceOwnership()";
4552            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
4553            #[inline]
4554            fn new<'a>(
4555                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4556            ) -> Self {
4557                tuple.into()
4558            }
4559            #[inline]
4560            fn tokenize(&self) -> Self::Token<'_> {
4561                ()
4562            }
4563            #[inline]
4564            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4565                renounceOwnershipReturn::_tokenize(ret)
4566            }
4567            #[inline]
4568            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4569                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
4570                    .map(Into::into)
4571            }
4572            #[inline]
4573            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4574                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4575                    data,
4576                )
4577                .map(Into::into)
4578            }
4579        }
4580    };
4581    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4582    /**Function with signature `rewardsInitiator()` and selector `0xfc299dee`.
4583    ```solidity
4584    function rewardsInitiator() external view returns (address);
4585    ```*/
4586    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4587    #[derive(Clone)]
4588    pub struct rewardsInitiatorCall;
4589    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4590    ///Container type for the return parameters of the [`rewardsInitiator()`](rewardsInitiatorCall) function.
4591    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4592    #[derive(Clone)]
4593    pub struct rewardsInitiatorReturn {
4594        #[allow(missing_docs)]
4595        pub _0: alloy::sol_types::private::Address,
4596    }
4597    #[allow(
4598        non_camel_case_types,
4599        non_snake_case,
4600        clippy::pub_underscore_fields,
4601        clippy::style
4602    )]
4603    const _: () = {
4604        use alloy::sol_types as alloy_sol_types;
4605        {
4606            #[doc(hidden)]
4607            type UnderlyingSolTuple<'a> = ();
4608            #[doc(hidden)]
4609            type UnderlyingRustTuple<'a> = ();
4610            #[cfg(test)]
4611            #[allow(dead_code, unreachable_patterns)]
4612            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4613                match _t {
4614                    alloy_sol_types::private::AssertTypeEq::<
4615                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4616                    >(_) => {}
4617                }
4618            }
4619            #[automatically_derived]
4620            #[doc(hidden)]
4621            impl ::core::convert::From<rewardsInitiatorCall> for UnderlyingRustTuple<'_> {
4622                fn from(value: rewardsInitiatorCall) -> Self {
4623                    ()
4624                }
4625            }
4626            #[automatically_derived]
4627            #[doc(hidden)]
4628            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rewardsInitiatorCall {
4629                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4630                    Self
4631                }
4632            }
4633        }
4634        {
4635            #[doc(hidden)]
4636            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4637            #[doc(hidden)]
4638            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4639            #[cfg(test)]
4640            #[allow(dead_code, unreachable_patterns)]
4641            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4642                match _t {
4643                    alloy_sol_types::private::AssertTypeEq::<
4644                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4645                    >(_) => {}
4646                }
4647            }
4648            #[automatically_derived]
4649            #[doc(hidden)]
4650            impl ::core::convert::From<rewardsInitiatorReturn> for UnderlyingRustTuple<'_> {
4651                fn from(value: rewardsInitiatorReturn) -> Self {
4652                    (value._0,)
4653                }
4654            }
4655            #[automatically_derived]
4656            #[doc(hidden)]
4657            impl ::core::convert::From<UnderlyingRustTuple<'_>> for rewardsInitiatorReturn {
4658                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4659                    Self { _0: tuple.0 }
4660                }
4661            }
4662        }
4663        #[automatically_derived]
4664        impl alloy_sol_types::SolCall for rewardsInitiatorCall {
4665            type Parameters<'a> = ();
4666            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4667            type Return = alloy::sol_types::private::Address;
4668            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
4669            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4670            const SIGNATURE: &'static str = "rewardsInitiator()";
4671            const SELECTOR: [u8; 4] = [252u8, 41u8, 157u8, 238u8];
4672            #[inline]
4673            fn new<'a>(
4674                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4675            ) -> Self {
4676                tuple.into()
4677            }
4678            #[inline]
4679            fn tokenize(&self) -> Self::Token<'_> {
4680                ()
4681            }
4682            #[inline]
4683            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4684                (
4685                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4686                        ret,
4687                    ),
4688                )
4689            }
4690            #[inline]
4691            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4692                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data).map(
4693                    |r| {
4694                        let r: rewardsInitiatorReturn = r.into();
4695                        r._0
4696                    },
4697                )
4698            }
4699            #[inline]
4700            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4701                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4702                    data,
4703                )
4704                .map(|r| {
4705                    let r: rewardsInitiatorReturn = r.into();
4706                    r._0
4707                })
4708            }
4709        }
4710    };
4711    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4712    /**Function with signature `setAppointee(address,address,bytes4)` and selector `0x1fdb0cfd`.
4713    ```solidity
4714    function setAppointee(address appointee, address target, bytes4 selector) external;
4715    ```*/
4716    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4717    #[derive(Clone)]
4718    pub struct setAppointeeCall {
4719        #[allow(missing_docs)]
4720        pub appointee: alloy::sol_types::private::Address,
4721        #[allow(missing_docs)]
4722        pub target: alloy::sol_types::private::Address,
4723        #[allow(missing_docs)]
4724        pub selector: alloy::sol_types::private::FixedBytes<4>,
4725    }
4726    ///Container type for the return parameters of the [`setAppointee(address,address,bytes4)`](setAppointeeCall) function.
4727    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4728    #[derive(Clone)]
4729    pub struct setAppointeeReturn {}
4730    #[allow(
4731        non_camel_case_types,
4732        non_snake_case,
4733        clippy::pub_underscore_fields,
4734        clippy::style
4735    )]
4736    const _: () = {
4737        use alloy::sol_types as alloy_sol_types;
4738        {
4739            #[doc(hidden)]
4740            type UnderlyingSolTuple<'a> = (
4741                alloy::sol_types::sol_data::Address,
4742                alloy::sol_types::sol_data::Address,
4743                alloy::sol_types::sol_data::FixedBytes<4>,
4744            );
4745            #[doc(hidden)]
4746            type UnderlyingRustTuple<'a> = (
4747                alloy::sol_types::private::Address,
4748                alloy::sol_types::private::Address,
4749                alloy::sol_types::private::FixedBytes<4>,
4750            );
4751            #[cfg(test)]
4752            #[allow(dead_code, unreachable_patterns)]
4753            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4754                match _t {
4755                    alloy_sol_types::private::AssertTypeEq::<
4756                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4757                    >(_) => {}
4758                }
4759            }
4760            #[automatically_derived]
4761            #[doc(hidden)]
4762            impl ::core::convert::From<setAppointeeCall> for UnderlyingRustTuple<'_> {
4763                fn from(value: setAppointeeCall) -> Self {
4764                    (value.appointee, value.target, value.selector)
4765                }
4766            }
4767            #[automatically_derived]
4768            #[doc(hidden)]
4769            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeCall {
4770                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4771                    Self {
4772                        appointee: tuple.0,
4773                        target: tuple.1,
4774                        selector: tuple.2,
4775                    }
4776                }
4777            }
4778        }
4779        {
4780            #[doc(hidden)]
4781            type UnderlyingSolTuple<'a> = ();
4782            #[doc(hidden)]
4783            type UnderlyingRustTuple<'a> = ();
4784            #[cfg(test)]
4785            #[allow(dead_code, unreachable_patterns)]
4786            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4787                match _t {
4788                    alloy_sol_types::private::AssertTypeEq::<
4789                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4790                    >(_) => {}
4791                }
4792            }
4793            #[automatically_derived]
4794            #[doc(hidden)]
4795            impl ::core::convert::From<setAppointeeReturn> for UnderlyingRustTuple<'_> {
4796                fn from(value: setAppointeeReturn) -> Self {
4797                    ()
4798                }
4799            }
4800            #[automatically_derived]
4801            #[doc(hidden)]
4802            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeReturn {
4803                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4804                    Self {}
4805                }
4806            }
4807        }
4808        impl setAppointeeReturn {
4809            fn _tokenize(&self) -> <setAppointeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4810                ()
4811            }
4812        }
4813        #[automatically_derived]
4814        impl alloy_sol_types::SolCall for setAppointeeCall {
4815            type Parameters<'a> = (
4816                alloy::sol_types::sol_data::Address,
4817                alloy::sol_types::sol_data::Address,
4818                alloy::sol_types::sol_data::FixedBytes<4>,
4819            );
4820            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4821            type Return = setAppointeeReturn;
4822            type ReturnTuple<'a> = ();
4823            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4824            const SIGNATURE: &'static str = "setAppointee(address,address,bytes4)";
4825            const SELECTOR: [u8; 4] = [31u8, 219u8, 12u8, 253u8];
4826            #[inline]
4827            fn new<'a>(
4828                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4829            ) -> Self {
4830                tuple.into()
4831            }
4832            #[inline]
4833            fn tokenize(&self) -> Self::Token<'_> {
4834                (
4835                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4836                        &self.appointee,
4837                    ),
4838                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4839                        &self.target,
4840                    ),
4841                    <alloy::sol_types::sol_data::FixedBytes<
4842                        4,
4843                    > as alloy_sol_types::SolType>::tokenize(&self.selector),
4844                )
4845            }
4846            #[inline]
4847            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4848                setAppointeeReturn::_tokenize(ret)
4849            }
4850            #[inline]
4851            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4852                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
4853                    .map(Into::into)
4854            }
4855            #[inline]
4856            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4857                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4858                    data,
4859                )
4860                .map(Into::into)
4861            }
4862        }
4863    };
4864    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4865    /**Function with signature `setClaimerFor(address)` and selector `0xa0169ddd`.
4866    ```solidity
4867    function setClaimerFor(address claimer) external;
4868    ```*/
4869    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4870    #[derive(Clone)]
4871    pub struct setClaimerForCall {
4872        #[allow(missing_docs)]
4873        pub claimer: alloy::sol_types::private::Address,
4874    }
4875    ///Container type for the return parameters of the [`setClaimerFor(address)`](setClaimerForCall) function.
4876    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4877    #[derive(Clone)]
4878    pub struct setClaimerForReturn {}
4879    #[allow(
4880        non_camel_case_types,
4881        non_snake_case,
4882        clippy::pub_underscore_fields,
4883        clippy::style
4884    )]
4885    const _: () = {
4886        use alloy::sol_types as alloy_sol_types;
4887        {
4888            #[doc(hidden)]
4889            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4890            #[doc(hidden)]
4891            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4892            #[cfg(test)]
4893            #[allow(dead_code, unreachable_patterns)]
4894            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4895                match _t {
4896                    alloy_sol_types::private::AssertTypeEq::<
4897                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4898                    >(_) => {}
4899                }
4900            }
4901            #[automatically_derived]
4902            #[doc(hidden)]
4903            impl ::core::convert::From<setClaimerForCall> for UnderlyingRustTuple<'_> {
4904                fn from(value: setClaimerForCall) -> Self {
4905                    (value.claimer,)
4906                }
4907            }
4908            #[automatically_derived]
4909            #[doc(hidden)]
4910            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setClaimerForCall {
4911                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4912                    Self { claimer: tuple.0 }
4913                }
4914            }
4915        }
4916        {
4917            #[doc(hidden)]
4918            type UnderlyingSolTuple<'a> = ();
4919            #[doc(hidden)]
4920            type UnderlyingRustTuple<'a> = ();
4921            #[cfg(test)]
4922            #[allow(dead_code, unreachable_patterns)]
4923            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
4924                match _t {
4925                    alloy_sol_types::private::AssertTypeEq::<
4926                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4927                    >(_) => {}
4928                }
4929            }
4930            #[automatically_derived]
4931            #[doc(hidden)]
4932            impl ::core::convert::From<setClaimerForReturn> for UnderlyingRustTuple<'_> {
4933                fn from(value: setClaimerForReturn) -> Self {
4934                    ()
4935                }
4936            }
4937            #[automatically_derived]
4938            #[doc(hidden)]
4939            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setClaimerForReturn {
4940                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4941                    Self {}
4942                }
4943            }
4944        }
4945        impl setClaimerForReturn {
4946            fn _tokenize(
4947                &self,
4948            ) -> <setClaimerForCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4949                ()
4950            }
4951        }
4952        #[automatically_derived]
4953        impl alloy_sol_types::SolCall for setClaimerForCall {
4954            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4955            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
4956            type Return = setClaimerForReturn;
4957            type ReturnTuple<'a> = ();
4958            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
4959            const SIGNATURE: &'static str = "setClaimerFor(address)";
4960            const SELECTOR: [u8; 4] = [160u8, 22u8, 157u8, 221u8];
4961            #[inline]
4962            fn new<'a>(
4963                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4964            ) -> Self {
4965                tuple.into()
4966            }
4967            #[inline]
4968            fn tokenize(&self) -> Self::Token<'_> {
4969                (
4970                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4971                        &self.claimer,
4972                    ),
4973                )
4974            }
4975            #[inline]
4976            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4977                setClaimerForReturn::_tokenize(ret)
4978            }
4979            #[inline]
4980            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4981                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
4982                    .map(Into::into)
4983            }
4984            #[inline]
4985            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4986                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
4987                    data,
4988                )
4989                .map(Into::into)
4990            }
4991        }
4992    };
4993    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
4994    /**Function with signature `setRewardsInitiator(address)` and selector `0x3bc28c8c`.
4995    ```solidity
4996    function setRewardsInitiator(address newRewardsInitiator) external;
4997    ```*/
4998    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4999    #[derive(Clone)]
5000    pub struct setRewardsInitiatorCall {
5001        #[allow(missing_docs)]
5002        pub newRewardsInitiator: alloy::sol_types::private::Address,
5003    }
5004    ///Container type for the return parameters of the [`setRewardsInitiator(address)`](setRewardsInitiatorCall) function.
5005    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5006    #[derive(Clone)]
5007    pub struct setRewardsInitiatorReturn {}
5008    #[allow(
5009        non_camel_case_types,
5010        non_snake_case,
5011        clippy::pub_underscore_fields,
5012        clippy::style
5013    )]
5014    const _: () = {
5015        use alloy::sol_types as alloy_sol_types;
5016        {
5017            #[doc(hidden)]
5018            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5019            #[doc(hidden)]
5020            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5021            #[cfg(test)]
5022            #[allow(dead_code, unreachable_patterns)]
5023            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5024                match _t {
5025                    alloy_sol_types::private::AssertTypeEq::<
5026                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5027                    >(_) => {}
5028                }
5029            }
5030            #[automatically_derived]
5031            #[doc(hidden)]
5032            impl ::core::convert::From<setRewardsInitiatorCall> for UnderlyingRustTuple<'_> {
5033                fn from(value: setRewardsInitiatorCall) -> Self {
5034                    (value.newRewardsInitiator,)
5035                }
5036            }
5037            #[automatically_derived]
5038            #[doc(hidden)]
5039            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setRewardsInitiatorCall {
5040                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5041                    Self {
5042                        newRewardsInitiator: tuple.0,
5043                    }
5044                }
5045            }
5046        }
5047        {
5048            #[doc(hidden)]
5049            type UnderlyingSolTuple<'a> = ();
5050            #[doc(hidden)]
5051            type UnderlyingRustTuple<'a> = ();
5052            #[cfg(test)]
5053            #[allow(dead_code, unreachable_patterns)]
5054            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5055                match _t {
5056                    alloy_sol_types::private::AssertTypeEq::<
5057                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5058                    >(_) => {}
5059                }
5060            }
5061            #[automatically_derived]
5062            #[doc(hidden)]
5063            impl ::core::convert::From<setRewardsInitiatorReturn> for UnderlyingRustTuple<'_> {
5064                fn from(value: setRewardsInitiatorReturn) -> Self {
5065                    ()
5066                }
5067            }
5068            #[automatically_derived]
5069            #[doc(hidden)]
5070            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setRewardsInitiatorReturn {
5071                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5072                    Self {}
5073                }
5074            }
5075        }
5076        impl setRewardsInitiatorReturn {
5077            fn _tokenize(
5078                &self,
5079            ) -> <setRewardsInitiatorCall as alloy_sol_types::SolCall>::ReturnToken<'_>
5080            {
5081                ()
5082            }
5083        }
5084        #[automatically_derived]
5085        impl alloy_sol_types::SolCall for setRewardsInitiatorCall {
5086            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
5087            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5088            type Return = setRewardsInitiatorReturn;
5089            type ReturnTuple<'a> = ();
5090            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5091            const SIGNATURE: &'static str = "setRewardsInitiator(address)";
5092            const SELECTOR: [u8; 4] = [59u8, 194u8, 140u8, 140u8];
5093            #[inline]
5094            fn new<'a>(
5095                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5096            ) -> Self {
5097                tuple.into()
5098            }
5099            #[inline]
5100            fn tokenize(&self) -> Self::Token<'_> {
5101                (
5102                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5103                        &self.newRewardsInitiator,
5104                    ),
5105                )
5106            }
5107            #[inline]
5108            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5109                setRewardsInitiatorReturn::_tokenize(ret)
5110            }
5111            #[inline]
5112            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5113                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
5114                    .map(Into::into)
5115            }
5116            #[inline]
5117            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5118                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5119                    data,
5120                )
5121                .map(Into::into)
5122            }
5123        }
5124    };
5125    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5126    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
5127    ```solidity
5128    function transferOwnership(address newOwner) external;
5129    ```*/
5130    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5131    #[derive(Clone)]
5132    pub struct transferOwnershipCall {
5133        #[allow(missing_docs)]
5134        pub newOwner: alloy::sol_types::private::Address,
5135    }
5136    ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function.
5137    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5138    #[derive(Clone)]
5139    pub struct transferOwnershipReturn {}
5140    #[allow(
5141        non_camel_case_types,
5142        non_snake_case,
5143        clippy::pub_underscore_fields,
5144        clippy::style
5145    )]
5146    const _: () = {
5147        use alloy::sol_types as alloy_sol_types;
5148        {
5149            #[doc(hidden)]
5150            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
5151            #[doc(hidden)]
5152            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
5153            #[cfg(test)]
5154            #[allow(dead_code, unreachable_patterns)]
5155            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5156                match _t {
5157                    alloy_sol_types::private::AssertTypeEq::<
5158                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5159                    >(_) => {}
5160                }
5161            }
5162            #[automatically_derived]
5163            #[doc(hidden)]
5164            impl ::core::convert::From<transferOwnershipCall> for UnderlyingRustTuple<'_> {
5165                fn from(value: transferOwnershipCall) -> Self {
5166                    (value.newOwner,)
5167                }
5168            }
5169            #[automatically_derived]
5170            #[doc(hidden)]
5171            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipCall {
5172                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5173                    Self { newOwner: tuple.0 }
5174                }
5175            }
5176        }
5177        {
5178            #[doc(hidden)]
5179            type UnderlyingSolTuple<'a> = ();
5180            #[doc(hidden)]
5181            type UnderlyingRustTuple<'a> = ();
5182            #[cfg(test)]
5183            #[allow(dead_code, unreachable_patterns)]
5184            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5185                match _t {
5186                    alloy_sol_types::private::AssertTypeEq::<
5187                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5188                    >(_) => {}
5189                }
5190            }
5191            #[automatically_derived]
5192            #[doc(hidden)]
5193            impl ::core::convert::From<transferOwnershipReturn> for UnderlyingRustTuple<'_> {
5194                fn from(value: transferOwnershipReturn) -> Self {
5195                    ()
5196                }
5197            }
5198            #[automatically_derived]
5199            #[doc(hidden)]
5200            impl ::core::convert::From<UnderlyingRustTuple<'_>> for transferOwnershipReturn {
5201                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5202                    Self {}
5203                }
5204            }
5205        }
5206        impl transferOwnershipReturn {
5207            fn _tokenize(
5208                &self,
5209            ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
5210                ()
5211            }
5212        }
5213        #[automatically_derived]
5214        impl alloy_sol_types::SolCall for transferOwnershipCall {
5215            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
5216            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5217            type Return = transferOwnershipReturn;
5218            type ReturnTuple<'a> = ();
5219            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5220            const SIGNATURE: &'static str = "transferOwnership(address)";
5221            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
5222            #[inline]
5223            fn new<'a>(
5224                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5225            ) -> Self {
5226                tuple.into()
5227            }
5228            #[inline]
5229            fn tokenize(&self) -> Self::Token<'_> {
5230                (
5231                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5232                        &self.newOwner,
5233                    ),
5234                )
5235            }
5236            #[inline]
5237            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5238                transferOwnershipReturn::_tokenize(ret)
5239            }
5240            #[inline]
5241            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5242                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
5243                    .map(Into::into)
5244            }
5245            #[inline]
5246            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5247                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5248                    data,
5249                )
5250                .map(Into::into)
5251            }
5252        }
5253    };
5254    #[derive(serde::Serialize, serde::Deserialize, Default, Debug, PartialEq, Eq, Hash)]
5255    /**Function with signature `updateAVSMetadataURI(string)` and selector `0xa98fb355`.
5256    ```solidity
5257    function updateAVSMetadataURI(string memory _metadataURI) external;
5258    ```*/
5259    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5260    #[derive(Clone)]
5261    pub struct updateAVSMetadataURICall {
5262        #[allow(missing_docs)]
5263        pub _metadataURI: alloy::sol_types::private::String,
5264    }
5265    ///Container type for the return parameters of the [`updateAVSMetadataURI(string)`](updateAVSMetadataURICall) function.
5266    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
5267    #[derive(Clone)]
5268    pub struct updateAVSMetadataURIReturn {}
5269    #[allow(
5270        non_camel_case_types,
5271        non_snake_case,
5272        clippy::pub_underscore_fields,
5273        clippy::style
5274    )]
5275    const _: () = {
5276        use alloy::sol_types as alloy_sol_types;
5277        {
5278            #[doc(hidden)]
5279            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
5280            #[doc(hidden)]
5281            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
5282            #[cfg(test)]
5283            #[allow(dead_code, unreachable_patterns)]
5284            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5285                match _t {
5286                    alloy_sol_types::private::AssertTypeEq::<
5287                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5288                    >(_) => {}
5289                }
5290            }
5291            #[automatically_derived]
5292            #[doc(hidden)]
5293            impl ::core::convert::From<updateAVSMetadataURICall> for UnderlyingRustTuple<'_> {
5294                fn from(value: updateAVSMetadataURICall) -> Self {
5295                    (value._metadataURI,)
5296                }
5297            }
5298            #[automatically_derived]
5299            #[doc(hidden)]
5300            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateAVSMetadataURICall {
5301                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5302                    Self {
5303                        _metadataURI: tuple.0,
5304                    }
5305                }
5306            }
5307        }
5308        {
5309            #[doc(hidden)]
5310            type UnderlyingSolTuple<'a> = ();
5311            #[doc(hidden)]
5312            type UnderlyingRustTuple<'a> = ();
5313            #[cfg(test)]
5314            #[allow(dead_code, unreachable_patterns)]
5315            fn _type_assertion(_t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>) {
5316                match _t {
5317                    alloy_sol_types::private::AssertTypeEq::<
5318                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
5319                    >(_) => {}
5320                }
5321            }
5322            #[automatically_derived]
5323            #[doc(hidden)]
5324            impl ::core::convert::From<updateAVSMetadataURIReturn> for UnderlyingRustTuple<'_> {
5325                fn from(value: updateAVSMetadataURIReturn) -> Self {
5326                    ()
5327                }
5328            }
5329            #[automatically_derived]
5330            #[doc(hidden)]
5331            impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateAVSMetadataURIReturn {
5332                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
5333                    Self {}
5334                }
5335            }
5336        }
5337        impl updateAVSMetadataURIReturn {
5338            fn _tokenize(
5339                &self,
5340            ) -> <updateAVSMetadataURICall as alloy_sol_types::SolCall>::ReturnToken<'_>
5341            {
5342                ()
5343            }
5344        }
5345        #[automatically_derived]
5346        impl alloy_sol_types::SolCall for updateAVSMetadataURICall {
5347            type Parameters<'a> = (alloy::sol_types::sol_data::String,);
5348            type Token<'a> = <Self::Parameters<'a> as alloy_sol_types::SolType>::Token<'a>;
5349            type Return = updateAVSMetadataURIReturn;
5350            type ReturnTuple<'a> = ();
5351            type ReturnToken<'a> = <Self::ReturnTuple<'a> as alloy_sol_types::SolType>::Token<'a>;
5352            const SIGNATURE: &'static str = "updateAVSMetadataURI(string)";
5353            const SELECTOR: [u8; 4] = [169u8, 143u8, 179u8, 85u8];
5354            #[inline]
5355            fn new<'a>(
5356                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
5357            ) -> Self {
5358                tuple.into()
5359            }
5360            #[inline]
5361            fn tokenize(&self) -> Self::Token<'_> {
5362                (
5363                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
5364                        &self._metadataURI,
5365                    ),
5366                )
5367            }
5368            #[inline]
5369            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
5370                updateAVSMetadataURIReturn::_tokenize(ret)
5371            }
5372            #[inline]
5373            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5374                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence(data)
5375                    .map(Into::into)
5376            }
5377            #[inline]
5378            fn abi_decode_returns_validate(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
5379                <Self::ReturnTuple<'_> as alloy_sol_types::SolType>::abi_decode_sequence_validate(
5380                    data,
5381                )
5382                .map(Into::into)
5383            }
5384        }
5385    };
5386    ///Container for all the [`ServiceManagerBase`](self) function calls.
5387    #[derive(serde::Serialize, serde::Deserialize)]
5388    pub enum ServiceManagerBaseCalls {
5389        #[allow(missing_docs)]
5390        addPendingAdmin(addPendingAdminCall),
5391        #[allow(missing_docs)]
5392        avsDirectory(avsDirectoryCall),
5393        #[allow(missing_docs)]
5394        createAVSRewardsSubmission(createAVSRewardsSubmissionCall),
5395        #[allow(missing_docs)]
5396        createOperatorDirectedAVSRewardsSubmission(createOperatorDirectedAVSRewardsSubmissionCall),
5397        #[allow(missing_docs)]
5398        deregisterOperatorFromAVS(deregisterOperatorFromAVSCall),
5399        #[allow(missing_docs)]
5400        deregisterOperatorFromOperatorSets(deregisterOperatorFromOperatorSetsCall),
5401        #[allow(missing_docs)]
5402        getOperatorRestakedStrategies(getOperatorRestakedStrategiesCall),
5403        #[allow(missing_docs)]
5404        getRestakeableStrategies(getRestakeableStrategiesCall),
5405        #[allow(missing_docs)]
5406        owner(ownerCall),
5407        #[allow(missing_docs)]
5408        registerOperatorToAVS(registerOperatorToAVSCall),
5409        #[allow(missing_docs)]
5410        removeAdmin(removeAdminCall),
5411        #[allow(missing_docs)]
5412        removeAppointee(removeAppointeeCall),
5413        #[allow(missing_docs)]
5414        removePendingAdmin(removePendingAdminCall),
5415        #[allow(missing_docs)]
5416        renounceOwnership(renounceOwnershipCall),
5417        #[allow(missing_docs)]
5418        rewardsInitiator(rewardsInitiatorCall),
5419        #[allow(missing_docs)]
5420        setAppointee(setAppointeeCall),
5421        #[allow(missing_docs)]
5422        setClaimerFor(setClaimerForCall),
5423        #[allow(missing_docs)]
5424        setRewardsInitiator(setRewardsInitiatorCall),
5425        #[allow(missing_docs)]
5426        transferOwnership(transferOwnershipCall),
5427        #[allow(missing_docs)]
5428        updateAVSMetadataURI(updateAVSMetadataURICall),
5429    }
5430    #[automatically_derived]
5431    impl ServiceManagerBaseCalls {
5432        /// All the selectors of this enum.
5433        ///
5434        /// Note that the selectors might not be in the same order as the variants.
5435        /// No guarantees are made about the order of the selectors.
5436        ///
5437        /// Prefer using `SolInterface` methods instead.
5438        pub const SELECTORS: &'static [[u8; 4usize]] = &[
5439            [23u8, 133u8, 245u8, 60u8],
5440            [31u8, 219u8, 12u8, 253u8],
5441            [39u8, 148u8, 50u8, 235u8],
5442            [51u8, 207u8, 183u8, 183u8],
5443            [59u8, 194u8, 140u8, 140u8],
5444            [107u8, 58u8, 167u8, 46u8],
5445            [113u8, 80u8, 24u8, 166u8],
5446            [141u8, 165u8, 203u8, 91u8],
5447            [153u8, 38u8, 238u8, 125u8],
5448            [157u8, 161u8, 109u8, 142u8],
5449            [160u8, 22u8, 157u8, 221u8],
5450            [162u8, 11u8, 153u8, 191u8],
5451            [163u8, 100u8, 244u8, 218u8],
5452            [169u8, 143u8, 179u8, 85u8],
5453            [186u8, 85u8, 8u8, 128u8],
5454            [193u8, 168u8, 226u8, 197u8],
5455            [228u8, 129u8, 175u8, 157u8],
5456            [242u8, 253u8, 227u8, 139u8],
5457            [252u8, 41u8, 157u8, 238u8],
5458            [252u8, 227u8, 108u8, 125u8],
5459        ];
5460    }
5461    #[automatically_derived]
5462    impl alloy_sol_types::SolInterface for ServiceManagerBaseCalls {
5463        const NAME: &'static str = "ServiceManagerBaseCalls";
5464        const MIN_DATA_LENGTH: usize = 0usize;
5465        const COUNT: usize = 20usize;
5466        #[inline]
5467        fn selector(&self) -> [u8; 4] {
5468            match self {
5469                Self::addPendingAdmin(_) => {
5470                    <addPendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
5471                }
5472                Self::avsDirectory(_) => {
5473                    <avsDirectoryCall as alloy_sol_types::SolCall>::SELECTOR
5474                }
5475                Self::createAVSRewardsSubmission(_) => {
5476                    <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::SELECTOR
5477                }
5478                Self::createOperatorDirectedAVSRewardsSubmission(_) => {
5479                    <createOperatorDirectedAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::SELECTOR
5480                }
5481                Self::deregisterOperatorFromAVS(_) => {
5482                    <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::SELECTOR
5483                }
5484                Self::deregisterOperatorFromOperatorSets(_) => {
5485                    <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
5486                }
5487                Self::getOperatorRestakedStrategies(_) => {
5488                    <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::SELECTOR
5489                }
5490                Self::getRestakeableStrategies(_) => {
5491                    <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::SELECTOR
5492                }
5493                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
5494                Self::registerOperatorToAVS(_) => {
5495                    <registerOperatorToAVSCall as alloy_sol_types::SolCall>::SELECTOR
5496                }
5497                Self::removeAdmin(_) => {
5498                    <removeAdminCall as alloy_sol_types::SolCall>::SELECTOR
5499                }
5500                Self::removeAppointee(_) => {
5501                    <removeAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
5502                }
5503                Self::removePendingAdmin(_) => {
5504                    <removePendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
5505                }
5506                Self::renounceOwnership(_) => {
5507                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
5508                }
5509                Self::rewardsInitiator(_) => {
5510                    <rewardsInitiatorCall as alloy_sol_types::SolCall>::SELECTOR
5511                }
5512                Self::setAppointee(_) => {
5513                    <setAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
5514                }
5515                Self::setClaimerFor(_) => {
5516                    <setClaimerForCall as alloy_sol_types::SolCall>::SELECTOR
5517                }
5518                Self::setRewardsInitiator(_) => {
5519                    <setRewardsInitiatorCall as alloy_sol_types::SolCall>::SELECTOR
5520                }
5521                Self::transferOwnership(_) => {
5522                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
5523                }
5524                Self::updateAVSMetadataURI(_) => {
5525                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::SELECTOR
5526                }
5527            }
5528        }
5529        #[inline]
5530        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5531            Self::SELECTORS.get(i).copied()
5532        }
5533        #[inline]
5534        fn valid_selector(selector: [u8; 4]) -> bool {
5535            Self::SELECTORS.binary_search(&selector).is_ok()
5536        }
5537        #[inline]
5538        #[allow(non_snake_case)]
5539        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
5540            static DECODE_SHIMS: &[fn(
5541                &[u8],
5542            )
5543                -> alloy_sol_types::Result<ServiceManagerBaseCalls>] = &[
5544                {
5545                    fn removeAdmin(
5546                        data: &[u8],
5547                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5548                        <removeAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5549                            .map(ServiceManagerBaseCalls::removeAdmin)
5550                    }
5551                    removeAdmin
5552                },
5553                {
5554                    fn setAppointee(
5555                        data: &[u8],
5556                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5557                        <setAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5558                            .map(ServiceManagerBaseCalls::setAppointee)
5559                    }
5560                    setAppointee
5561                },
5562                {
5563                    fn addPendingAdmin(
5564                        data: &[u8],
5565                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5566                        <addPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5567                            .map(ServiceManagerBaseCalls::addPendingAdmin)
5568                    }
5569                    addPendingAdmin
5570                },
5571                {
5572                    fn getOperatorRestakedStrategies(
5573                        data: &[u8],
5574                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5575                        <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
5576                                data,
5577                            )
5578                            .map(ServiceManagerBaseCalls::getOperatorRestakedStrategies)
5579                    }
5580                    getOperatorRestakedStrategies
5581                },
5582                {
5583                    fn setRewardsInitiator(
5584                        data: &[u8],
5585                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5586                        <setRewardsInitiatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5587                            .map(ServiceManagerBaseCalls::setRewardsInitiator)
5588                    }
5589                    setRewardsInitiator
5590                },
5591                {
5592                    fn avsDirectory(
5593                        data: &[u8],
5594                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5595                        <avsDirectoryCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5596                            .map(ServiceManagerBaseCalls::avsDirectory)
5597                    }
5598                    avsDirectory
5599                },
5600                {
5601                    fn renounceOwnership(
5602                        data: &[u8],
5603                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5604                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5605                            .map(ServiceManagerBaseCalls::renounceOwnership)
5606                    }
5607                    renounceOwnership
5608                },
5609                {
5610                    fn owner(data: &[u8]) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5611                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5612                            .map(ServiceManagerBaseCalls::owner)
5613                    }
5614                    owner
5615                },
5616                {
5617                    fn registerOperatorToAVS(
5618                        data: &[u8],
5619                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5620                        <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
5621                            data,
5622                        )
5623                        .map(ServiceManagerBaseCalls::registerOperatorToAVS)
5624                    }
5625                    registerOperatorToAVS
5626                },
5627                {
5628                    fn removePendingAdmin(
5629                        data: &[u8],
5630                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5631                        <removePendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5632                            .map(ServiceManagerBaseCalls::removePendingAdmin)
5633                    }
5634                    removePendingAdmin
5635                },
5636                {
5637                    fn setClaimerFor(
5638                        data: &[u8],
5639                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5640                        <setClaimerForCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5641                            .map(ServiceManagerBaseCalls::setClaimerFor)
5642                    }
5643                    setClaimerFor
5644                },
5645                {
5646                    fn createOperatorDirectedAVSRewardsSubmission(
5647                        data: &[u8],
5648                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5649                        <createOperatorDirectedAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_decode_raw(
5650                                data,
5651                            )
5652                            .map(
5653                                ServiceManagerBaseCalls::createOperatorDirectedAVSRewardsSubmission,
5654                            )
5655                    }
5656                    createOperatorDirectedAVSRewardsSubmission
5657                },
5658                {
5659                    fn deregisterOperatorFromAVS(
5660                        data: &[u8],
5661                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5662                        <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_decode_raw(
5663                            data,
5664                        )
5665                        .map(ServiceManagerBaseCalls::deregisterOperatorFromAVS)
5666                    }
5667                    deregisterOperatorFromAVS
5668                },
5669                {
5670                    fn updateAVSMetadataURI(
5671                        data: &[u8],
5672                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5673                        <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5674                            .map(ServiceManagerBaseCalls::updateAVSMetadataURI)
5675                    }
5676                    updateAVSMetadataURI
5677                },
5678                {
5679                    fn removeAppointee(
5680                        data: &[u8],
5681                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5682                        <removeAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5683                            .map(ServiceManagerBaseCalls::removeAppointee)
5684                    }
5685                    removeAppointee
5686                },
5687                {
5688                    fn deregisterOperatorFromOperatorSets(
5689                        data: &[u8],
5690                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5691                        <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
5692                                data,
5693                            )
5694                            .map(
5695                                ServiceManagerBaseCalls::deregisterOperatorFromOperatorSets,
5696                            )
5697                    }
5698                    deregisterOperatorFromOperatorSets
5699                },
5700                {
5701                    fn getRestakeableStrategies(
5702                        data: &[u8],
5703                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5704                        <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
5705                            data,
5706                        )
5707                        .map(ServiceManagerBaseCalls::getRestakeableStrategies)
5708                    }
5709                    getRestakeableStrategies
5710                },
5711                {
5712                    fn transferOwnership(
5713                        data: &[u8],
5714                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5715                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5716                            .map(ServiceManagerBaseCalls::transferOwnership)
5717                    }
5718                    transferOwnership
5719                },
5720                {
5721                    fn rewardsInitiator(
5722                        data: &[u8],
5723                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5724                        <rewardsInitiatorCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
5725                            .map(ServiceManagerBaseCalls::rewardsInitiator)
5726                    }
5727                    rewardsInitiator
5728                },
5729                {
5730                    fn createAVSRewardsSubmission(
5731                        data: &[u8],
5732                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5733                        <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_decode_raw(
5734                                data,
5735                            )
5736                            .map(ServiceManagerBaseCalls::createAVSRewardsSubmission)
5737                    }
5738                    createAVSRewardsSubmission
5739                },
5740            ];
5741            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5742                return Err(alloy_sol_types::Error::unknown_selector(
5743                    <Self as alloy_sol_types::SolInterface>::NAME,
5744                    selector,
5745                ));
5746            };
5747            DECODE_SHIMS[idx](data)
5748        }
5749        #[inline]
5750        #[allow(non_snake_case)]
5751        fn abi_decode_raw_validate(
5752            selector: [u8; 4],
5753            data: &[u8],
5754        ) -> alloy_sol_types::Result<Self> {
5755            static DECODE_VALIDATE_SHIMS: &[fn(
5756                &[u8],
5757            ) -> alloy_sol_types::Result<
5758                ServiceManagerBaseCalls,
5759            >] = &[
5760                {
5761                    fn removeAdmin(
5762                        data: &[u8],
5763                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5764                        <removeAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
5765                            .map(ServiceManagerBaseCalls::removeAdmin)
5766                    }
5767                    removeAdmin
5768                },
5769                {
5770                    fn setAppointee(
5771                        data: &[u8],
5772                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5773                        <setAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5774                            data,
5775                        )
5776                        .map(ServiceManagerBaseCalls::setAppointee)
5777                    }
5778                    setAppointee
5779                },
5780                {
5781                    fn addPendingAdmin(
5782                        data: &[u8],
5783                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5784                        <addPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5785                            data,
5786                        )
5787                        .map(ServiceManagerBaseCalls::addPendingAdmin)
5788                    }
5789                    addPendingAdmin
5790                },
5791                {
5792                    fn getOperatorRestakedStrategies(
5793                        data: &[u8],
5794                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5795                        <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5796                                data,
5797                            )
5798                            .map(ServiceManagerBaseCalls::getOperatorRestakedStrategies)
5799                    }
5800                    getOperatorRestakedStrategies
5801                },
5802                {
5803                    fn setRewardsInitiator(
5804                        data: &[u8],
5805                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5806                        <setRewardsInitiatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5807                                data,
5808                            )
5809                            .map(ServiceManagerBaseCalls::setRewardsInitiator)
5810                    }
5811                    setRewardsInitiator
5812                },
5813                {
5814                    fn avsDirectory(
5815                        data: &[u8],
5816                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5817                        <avsDirectoryCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5818                            data,
5819                        )
5820                        .map(ServiceManagerBaseCalls::avsDirectory)
5821                    }
5822                    avsDirectory
5823                },
5824                {
5825                    fn renounceOwnership(
5826                        data: &[u8],
5827                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5828                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5829                                data,
5830                            )
5831                            .map(ServiceManagerBaseCalls::renounceOwnership)
5832                    }
5833                    renounceOwnership
5834                },
5835                {
5836                    fn owner(data: &[u8]) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5837                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(data)
5838                            .map(ServiceManagerBaseCalls::owner)
5839                    }
5840                    owner
5841                },
5842                {
5843                    fn registerOperatorToAVS(
5844                        data: &[u8],
5845                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5846                        <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5847                                data,
5848                            )
5849                            .map(ServiceManagerBaseCalls::registerOperatorToAVS)
5850                    }
5851                    registerOperatorToAVS
5852                },
5853                {
5854                    fn removePendingAdmin(
5855                        data: &[u8],
5856                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5857                        <removePendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5858                                data,
5859                            )
5860                            .map(ServiceManagerBaseCalls::removePendingAdmin)
5861                    }
5862                    removePendingAdmin
5863                },
5864                {
5865                    fn setClaimerFor(
5866                        data: &[u8],
5867                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5868                        <setClaimerForCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5869                            data,
5870                        )
5871                        .map(ServiceManagerBaseCalls::setClaimerFor)
5872                    }
5873                    setClaimerFor
5874                },
5875                {
5876                    fn createOperatorDirectedAVSRewardsSubmission(
5877                        data: &[u8],
5878                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5879                        <createOperatorDirectedAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5880                                data,
5881                            )
5882                            .map(
5883                                ServiceManagerBaseCalls::createOperatorDirectedAVSRewardsSubmission,
5884                            )
5885                    }
5886                    createOperatorDirectedAVSRewardsSubmission
5887                },
5888                {
5889                    fn deregisterOperatorFromAVS(
5890                        data: &[u8],
5891                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5892                        <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5893                                data,
5894                            )
5895                            .map(ServiceManagerBaseCalls::deregisterOperatorFromAVS)
5896                    }
5897                    deregisterOperatorFromAVS
5898                },
5899                {
5900                    fn updateAVSMetadataURI(
5901                        data: &[u8],
5902                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5903                        <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5904                                data,
5905                            )
5906                            .map(ServiceManagerBaseCalls::updateAVSMetadataURI)
5907                    }
5908                    updateAVSMetadataURI
5909                },
5910                {
5911                    fn removeAppointee(
5912                        data: &[u8],
5913                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5914                        <removeAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5915                            data,
5916                        )
5917                        .map(ServiceManagerBaseCalls::removeAppointee)
5918                    }
5919                    removeAppointee
5920                },
5921                {
5922                    fn deregisterOperatorFromOperatorSets(
5923                        data: &[u8],
5924                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5925                        <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5926                                data,
5927                            )
5928                            .map(
5929                                ServiceManagerBaseCalls::deregisterOperatorFromOperatorSets,
5930                            )
5931                    }
5932                    deregisterOperatorFromOperatorSets
5933                },
5934                {
5935                    fn getRestakeableStrategies(
5936                        data: &[u8],
5937                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5938                        <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5939                                data,
5940                            )
5941                            .map(ServiceManagerBaseCalls::getRestakeableStrategies)
5942                    }
5943                    getRestakeableStrategies
5944                },
5945                {
5946                    fn transferOwnership(
5947                        data: &[u8],
5948                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5949                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5950                                data,
5951                            )
5952                            .map(ServiceManagerBaseCalls::transferOwnership)
5953                    }
5954                    transferOwnership
5955                },
5956                {
5957                    fn rewardsInitiator(
5958                        data: &[u8],
5959                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5960                        <rewardsInitiatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5961                            data,
5962                        )
5963                        .map(ServiceManagerBaseCalls::rewardsInitiator)
5964                    }
5965                    rewardsInitiator
5966                },
5967                {
5968                    fn createAVSRewardsSubmission(
5969                        data: &[u8],
5970                    ) -> alloy_sol_types::Result<ServiceManagerBaseCalls> {
5971                        <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5972                                data,
5973                            )
5974                            .map(ServiceManagerBaseCalls::createAVSRewardsSubmission)
5975                    }
5976                    createAVSRewardsSubmission
5977                },
5978            ];
5979            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5980                return Err(alloy_sol_types::Error::unknown_selector(
5981                    <Self as alloy_sol_types::SolInterface>::NAME,
5982                    selector,
5983                ));
5984            };
5985            DECODE_VALIDATE_SHIMS[idx](data)
5986        }
5987        #[inline]
5988        fn abi_encoded_size(&self) -> usize {
5989            match self {
5990                Self::addPendingAdmin(inner) => {
5991                    <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
5992                        inner,
5993                    )
5994                }
5995                Self::avsDirectory(inner) => {
5996                    <avsDirectoryCall as alloy_sol_types::SolCall>::abi_encoded_size(
5997                        inner,
5998                    )
5999                }
6000                Self::createAVSRewardsSubmission(inner) => {
6001                    <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_encoded_size(
6002                        inner,
6003                    )
6004                }
6005                Self::createOperatorDirectedAVSRewardsSubmission(inner) => {
6006                    <createOperatorDirectedAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_encoded_size(
6007                        inner,
6008                    )
6009                }
6010                Self::deregisterOperatorFromAVS(inner) => {
6011                    <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(
6012                        inner,
6013                    )
6014                }
6015                Self::deregisterOperatorFromOperatorSets(inner) => {
6016                    <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
6017                        inner,
6018                    )
6019                }
6020                Self::getOperatorRestakedStrategies(inner) => {
6021                    <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
6022                        inner,
6023                    )
6024                }
6025                Self::getRestakeableStrategies(inner) => {
6026                    <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
6027                        inner,
6028                    )
6029                }
6030                Self::owner(inner) => {
6031                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
6032                }
6033                Self::registerOperatorToAVS(inner) => {
6034                    <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_encoded_size(
6035                        inner,
6036                    )
6037                }
6038                Self::removeAdmin(inner) => {
6039                    <removeAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
6040                        inner,
6041                    )
6042                }
6043                Self::removeAppointee(inner) => {
6044                    <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
6045                        inner,
6046                    )
6047                }
6048                Self::removePendingAdmin(inner) => {
6049                    <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
6050                        inner,
6051                    )
6052                }
6053                Self::renounceOwnership(inner) => {
6054                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
6055                        inner,
6056                    )
6057                }
6058                Self::rewardsInitiator(inner) => {
6059                    <rewardsInitiatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
6060                        inner,
6061                    )
6062                }
6063                Self::setAppointee(inner) => {
6064                    <setAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
6065                        inner,
6066                    )
6067                }
6068                Self::setClaimerFor(inner) => {
6069                    <setClaimerForCall as alloy_sol_types::SolCall>::abi_encoded_size(
6070                        inner,
6071                    )
6072                }
6073                Self::setRewardsInitiator(inner) => {
6074                    <setRewardsInitiatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
6075                        inner,
6076                    )
6077                }
6078                Self::transferOwnership(inner) => {
6079                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
6080                        inner,
6081                    )
6082                }
6083                Self::updateAVSMetadataURI(inner) => {
6084                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encoded_size(
6085                        inner,
6086                    )
6087                }
6088            }
6089        }
6090        #[inline]
6091        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
6092            match self {
6093                Self::addPendingAdmin(inner) => {
6094                    <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
6095                        inner,
6096                        out,
6097                    )
6098                }
6099                Self::avsDirectory(inner) => {
6100                    <avsDirectoryCall as alloy_sol_types::SolCall>::abi_encode_raw(
6101                        inner,
6102                        out,
6103                    )
6104                }
6105                Self::createAVSRewardsSubmission(inner) => {
6106                    <createAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_encode_raw(
6107                        inner,
6108                        out,
6109                    )
6110                }
6111                Self::createOperatorDirectedAVSRewardsSubmission(inner) => {
6112                    <createOperatorDirectedAVSRewardsSubmissionCall as alloy_sol_types::SolCall>::abi_encode_raw(
6113                        inner,
6114                        out,
6115                    )
6116                }
6117                Self::deregisterOperatorFromAVS(inner) => {
6118                    <deregisterOperatorFromAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(
6119                        inner,
6120                        out,
6121                    )
6122                }
6123                Self::deregisterOperatorFromOperatorSets(inner) => {
6124                    <deregisterOperatorFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
6125                        inner,
6126                        out,
6127                    )
6128                }
6129                Self::getOperatorRestakedStrategies(inner) => {
6130                    <getOperatorRestakedStrategiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
6131                        inner,
6132                        out,
6133                    )
6134                }
6135                Self::getRestakeableStrategies(inner) => {
6136                    <getRestakeableStrategiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
6137                        inner,
6138                        out,
6139                    )
6140                }
6141                Self::owner(inner) => {
6142                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
6143                }
6144                Self::registerOperatorToAVS(inner) => {
6145                    <registerOperatorToAVSCall as alloy_sol_types::SolCall>::abi_encode_raw(
6146                        inner,
6147                        out,
6148                    )
6149                }
6150                Self::removeAdmin(inner) => {
6151                    <removeAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
6152                        inner,
6153                        out,
6154                    )
6155                }
6156                Self::removeAppointee(inner) => {
6157                    <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
6158                        inner,
6159                        out,
6160                    )
6161                }
6162                Self::removePendingAdmin(inner) => {
6163                    <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
6164                        inner,
6165                        out,
6166                    )
6167                }
6168                Self::renounceOwnership(inner) => {
6169                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
6170                        inner,
6171                        out,
6172                    )
6173                }
6174                Self::rewardsInitiator(inner) => {
6175                    <rewardsInitiatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
6176                        inner,
6177                        out,
6178                    )
6179                }
6180                Self::setAppointee(inner) => {
6181                    <setAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
6182                        inner,
6183                        out,
6184                    )
6185                }
6186                Self::setClaimerFor(inner) => {
6187                    <setClaimerForCall as alloy_sol_types::SolCall>::abi_encode_raw(
6188                        inner,
6189                        out,
6190                    )
6191                }
6192                Self::setRewardsInitiator(inner) => {
6193                    <setRewardsInitiatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
6194                        inner,
6195                        out,
6196                    )
6197                }
6198                Self::transferOwnership(inner) => {
6199                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
6200                        inner,
6201                        out,
6202                    )
6203                }
6204                Self::updateAVSMetadataURI(inner) => {
6205                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encode_raw(
6206                        inner,
6207                        out,
6208                    )
6209                }
6210            }
6211        }
6212    }
6213    ///Container for all the [`ServiceManagerBase`](self) custom errors.
6214    #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
6215    pub enum ServiceManagerBaseErrors {
6216        #[allow(missing_docs)]
6217        DelayPeriodNotPassed(DelayPeriodNotPassed),
6218        #[allow(missing_docs)]
6219        OnlyRegistryCoordinator(OnlyRegistryCoordinator),
6220        #[allow(missing_docs)]
6221        OnlyRewardsInitiator(OnlyRewardsInitiator),
6222        #[allow(missing_docs)]
6223        OnlyStakeRegistry(OnlyStakeRegistry),
6224    }
6225    #[automatically_derived]
6226    impl ServiceManagerBaseErrors {
6227        /// All the selectors of this enum.
6228        ///
6229        /// Note that the selectors might not be in the same order as the variants.
6230        /// No guarantees are made about the order of the selectors.
6231        ///
6232        /// Prefer using `SolInterface` methods instead.
6233        pub const SELECTORS: &'static [[u8; 4usize]] = &[
6234            [70u8, 191u8, 34u8, 129u8],
6235            [135u8, 41u8, 183u8, 190u8],
6236            [142u8, 121u8, 253u8, 181u8],
6237            [251u8, 98u8, 59u8, 4u8],
6238        ];
6239    }
6240    #[automatically_derived]
6241    impl alloy_sol_types::SolInterface for ServiceManagerBaseErrors {
6242        const NAME: &'static str = "ServiceManagerBaseErrors";
6243        const MIN_DATA_LENGTH: usize = 0usize;
6244        const COUNT: usize = 4usize;
6245        #[inline]
6246        fn selector(&self) -> [u8; 4] {
6247            match self {
6248                Self::DelayPeriodNotPassed(_) => {
6249                    <DelayPeriodNotPassed as alloy_sol_types::SolError>::SELECTOR
6250                }
6251                Self::OnlyRegistryCoordinator(_) => {
6252                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::SELECTOR
6253                }
6254                Self::OnlyRewardsInitiator(_) => {
6255                    <OnlyRewardsInitiator as alloy_sol_types::SolError>::SELECTOR
6256                }
6257                Self::OnlyStakeRegistry(_) => {
6258                    <OnlyStakeRegistry as alloy_sol_types::SolError>::SELECTOR
6259                }
6260            }
6261        }
6262        #[inline]
6263        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
6264            Self::SELECTORS.get(i).copied()
6265        }
6266        #[inline]
6267        fn valid_selector(selector: [u8; 4]) -> bool {
6268            Self::SELECTORS.binary_search(&selector).is_ok()
6269        }
6270        #[inline]
6271        #[allow(non_snake_case)]
6272        fn abi_decode_raw(selector: [u8; 4], data: &[u8]) -> alloy_sol_types::Result<Self> {
6273            static DECODE_SHIMS: &[fn(
6274                &[u8],
6275            )
6276                -> alloy_sol_types::Result<ServiceManagerBaseErrors>] = &[
6277                {
6278                    fn OnlyStakeRegistry(
6279                        data: &[u8],
6280                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6281                        <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_decode_raw(data)
6282                            .map(ServiceManagerBaseErrors::OnlyStakeRegistry)
6283                    }
6284                    OnlyStakeRegistry
6285                },
6286                {
6287                    fn OnlyRegistryCoordinator(
6288                        data: &[u8],
6289                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6290                        <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw(data)
6291                            .map(ServiceManagerBaseErrors::OnlyRegistryCoordinator)
6292                    }
6293                    OnlyRegistryCoordinator
6294                },
6295                {
6296                    fn OnlyRewardsInitiator(
6297                        data: &[u8],
6298                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6299                        <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_decode_raw(data)
6300                            .map(ServiceManagerBaseErrors::OnlyRewardsInitiator)
6301                    }
6302                    OnlyRewardsInitiator
6303                },
6304                {
6305                    fn DelayPeriodNotPassed(
6306                        data: &[u8],
6307                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6308                        <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_decode_raw(data)
6309                            .map(ServiceManagerBaseErrors::DelayPeriodNotPassed)
6310                    }
6311                    DelayPeriodNotPassed
6312                },
6313            ];
6314            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
6315                return Err(alloy_sol_types::Error::unknown_selector(
6316                    <Self as alloy_sol_types::SolInterface>::NAME,
6317                    selector,
6318                ));
6319            };
6320            DECODE_SHIMS[idx](data)
6321        }
6322        #[inline]
6323        #[allow(non_snake_case)]
6324        fn abi_decode_raw_validate(
6325            selector: [u8; 4],
6326            data: &[u8],
6327        ) -> alloy_sol_types::Result<Self> {
6328            static DECODE_VALIDATE_SHIMS: &[fn(
6329                &[u8],
6330            ) -> alloy_sol_types::Result<
6331                ServiceManagerBaseErrors,
6332            >] = &[
6333                {
6334                    fn OnlyStakeRegistry(
6335                        data: &[u8],
6336                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6337                        <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_decode_raw_validate(
6338                            data,
6339                        )
6340                        .map(ServiceManagerBaseErrors::OnlyStakeRegistry)
6341                    }
6342                    OnlyStakeRegistry
6343                },
6344                {
6345                    fn OnlyRegistryCoordinator(
6346                        data: &[u8],
6347                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6348                        <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw_validate(
6349                                data,
6350                            )
6351                            .map(ServiceManagerBaseErrors::OnlyRegistryCoordinator)
6352                    }
6353                    OnlyRegistryCoordinator
6354                },
6355                {
6356                    fn OnlyRewardsInitiator(
6357                        data: &[u8],
6358                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6359                        <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_decode_raw_validate(
6360                                data,
6361                            )
6362                            .map(ServiceManagerBaseErrors::OnlyRewardsInitiator)
6363                    }
6364                    OnlyRewardsInitiator
6365                },
6366                {
6367                    fn DelayPeriodNotPassed(
6368                        data: &[u8],
6369                    ) -> alloy_sol_types::Result<ServiceManagerBaseErrors> {
6370                        <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_decode_raw_validate(
6371                                data,
6372                            )
6373                            .map(ServiceManagerBaseErrors::DelayPeriodNotPassed)
6374                    }
6375                    DelayPeriodNotPassed
6376                },
6377            ];
6378            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
6379                return Err(alloy_sol_types::Error::unknown_selector(
6380                    <Self as alloy_sol_types::SolInterface>::NAME,
6381                    selector,
6382                ));
6383            };
6384            DECODE_VALIDATE_SHIMS[idx](data)
6385        }
6386        #[inline]
6387        fn abi_encoded_size(&self) -> usize {
6388            match self {
6389                Self::DelayPeriodNotPassed(inner) => {
6390                    <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_encoded_size(inner)
6391                }
6392                Self::OnlyRegistryCoordinator(inner) => {
6393                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_encoded_size(inner)
6394                }
6395                Self::OnlyRewardsInitiator(inner) => {
6396                    <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_encoded_size(inner)
6397                }
6398                Self::OnlyStakeRegistry(inner) => {
6399                    <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_encoded_size(inner)
6400                }
6401            }
6402        }
6403        #[inline]
6404        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
6405            match self {
6406                Self::DelayPeriodNotPassed(inner) => {
6407                    <DelayPeriodNotPassed as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
6408                }
6409                Self::OnlyRegistryCoordinator(inner) => {
6410                    <OnlyRegistryCoordinator as alloy_sol_types::SolError>::abi_encode_raw(
6411                        inner, out,
6412                    )
6413                }
6414                Self::OnlyRewardsInitiator(inner) => {
6415                    <OnlyRewardsInitiator as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
6416                }
6417                Self::OnlyStakeRegistry(inner) => {
6418                    <OnlyStakeRegistry as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
6419                }
6420            }
6421        }
6422    }
6423    ///Container for all the [`ServiceManagerBase`](self) events.
6424    #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Eq, Hash)]
6425    pub enum ServiceManagerBaseEvents {
6426        #[allow(missing_docs)]
6427        Initialized(Initialized),
6428        #[allow(missing_docs)]
6429        OwnershipTransferred(OwnershipTransferred),
6430        #[allow(missing_docs)]
6431        RewardsInitiatorUpdated(RewardsInitiatorUpdated),
6432    }
6433    #[automatically_derived]
6434    impl ServiceManagerBaseEvents {
6435        /// All the selectors of this enum.
6436        ///
6437        /// Note that the selectors might not be in the same order as the variants.
6438        /// No guarantees are made about the order of the selectors.
6439        ///
6440        /// Prefer using `SolInterface` methods instead.
6441        pub const SELECTORS: &'static [[u8; 32usize]] = &[
6442            [
6443                127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8, 19u8, 56u8,
6444                82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8, 146u8, 20u8, 96u8,
6445                206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
6446            ],
6447            [
6448                139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8, 31u8, 208u8,
6449                164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8, 218u8, 175u8, 227u8,
6450                180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
6451            ],
6452            [
6453                225u8, 28u8, 221u8, 241u8, 129u8, 106u8, 67u8, 49u8, 140u8, 161u8, 117u8, 187u8,
6454                197u8, 44u8, 208u8, 24u8, 84u8, 54u8, 233u8, 203u8, 234u8, 215u8, 200u8, 58u8,
6455                204u8, 84u8, 167u8, 62u8, 70u8, 23u8, 23u8, 227u8,
6456            ],
6457        ];
6458    }
6459    #[automatically_derived]
6460    impl alloy_sol_types::SolEventInterface for ServiceManagerBaseEvents {
6461        const NAME: &'static str = "ServiceManagerBaseEvents";
6462        const COUNT: usize = 3usize;
6463        fn decode_raw_log(
6464            topics: &[alloy_sol_types::Word],
6465            data: &[u8],
6466        ) -> alloy_sol_types::Result<Self> {
6467            match topics.first().copied() {
6468                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6469                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
6470                        .map(Self::Initialized)
6471                }
6472                Some(<OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6473                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
6474                        topics, data,
6475                    )
6476                    .map(Self::OwnershipTransferred)
6477                }
6478                Some(<RewardsInitiatorUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
6479                    <RewardsInitiatorUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
6480                        topics, data,
6481                    )
6482                    .map(Self::RewardsInitiatorUpdated)
6483                }
6484                _ => alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
6485                    name: <Self as alloy_sol_types::SolEventInterface>::NAME,
6486                    log: alloy_sol_types::private::Box::new(
6487                        alloy_sol_types::private::LogData::new_unchecked(
6488                            topics.to_vec(),
6489                            data.to_vec().into(),
6490                        ),
6491                    ),
6492                }),
6493            }
6494        }
6495    }
6496    #[automatically_derived]
6497    impl alloy_sol_types::private::IntoLogData for ServiceManagerBaseEvents {
6498        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6499            match self {
6500                Self::Initialized(inner) => {
6501                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
6502                }
6503                Self::OwnershipTransferred(inner) => {
6504                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
6505                }
6506                Self::RewardsInitiatorUpdated(inner) => {
6507                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
6508                }
6509            }
6510        }
6511        fn into_log_data(self) -> alloy_sol_types::private::LogData {
6512            match self {
6513                Self::Initialized(inner) => {
6514                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
6515                }
6516                Self::OwnershipTransferred(inner) => {
6517                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
6518                }
6519                Self::RewardsInitiatorUpdated(inner) => {
6520                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
6521                }
6522            }
6523        }
6524    }
6525    use alloy::contract as alloy_contract;
6526    /**Creates a new wrapper around an on-chain [`ServiceManagerBase`](self) contract instance.
6527
6528    See the [wrapper's documentation](`ServiceManagerBaseInstance`) for more details.*/
6529    #[inline]
6530    pub const fn new<
6531        P: alloy_contract::private::Provider<N>,
6532        N: alloy_contract::private::Network,
6533    >(
6534        address: alloy_sol_types::private::Address,
6535        provider: P,
6536    ) -> ServiceManagerBaseInstance<P, N> {
6537        ServiceManagerBaseInstance::<P, N>::new(address, provider)
6538    }
6539    /**Deploys this contract using the given `provider` and constructor arguments, if any.
6540
6541    Returns a new instance of the contract, if the deployment was successful.
6542
6543    For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
6544    #[inline]
6545    pub fn deploy<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>(
6546        provider: P,
6547    ) -> impl ::core::future::Future<Output = alloy_contract::Result<ServiceManagerBaseInstance<P, N>>>
6548    {
6549        ServiceManagerBaseInstance::<P, N>::deploy(provider)
6550    }
6551    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
6552    and constructor arguments, if any.
6553
6554    This is a simple wrapper around creating a `RawCallBuilder` with the data set to
6555    the bytecode concatenated with the constructor's ABI-encoded arguments.*/
6556    #[inline]
6557    pub fn deploy_builder<
6558        P: alloy_contract::private::Provider<N>,
6559        N: alloy_contract::private::Network,
6560    >(
6561        provider: P,
6562    ) -> alloy_contract::RawCallBuilder<P, N> {
6563        ServiceManagerBaseInstance::<P, N>::deploy_builder(provider)
6564    }
6565    /**A [`ServiceManagerBase`](self) instance.
6566
6567    Contains type-safe methods for interacting with an on-chain instance of the
6568    [`ServiceManagerBase`](self) contract located at a given `address`, using a given
6569    provider `P`.
6570
6571    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
6572    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
6573    be used to deploy a new instance of the contract.
6574
6575    See the [module-level documentation](self) for all the available methods.*/
6576    #[derive(Clone)]
6577    pub struct ServiceManagerBaseInstance<P, N = alloy_contract::private::Ethereum> {
6578        address: alloy_sol_types::private::Address,
6579        provider: P,
6580        _network: ::core::marker::PhantomData<N>,
6581    }
6582    #[automatically_derived]
6583    impl<P, N> ::core::fmt::Debug for ServiceManagerBaseInstance<P, N> {
6584        #[inline]
6585        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6586            f.debug_tuple("ServiceManagerBaseInstance")
6587                .field(&self.address)
6588                .finish()
6589        }
6590    }
6591    /// Instantiation and getters/setters.
6592    #[automatically_derived]
6593    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
6594        ServiceManagerBaseInstance<P, N>
6595    {
6596        /**Creates a new wrapper around an on-chain [`ServiceManagerBase`](self) contract instance.
6597
6598        See the [wrapper's documentation](`ServiceManagerBaseInstance`) for more details.*/
6599        #[inline]
6600        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
6601            Self {
6602                address,
6603                provider,
6604                _network: ::core::marker::PhantomData,
6605            }
6606        }
6607        /**Deploys this contract using the given `provider` and constructor arguments, if any.
6608
6609        Returns a new instance of the contract, if the deployment was successful.
6610
6611        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
6612        #[inline]
6613        pub async fn deploy(
6614            provider: P,
6615        ) -> alloy_contract::Result<ServiceManagerBaseInstance<P, N>> {
6616            let call_builder = Self::deploy_builder(provider);
6617            let contract_address = call_builder.deploy().await?;
6618            Ok(Self::new(contract_address, call_builder.provider))
6619        }
6620        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
6621        and constructor arguments, if any.
6622
6623        This is a simple wrapper around creating a `RawCallBuilder` with the data set to
6624        the bytecode concatenated with the constructor's ABI-encoded arguments.*/
6625        #[inline]
6626        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
6627            alloy_contract::RawCallBuilder::new_raw_deploy(
6628                provider,
6629                ::core::clone::Clone::clone(&BYTECODE),
6630            )
6631        }
6632        /// Returns a reference to the address.
6633        #[inline]
6634        pub const fn address(&self) -> &alloy_sol_types::private::Address {
6635            &self.address
6636        }
6637        /// Sets the address.
6638        #[inline]
6639        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
6640            self.address = address;
6641        }
6642        /// Sets the address and returns `self`.
6643        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
6644            self.set_address(address);
6645            self
6646        }
6647        /// Returns a reference to the provider.
6648        #[inline]
6649        pub const fn provider(&self) -> &P {
6650            &self.provider
6651        }
6652    }
6653    impl<P: ::core::clone::Clone, N> ServiceManagerBaseInstance<&P, N> {
6654        /// Clones the provider and returns a new instance with the cloned provider.
6655        #[inline]
6656        pub fn with_cloned_provider(self) -> ServiceManagerBaseInstance<P, N> {
6657            ServiceManagerBaseInstance {
6658                address: self.address,
6659                provider: ::core::clone::Clone::clone(&self.provider),
6660                _network: ::core::marker::PhantomData,
6661            }
6662        }
6663    }
6664    /// Function calls.
6665    #[automatically_derived]
6666    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
6667        ServiceManagerBaseInstance<P, N>
6668    {
6669        /// Creates a new call builder using this contract instance's provider and address.
6670        ///
6671        /// Note that the call can be any function call, not just those defined in this
6672        /// contract. Prefer using the other methods for building type-safe contract calls.
6673        pub fn call_builder<C: alloy_sol_types::SolCall>(
6674            &self,
6675            call: &C,
6676        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
6677            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
6678        }
6679        ///Creates a new call builder for the [`addPendingAdmin`] function.
6680        pub fn addPendingAdmin(
6681            &self,
6682            admin: alloy::sol_types::private::Address,
6683        ) -> alloy_contract::SolCallBuilder<&P, addPendingAdminCall, N> {
6684            self.call_builder(&addPendingAdminCall { admin })
6685        }
6686        ///Creates a new call builder for the [`avsDirectory`] function.
6687        pub fn avsDirectory(&self) -> alloy_contract::SolCallBuilder<&P, avsDirectoryCall, N> {
6688            self.call_builder(&avsDirectoryCall)
6689        }
6690        ///Creates a new call builder for the [`createAVSRewardsSubmission`] function.
6691        pub fn createAVSRewardsSubmission(
6692            &self,
6693            rewardsSubmissions: alloy::sol_types::private::Vec<
6694                <IRewardsCoordinatorTypes::RewardsSubmission as alloy::sol_types::SolType>::RustType,
6695            >,
6696        ) -> alloy_contract::SolCallBuilder<&P, createAVSRewardsSubmissionCall, N> {
6697            self.call_builder(&createAVSRewardsSubmissionCall { rewardsSubmissions })
6698        }
6699        ///Creates a new call builder for the [`createOperatorDirectedAVSRewardsSubmission`] function.
6700        pub fn createOperatorDirectedAVSRewardsSubmission(
6701            &self,
6702            operatorDirectedRewardsSubmissions: alloy::sol_types::private::Vec<
6703                <IRewardsCoordinatorTypes::OperatorDirectedRewardsSubmission as alloy::sol_types::SolType>::RustType,
6704            >,
6705        ) -> alloy_contract::SolCallBuilder<&P, createOperatorDirectedAVSRewardsSubmissionCall, N>
6706        {
6707            self.call_builder(&createOperatorDirectedAVSRewardsSubmissionCall {
6708                operatorDirectedRewardsSubmissions,
6709            })
6710        }
6711        ///Creates a new call builder for the [`deregisterOperatorFromAVS`] function.
6712        pub fn deregisterOperatorFromAVS(
6713            &self,
6714            operator: alloy::sol_types::private::Address,
6715        ) -> alloy_contract::SolCallBuilder<&P, deregisterOperatorFromAVSCall, N> {
6716            self.call_builder(&deregisterOperatorFromAVSCall { operator })
6717        }
6718        ///Creates a new call builder for the [`deregisterOperatorFromOperatorSets`] function.
6719        pub fn deregisterOperatorFromOperatorSets(
6720            &self,
6721            operator: alloy::sol_types::private::Address,
6722            operatorSetIds: alloy::sol_types::private::Vec<u32>,
6723        ) -> alloy_contract::SolCallBuilder<&P, deregisterOperatorFromOperatorSetsCall, N> {
6724            self.call_builder(&deregisterOperatorFromOperatorSetsCall {
6725                operator,
6726                operatorSetIds,
6727            })
6728        }
6729        ///Creates a new call builder for the [`getOperatorRestakedStrategies`] function.
6730        pub fn getOperatorRestakedStrategies(
6731            &self,
6732            operator: alloy::sol_types::private::Address,
6733        ) -> alloy_contract::SolCallBuilder<&P, getOperatorRestakedStrategiesCall, N> {
6734            self.call_builder(&getOperatorRestakedStrategiesCall { operator })
6735        }
6736        ///Creates a new call builder for the [`getRestakeableStrategies`] function.
6737        pub fn getRestakeableStrategies(
6738            &self,
6739        ) -> alloy_contract::SolCallBuilder<&P, getRestakeableStrategiesCall, N> {
6740            self.call_builder(&getRestakeableStrategiesCall)
6741        }
6742        ///Creates a new call builder for the [`owner`] function.
6743        pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
6744            self.call_builder(&ownerCall)
6745        }
6746        ///Creates a new call builder for the [`registerOperatorToAVS`] function.
6747        pub fn registerOperatorToAVS(
6748            &self,
6749            operator: alloy::sol_types::private::Address,
6750            operatorSignature: <ISignatureUtilsMixinTypes::SignatureWithSaltAndExpiry as alloy::sol_types::SolType>::RustType,
6751        ) -> alloy_contract::SolCallBuilder<&P, registerOperatorToAVSCall, N> {
6752            self.call_builder(&registerOperatorToAVSCall {
6753                operator,
6754                operatorSignature,
6755            })
6756        }
6757        ///Creates a new call builder for the [`removeAdmin`] function.
6758        pub fn removeAdmin(
6759            &self,
6760            admin: alloy::sol_types::private::Address,
6761        ) -> alloy_contract::SolCallBuilder<&P, removeAdminCall, N> {
6762            self.call_builder(&removeAdminCall { admin })
6763        }
6764        ///Creates a new call builder for the [`removeAppointee`] function.
6765        pub fn removeAppointee(
6766            &self,
6767            appointee: alloy::sol_types::private::Address,
6768            target: alloy::sol_types::private::Address,
6769            selector: alloy::sol_types::private::FixedBytes<4>,
6770        ) -> alloy_contract::SolCallBuilder<&P, removeAppointeeCall, N> {
6771            self.call_builder(&removeAppointeeCall {
6772                appointee,
6773                target,
6774                selector,
6775            })
6776        }
6777        ///Creates a new call builder for the [`removePendingAdmin`] function.
6778        pub fn removePendingAdmin(
6779            &self,
6780            pendingAdmin: alloy::sol_types::private::Address,
6781        ) -> alloy_contract::SolCallBuilder<&P, removePendingAdminCall, N> {
6782            self.call_builder(&removePendingAdminCall { pendingAdmin })
6783        }
6784        ///Creates a new call builder for the [`renounceOwnership`] function.
6785        pub fn renounceOwnership(
6786            &self,
6787        ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
6788            self.call_builder(&renounceOwnershipCall)
6789        }
6790        ///Creates a new call builder for the [`rewardsInitiator`] function.
6791        pub fn rewardsInitiator(
6792            &self,
6793        ) -> alloy_contract::SolCallBuilder<&P, rewardsInitiatorCall, N> {
6794            self.call_builder(&rewardsInitiatorCall)
6795        }
6796        ///Creates a new call builder for the [`setAppointee`] function.
6797        pub fn setAppointee(
6798            &self,
6799            appointee: alloy::sol_types::private::Address,
6800            target: alloy::sol_types::private::Address,
6801            selector: alloy::sol_types::private::FixedBytes<4>,
6802        ) -> alloy_contract::SolCallBuilder<&P, setAppointeeCall, N> {
6803            self.call_builder(&setAppointeeCall {
6804                appointee,
6805                target,
6806                selector,
6807            })
6808        }
6809        ///Creates a new call builder for the [`setClaimerFor`] function.
6810        pub fn setClaimerFor(
6811            &self,
6812            claimer: alloy::sol_types::private::Address,
6813        ) -> alloy_contract::SolCallBuilder<&P, setClaimerForCall, N> {
6814            self.call_builder(&setClaimerForCall { claimer })
6815        }
6816        ///Creates a new call builder for the [`setRewardsInitiator`] function.
6817        pub fn setRewardsInitiator(
6818            &self,
6819            newRewardsInitiator: alloy::sol_types::private::Address,
6820        ) -> alloy_contract::SolCallBuilder<&P, setRewardsInitiatorCall, N> {
6821            self.call_builder(&setRewardsInitiatorCall {
6822                newRewardsInitiator,
6823            })
6824        }
6825        ///Creates a new call builder for the [`transferOwnership`] function.
6826        pub fn transferOwnership(
6827            &self,
6828            newOwner: alloy::sol_types::private::Address,
6829        ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
6830            self.call_builder(&transferOwnershipCall { newOwner })
6831        }
6832        ///Creates a new call builder for the [`updateAVSMetadataURI`] function.
6833        pub fn updateAVSMetadataURI(
6834            &self,
6835            _metadataURI: alloy::sol_types::private::String,
6836        ) -> alloy_contract::SolCallBuilder<&P, updateAVSMetadataURICall, N> {
6837            self.call_builder(&updateAVSMetadataURICall { _metadataURI })
6838        }
6839    }
6840    /// Event filters.
6841    #[automatically_derived]
6842    impl<P: alloy_contract::private::Provider<N>, N: alloy_contract::private::Network>
6843        ServiceManagerBaseInstance<P, N>
6844    {
6845        /// Creates a new event filter using this contract instance's provider and address.
6846        ///
6847        /// Note that the type can be any event, not just those defined in this contract.
6848        /// Prefer using the other methods for building type-safe event filters.
6849        pub fn event_filter<E: alloy_sol_types::SolEvent>(
6850            &self,
6851        ) -> alloy_contract::Event<&P, E, N> {
6852            alloy_contract::Event::new_sol(&self.provider, &self.address)
6853        }
6854        ///Creates a new event filter for the [`Initialized`] event.
6855        pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
6856            self.event_filter::<Initialized>()
6857        }
6858        ///Creates a new event filter for the [`OwnershipTransferred`] event.
6859        pub fn OwnershipTransferred_filter(
6860            &self,
6861        ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
6862            self.event_filter::<OwnershipTransferred>()
6863        }
6864        ///Creates a new event filter for the [`RewardsInitiatorUpdated`] event.
6865        pub fn RewardsInitiatorUpdated_filter(
6866            &self,
6867        ) -> alloy_contract::Event<&P, RewardsInitiatorUpdated, N> {
6868            self.event_filter::<RewardsInitiatorUpdated>()
6869        }
6870    }
6871}
eigen_utils/slashing/middleware/service_manager_base.rs

eigen_utils/slashing/middleware/
service_manager_base.rs
