eigenlayer_contract_deployer/bindings/core/
i_allocation_manager.rs

1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use IAllocationManager::*;
3
4///Module containing a contract's types and functions.
5/**
6
7```solidity
8library IAllocationManagerTypes {
9    struct AllocateParams { OperatorSet operatorSet; address[] strategies; uint64[] newMagnitudes; }
10    struct Allocation { uint64 currentMagnitude; int128 pendingDiff; uint32 effectBlock; }
11    struct CreateSetParams { uint32 operatorSetId; address[] strategies; }
12    struct DeregisterParams { address operator; address avs; uint32[] operatorSetIds; }
13    struct RegisterParams { address avs; uint32[] operatorSetIds; bytes data; }
14    struct SlashingParams { address operator; uint32 operatorSetId; address[] strategies; uint256[] wadsToSlash; string description; }
15}
16```*/
17#[allow(
18    non_camel_case_types,
19    non_snake_case,
20    clippy::pub_underscore_fields,
21    clippy::style,
22    clippy::empty_structs_with_brackets
23)]
24pub mod IAllocationManagerTypes {
25    use super::*;
26    use alloy::sol_types as alloy_sol_types;
27    #[derive(serde::Serialize, serde::Deserialize)]
28    #[derive()]
29    /**```solidity
30struct AllocateParams { OperatorSet operatorSet; address[] strategies; uint64[] newMagnitudes; }
31```*/
32    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
33    #[derive(Clone, Hash, Debug, Eq, PartialEq)]
34    pub struct AllocateParams {
35        #[allow(missing_docs)]
36        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
37        #[allow(missing_docs)]
38        pub strategies: alloy::sol_types::private::Vec<
39            alloy::sol_types::private::Address,
40        >,
41        #[allow(missing_docs)]
42        pub newMagnitudes: alloy::sol_types::private::Vec<u64>,
43    }
44    #[allow(
45        non_camel_case_types,
46        non_snake_case,
47        clippy::pub_underscore_fields,
48        clippy::style
49    )]
50    const _: () = {
51        use alloy::sol_types as alloy_sol_types;
52        #[doc(hidden)]
53        type UnderlyingSolTuple<'a> = (
54            OperatorSet,
55            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
56            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
57        );
58        #[doc(hidden)]
59        type UnderlyingRustTuple<'a> = (
60            <OperatorSet as alloy::sol_types::SolType>::RustType,
61            alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
62            alloy::sol_types::private::Vec<u64>,
63        );
64        #[cfg(test)]
65        #[allow(dead_code, unreachable_patterns)]
66        fn _type_assertion(
67            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
68        ) {
69            match _t {
70                alloy_sol_types::private::AssertTypeEq::<
71                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
72                >(_) => {}
73            }
74        }
75        #[automatically_derived]
76        #[doc(hidden)]
77        impl ::core::convert::From<AllocateParams> for UnderlyingRustTuple<'_> {
78            fn from(value: AllocateParams) -> Self {
79                (value.operatorSet, value.strategies, value.newMagnitudes)
80            }
81        }
82        #[automatically_derived]
83        #[doc(hidden)]
84        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AllocateParams {
85            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
86                Self {
87                    operatorSet: tuple.0,
88                    strategies: tuple.1,
89                    newMagnitudes: tuple.2,
90                }
91            }
92        }
93        #[automatically_derived]
94        impl alloy_sol_types::SolValue for AllocateParams {
95            type SolType = Self;
96        }
97        #[automatically_derived]
98        impl alloy_sol_types::private::SolTypeValue<Self> for AllocateParams {
99            #[inline]
100            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
101                (
102                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
103                        &self.operatorSet,
104                    ),
105                    <alloy::sol_types::sol_data::Array<
106                        alloy::sol_types::sol_data::Address,
107                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
108                    <alloy::sol_types::sol_data::Array<
109                        alloy::sol_types::sol_data::Uint<64>,
110                    > as alloy_sol_types::SolType>::tokenize(&self.newMagnitudes),
111                )
112            }
113            #[inline]
114            fn stv_abi_encoded_size(&self) -> usize {
115                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
116                    return size;
117                }
118                let tuple = <UnderlyingRustTuple<
119                    '_,
120                > as ::core::convert::From<Self>>::from(self.clone());
121                <UnderlyingSolTuple<
122                    '_,
123                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
124            }
125            #[inline]
126            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
127                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
128            }
129            #[inline]
130            fn stv_abi_encode_packed_to(
131                &self,
132                out: &mut alloy_sol_types::private::Vec<u8>,
133            ) {
134                let tuple = <UnderlyingRustTuple<
135                    '_,
136                > as ::core::convert::From<Self>>::from(self.clone());
137                <UnderlyingSolTuple<
138                    '_,
139                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
140            }
141            #[inline]
142            fn stv_abi_packed_encoded_size(&self) -> usize {
143                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
144                    return size;
145                }
146                let tuple = <UnderlyingRustTuple<
147                    '_,
148                > as ::core::convert::From<Self>>::from(self.clone());
149                <UnderlyingSolTuple<
150                    '_,
151                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
152            }
153        }
154        #[automatically_derived]
155        impl alloy_sol_types::SolType for AllocateParams {
156            type RustType = Self;
157            type Token<'a> = <UnderlyingSolTuple<
158                'a,
159            > as alloy_sol_types::SolType>::Token<'a>;
160            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
161            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
162                '_,
163            > as alloy_sol_types::SolType>::ENCODED_SIZE;
164            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
165                '_,
166            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
167            #[inline]
168            fn valid_token(token: &Self::Token<'_>) -> bool {
169                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
170            }
171            #[inline]
172            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
173                let tuple = <UnderlyingSolTuple<
174                    '_,
175                > as alloy_sol_types::SolType>::detokenize(token);
176                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
177            }
178        }
179        #[automatically_derived]
180        impl alloy_sol_types::SolStruct for AllocateParams {
181            const NAME: &'static str = "AllocateParams";
182            #[inline]
183            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
184                alloy_sol_types::private::Cow::Borrowed(
185                    "AllocateParams(OperatorSet operatorSet,address[] strategies,uint64[] newMagnitudes)",
186                )
187            }
188            #[inline]
189            fn eip712_components() -> alloy_sol_types::private::Vec<
190                alloy_sol_types::private::Cow<'static, str>,
191            > {
192                let mut components = alloy_sol_types::private::Vec::with_capacity(1);
193                components
194                    .push(
195                        <OperatorSet as alloy_sol_types::SolStruct>::eip712_root_type(),
196                    );
197                components
198                    .extend(
199                        <OperatorSet as alloy_sol_types::SolStruct>::eip712_components(),
200                    );
201                components
202            }
203            #[inline]
204            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
205                [
206                    <OperatorSet as alloy_sol_types::SolType>::eip712_data_word(
207                            &self.operatorSet,
208                        )
209                        .0,
210                    <alloy::sol_types::sol_data::Array<
211                        alloy::sol_types::sol_data::Address,
212                    > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
213                        .0,
214                    <alloy::sol_types::sol_data::Array<
215                        alloy::sol_types::sol_data::Uint<64>,
216                    > as alloy_sol_types::SolType>::eip712_data_word(&self.newMagnitudes)
217                        .0,
218                ]
219                    .concat()
220            }
221        }
222        #[automatically_derived]
223        impl alloy_sol_types::EventTopic for AllocateParams {
224            #[inline]
225            fn topic_preimage_length(rust: &Self::RustType) -> usize {
226                0usize
227                    + <OperatorSet as alloy_sol_types::EventTopic>::topic_preimage_length(
228                        &rust.operatorSet,
229                    )
230                    + <alloy::sol_types::sol_data::Array<
231                        alloy::sol_types::sol_data::Address,
232                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
233                        &rust.strategies,
234                    )
235                    + <alloy::sol_types::sol_data::Array<
236                        alloy::sol_types::sol_data::Uint<64>,
237                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
238                        &rust.newMagnitudes,
239                    )
240            }
241            #[inline]
242            fn encode_topic_preimage(
243                rust: &Self::RustType,
244                out: &mut alloy_sol_types::private::Vec<u8>,
245            ) {
246                out.reserve(
247                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
248                );
249                <OperatorSet as alloy_sol_types::EventTopic>::encode_topic_preimage(
250                    &rust.operatorSet,
251                    out,
252                );
253                <alloy::sol_types::sol_data::Array<
254                    alloy::sol_types::sol_data::Address,
255                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
256                    &rust.strategies,
257                    out,
258                );
259                <alloy::sol_types::sol_data::Array<
260                    alloy::sol_types::sol_data::Uint<64>,
261                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
262                    &rust.newMagnitudes,
263                    out,
264                );
265            }
266            #[inline]
267            fn encode_topic(
268                rust: &Self::RustType,
269            ) -> alloy_sol_types::abi::token::WordToken {
270                let mut out = alloy_sol_types::private::Vec::new();
271                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
272                    rust,
273                    &mut out,
274                );
275                alloy_sol_types::abi::token::WordToken(
276                    alloy_sol_types::private::keccak256(out),
277                )
278            }
279        }
280    };
281    #[derive(serde::Serialize, serde::Deserialize)]
282    #[derive(Default, Debug, PartialEq, Eq, Hash)]
283    /**```solidity
284struct Allocation { uint64 currentMagnitude; int128 pendingDiff; uint32 effectBlock; }
285```*/
286    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
287    #[derive(Clone)]
288    pub struct Allocation {
289        #[allow(missing_docs)]
290        pub currentMagnitude: u64,
291        #[allow(missing_docs)]
292        pub pendingDiff: i128,
293        #[allow(missing_docs)]
294        pub effectBlock: u32,
295    }
296    #[allow(
297        non_camel_case_types,
298        non_snake_case,
299        clippy::pub_underscore_fields,
300        clippy::style
301    )]
302    const _: () = {
303        use alloy::sol_types as alloy_sol_types;
304        #[doc(hidden)]
305        type UnderlyingSolTuple<'a> = (
306            alloy::sol_types::sol_data::Uint<64>,
307            alloy::sol_types::sol_data::Int<128>,
308            alloy::sol_types::sol_data::Uint<32>,
309        );
310        #[doc(hidden)]
311        type UnderlyingRustTuple<'a> = (u64, i128, u32);
312        #[cfg(test)]
313        #[allow(dead_code, unreachable_patterns)]
314        fn _type_assertion(
315            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
316        ) {
317            match _t {
318                alloy_sol_types::private::AssertTypeEq::<
319                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
320                >(_) => {}
321            }
322        }
323        #[automatically_derived]
324        #[doc(hidden)]
325        impl ::core::convert::From<Allocation> for UnderlyingRustTuple<'_> {
326            fn from(value: Allocation) -> Self {
327                (value.currentMagnitude, value.pendingDiff, value.effectBlock)
328            }
329        }
330        #[automatically_derived]
331        #[doc(hidden)]
332        impl ::core::convert::From<UnderlyingRustTuple<'_>> for Allocation {
333            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
334                Self {
335                    currentMagnitude: tuple.0,
336                    pendingDiff: tuple.1,
337                    effectBlock: tuple.2,
338                }
339            }
340        }
341        #[automatically_derived]
342        impl alloy_sol_types::SolValue for Allocation {
343            type SolType = Self;
344        }
345        #[automatically_derived]
346        impl alloy_sol_types::private::SolTypeValue<Self> for Allocation {
347            #[inline]
348            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
349                (
350                    <alloy::sol_types::sol_data::Uint<
351                        64,
352                    > as alloy_sol_types::SolType>::tokenize(&self.currentMagnitude),
353                    <alloy::sol_types::sol_data::Int<
354                        128,
355                    > as alloy_sol_types::SolType>::tokenize(&self.pendingDiff),
356                    <alloy::sol_types::sol_data::Uint<
357                        32,
358                    > as alloy_sol_types::SolType>::tokenize(&self.effectBlock),
359                )
360            }
361            #[inline]
362            fn stv_abi_encoded_size(&self) -> usize {
363                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
364                    return size;
365                }
366                let tuple = <UnderlyingRustTuple<
367                    '_,
368                > as ::core::convert::From<Self>>::from(self.clone());
369                <UnderlyingSolTuple<
370                    '_,
371                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
372            }
373            #[inline]
374            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
375                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
376            }
377            #[inline]
378            fn stv_abi_encode_packed_to(
379                &self,
380                out: &mut alloy_sol_types::private::Vec<u8>,
381            ) {
382                let tuple = <UnderlyingRustTuple<
383                    '_,
384                > as ::core::convert::From<Self>>::from(self.clone());
385                <UnderlyingSolTuple<
386                    '_,
387                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
388            }
389            #[inline]
390            fn stv_abi_packed_encoded_size(&self) -> usize {
391                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
392                    return size;
393                }
394                let tuple = <UnderlyingRustTuple<
395                    '_,
396                > as ::core::convert::From<Self>>::from(self.clone());
397                <UnderlyingSolTuple<
398                    '_,
399                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
400            }
401        }
402        #[automatically_derived]
403        impl alloy_sol_types::SolType for Allocation {
404            type RustType = Self;
405            type Token<'a> = <UnderlyingSolTuple<
406                'a,
407            > as alloy_sol_types::SolType>::Token<'a>;
408            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
409            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
410                '_,
411            > as alloy_sol_types::SolType>::ENCODED_SIZE;
412            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
413                '_,
414            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
415            #[inline]
416            fn valid_token(token: &Self::Token<'_>) -> bool {
417                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
418            }
419            #[inline]
420            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
421                let tuple = <UnderlyingSolTuple<
422                    '_,
423                > as alloy_sol_types::SolType>::detokenize(token);
424                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
425            }
426        }
427        #[automatically_derived]
428        impl alloy_sol_types::SolStruct for Allocation {
429            const NAME: &'static str = "Allocation";
430            #[inline]
431            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
432                alloy_sol_types::private::Cow::Borrowed(
433                    "Allocation(uint64 currentMagnitude,int128 pendingDiff,uint32 effectBlock)",
434                )
435            }
436            #[inline]
437            fn eip712_components() -> alloy_sol_types::private::Vec<
438                alloy_sol_types::private::Cow<'static, str>,
439            > {
440                alloy_sol_types::private::Vec::new()
441            }
442            #[inline]
443            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
444                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
445            }
446            #[inline]
447            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
448                [
449                    <alloy::sol_types::sol_data::Uint<
450                        64,
451                    > as alloy_sol_types::SolType>::eip712_data_word(
452                            &self.currentMagnitude,
453                        )
454                        .0,
455                    <alloy::sol_types::sol_data::Int<
456                        128,
457                    > as alloy_sol_types::SolType>::eip712_data_word(&self.pendingDiff)
458                        .0,
459                    <alloy::sol_types::sol_data::Uint<
460                        32,
461                    > as alloy_sol_types::SolType>::eip712_data_word(&self.effectBlock)
462                        .0,
463                ]
464                    .concat()
465            }
466        }
467        #[automatically_derived]
468        impl alloy_sol_types::EventTopic for Allocation {
469            #[inline]
470            fn topic_preimage_length(rust: &Self::RustType) -> usize {
471                0usize
472                    + <alloy::sol_types::sol_data::Uint<
473                        64,
474                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
475                        &rust.currentMagnitude,
476                    )
477                    + <alloy::sol_types::sol_data::Int<
478                        128,
479                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
480                        &rust.pendingDiff,
481                    )
482                    + <alloy::sol_types::sol_data::Uint<
483                        32,
484                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
485                        &rust.effectBlock,
486                    )
487            }
488            #[inline]
489            fn encode_topic_preimage(
490                rust: &Self::RustType,
491                out: &mut alloy_sol_types::private::Vec<u8>,
492            ) {
493                out.reserve(
494                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
495                );
496                <alloy::sol_types::sol_data::Uint<
497                    64,
498                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
499                    &rust.currentMagnitude,
500                    out,
501                );
502                <alloy::sol_types::sol_data::Int<
503                    128,
504                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
505                    &rust.pendingDiff,
506                    out,
507                );
508                <alloy::sol_types::sol_data::Uint<
509                    32,
510                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
511                    &rust.effectBlock,
512                    out,
513                );
514            }
515            #[inline]
516            fn encode_topic(
517                rust: &Self::RustType,
518            ) -> alloy_sol_types::abi::token::WordToken {
519                let mut out = alloy_sol_types::private::Vec::new();
520                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
521                    rust,
522                    &mut out,
523                );
524                alloy_sol_types::abi::token::WordToken(
525                    alloy_sol_types::private::keccak256(out),
526                )
527            }
528        }
529    };
530    #[derive(serde::Serialize, serde::Deserialize)]
531    #[derive(Default, Debug, PartialEq, Eq, Hash)]
532    /**```solidity
533struct CreateSetParams { uint32 operatorSetId; address[] strategies; }
534```*/
535    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
536    #[derive(Clone)]
537    pub struct CreateSetParams {
538        #[allow(missing_docs)]
539        pub operatorSetId: u32,
540        #[allow(missing_docs)]
541        pub strategies: alloy::sol_types::private::Vec<
542            alloy::sol_types::private::Address,
543        >,
544    }
545    #[allow(
546        non_camel_case_types,
547        non_snake_case,
548        clippy::pub_underscore_fields,
549        clippy::style
550    )]
551    const _: () = {
552        use alloy::sol_types as alloy_sol_types;
553        #[doc(hidden)]
554        type UnderlyingSolTuple<'a> = (
555            alloy::sol_types::sol_data::Uint<32>,
556            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
557        );
558        #[doc(hidden)]
559        type UnderlyingRustTuple<'a> = (
560            u32,
561            alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
562        );
563        #[cfg(test)]
564        #[allow(dead_code, unreachable_patterns)]
565        fn _type_assertion(
566            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
567        ) {
568            match _t {
569                alloy_sol_types::private::AssertTypeEq::<
570                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
571                >(_) => {}
572            }
573        }
574        #[automatically_derived]
575        #[doc(hidden)]
576        impl ::core::convert::From<CreateSetParams> for UnderlyingRustTuple<'_> {
577            fn from(value: CreateSetParams) -> Self {
578                (value.operatorSetId, value.strategies)
579            }
580        }
581        #[automatically_derived]
582        #[doc(hidden)]
583        impl ::core::convert::From<UnderlyingRustTuple<'_>> for CreateSetParams {
584            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
585                Self {
586                    operatorSetId: tuple.0,
587                    strategies: tuple.1,
588                }
589            }
590        }
591        #[automatically_derived]
592        impl alloy_sol_types::SolValue for CreateSetParams {
593            type SolType = Self;
594        }
595        #[automatically_derived]
596        impl alloy_sol_types::private::SolTypeValue<Self> for CreateSetParams {
597            #[inline]
598            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
599                (
600                    <alloy::sol_types::sol_data::Uint<
601                        32,
602                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
603                    <alloy::sol_types::sol_data::Array<
604                        alloy::sol_types::sol_data::Address,
605                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
606                )
607            }
608            #[inline]
609            fn stv_abi_encoded_size(&self) -> usize {
610                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
611                    return size;
612                }
613                let tuple = <UnderlyingRustTuple<
614                    '_,
615                > as ::core::convert::From<Self>>::from(self.clone());
616                <UnderlyingSolTuple<
617                    '_,
618                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
619            }
620            #[inline]
621            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
622                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
623            }
624            #[inline]
625            fn stv_abi_encode_packed_to(
626                &self,
627                out: &mut alloy_sol_types::private::Vec<u8>,
628            ) {
629                let tuple = <UnderlyingRustTuple<
630                    '_,
631                > as ::core::convert::From<Self>>::from(self.clone());
632                <UnderlyingSolTuple<
633                    '_,
634                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
635            }
636            #[inline]
637            fn stv_abi_packed_encoded_size(&self) -> usize {
638                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
639                    return size;
640                }
641                let tuple = <UnderlyingRustTuple<
642                    '_,
643                > as ::core::convert::From<Self>>::from(self.clone());
644                <UnderlyingSolTuple<
645                    '_,
646                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
647            }
648        }
649        #[automatically_derived]
650        impl alloy_sol_types::SolType for CreateSetParams {
651            type RustType = Self;
652            type Token<'a> = <UnderlyingSolTuple<
653                'a,
654            > as alloy_sol_types::SolType>::Token<'a>;
655            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
656            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
657                '_,
658            > as alloy_sol_types::SolType>::ENCODED_SIZE;
659            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
660                '_,
661            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
662            #[inline]
663            fn valid_token(token: &Self::Token<'_>) -> bool {
664                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
665            }
666            #[inline]
667            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
668                let tuple = <UnderlyingSolTuple<
669                    '_,
670                > as alloy_sol_types::SolType>::detokenize(token);
671                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
672            }
673        }
674        #[automatically_derived]
675        impl alloy_sol_types::SolStruct for CreateSetParams {
676            const NAME: &'static str = "CreateSetParams";
677            #[inline]
678            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
679                alloy_sol_types::private::Cow::Borrowed(
680                    "CreateSetParams(uint32 operatorSetId,address[] strategies)",
681                )
682            }
683            #[inline]
684            fn eip712_components() -> alloy_sol_types::private::Vec<
685                alloy_sol_types::private::Cow<'static, str>,
686            > {
687                alloy_sol_types::private::Vec::new()
688            }
689            #[inline]
690            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
691                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
692            }
693            #[inline]
694            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
695                [
696                    <alloy::sol_types::sol_data::Uint<
697                        32,
698                    > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorSetId)
699                        .0,
700                    <alloy::sol_types::sol_data::Array<
701                        alloy::sol_types::sol_data::Address,
702                    > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
703                        .0,
704                ]
705                    .concat()
706            }
707        }
708        #[automatically_derived]
709        impl alloy_sol_types::EventTopic for CreateSetParams {
710            #[inline]
711            fn topic_preimage_length(rust: &Self::RustType) -> usize {
712                0usize
713                    + <alloy::sol_types::sol_data::Uint<
714                        32,
715                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
716                        &rust.operatorSetId,
717                    )
718                    + <alloy::sol_types::sol_data::Array<
719                        alloy::sol_types::sol_data::Address,
720                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
721                        &rust.strategies,
722                    )
723            }
724            #[inline]
725            fn encode_topic_preimage(
726                rust: &Self::RustType,
727                out: &mut alloy_sol_types::private::Vec<u8>,
728            ) {
729                out.reserve(
730                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
731                );
732                <alloy::sol_types::sol_data::Uint<
733                    32,
734                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
735                    &rust.operatorSetId,
736                    out,
737                );
738                <alloy::sol_types::sol_data::Array<
739                    alloy::sol_types::sol_data::Address,
740                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
741                    &rust.strategies,
742                    out,
743                );
744            }
745            #[inline]
746            fn encode_topic(
747                rust: &Self::RustType,
748            ) -> alloy_sol_types::abi::token::WordToken {
749                let mut out = alloy_sol_types::private::Vec::new();
750                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
751                    rust,
752                    &mut out,
753                );
754                alloy_sol_types::abi::token::WordToken(
755                    alloy_sol_types::private::keccak256(out),
756                )
757            }
758        }
759    };
760    #[derive(serde::Serialize, serde::Deserialize)]
761    #[derive(Default, Debug, PartialEq, Eq, Hash)]
762    /**```solidity
763struct DeregisterParams { address operator; address avs; uint32[] operatorSetIds; }
764```*/
765    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
766    #[derive(Clone)]
767    pub struct DeregisterParams {
768        #[allow(missing_docs)]
769        pub operator: alloy::sol_types::private::Address,
770        #[allow(missing_docs)]
771        pub avs: alloy::sol_types::private::Address,
772        #[allow(missing_docs)]
773        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
774    }
775    #[allow(
776        non_camel_case_types,
777        non_snake_case,
778        clippy::pub_underscore_fields,
779        clippy::style
780    )]
781    const _: () = {
782        use alloy::sol_types as alloy_sol_types;
783        #[doc(hidden)]
784        type UnderlyingSolTuple<'a> = (
785            alloy::sol_types::sol_data::Address,
786            alloy::sol_types::sol_data::Address,
787            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
788        );
789        #[doc(hidden)]
790        type UnderlyingRustTuple<'a> = (
791            alloy::sol_types::private::Address,
792            alloy::sol_types::private::Address,
793            alloy::sol_types::private::Vec<u32>,
794        );
795        #[cfg(test)]
796        #[allow(dead_code, unreachable_patterns)]
797        fn _type_assertion(
798            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
799        ) {
800            match _t {
801                alloy_sol_types::private::AssertTypeEq::<
802                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
803                >(_) => {}
804            }
805        }
806        #[automatically_derived]
807        #[doc(hidden)]
808        impl ::core::convert::From<DeregisterParams> for UnderlyingRustTuple<'_> {
809            fn from(value: DeregisterParams) -> Self {
810                (value.operator, value.avs, value.operatorSetIds)
811            }
812        }
813        #[automatically_derived]
814        #[doc(hidden)]
815        impl ::core::convert::From<UnderlyingRustTuple<'_>> for DeregisterParams {
816            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
817                Self {
818                    operator: tuple.0,
819                    avs: tuple.1,
820                    operatorSetIds: tuple.2,
821                }
822            }
823        }
824        #[automatically_derived]
825        impl alloy_sol_types::SolValue for DeregisterParams {
826            type SolType = Self;
827        }
828        #[automatically_derived]
829        impl alloy_sol_types::private::SolTypeValue<Self> for DeregisterParams {
830            #[inline]
831            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
832                (
833                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
834                        &self.operator,
835                    ),
836                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
837                        &self.avs,
838                    ),
839                    <alloy::sol_types::sol_data::Array<
840                        alloy::sol_types::sol_data::Uint<32>,
841                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
842                )
843            }
844            #[inline]
845            fn stv_abi_encoded_size(&self) -> usize {
846                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
847                    return size;
848                }
849                let tuple = <UnderlyingRustTuple<
850                    '_,
851                > as ::core::convert::From<Self>>::from(self.clone());
852                <UnderlyingSolTuple<
853                    '_,
854                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
855            }
856            #[inline]
857            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
858                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
859            }
860            #[inline]
861            fn stv_abi_encode_packed_to(
862                &self,
863                out: &mut alloy_sol_types::private::Vec<u8>,
864            ) {
865                let tuple = <UnderlyingRustTuple<
866                    '_,
867                > as ::core::convert::From<Self>>::from(self.clone());
868                <UnderlyingSolTuple<
869                    '_,
870                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
871            }
872            #[inline]
873            fn stv_abi_packed_encoded_size(&self) -> usize {
874                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
875                    return size;
876                }
877                let tuple = <UnderlyingRustTuple<
878                    '_,
879                > as ::core::convert::From<Self>>::from(self.clone());
880                <UnderlyingSolTuple<
881                    '_,
882                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
883            }
884        }
885        #[automatically_derived]
886        impl alloy_sol_types::SolType for DeregisterParams {
887            type RustType = Self;
888            type Token<'a> = <UnderlyingSolTuple<
889                'a,
890            > as alloy_sol_types::SolType>::Token<'a>;
891            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
892            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
893                '_,
894            > as alloy_sol_types::SolType>::ENCODED_SIZE;
895            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
896                '_,
897            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
898            #[inline]
899            fn valid_token(token: &Self::Token<'_>) -> bool {
900                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
901            }
902            #[inline]
903            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
904                let tuple = <UnderlyingSolTuple<
905                    '_,
906                > as alloy_sol_types::SolType>::detokenize(token);
907                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
908            }
909        }
910        #[automatically_derived]
911        impl alloy_sol_types::SolStruct for DeregisterParams {
912            const NAME: &'static str = "DeregisterParams";
913            #[inline]
914            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
915                alloy_sol_types::private::Cow::Borrowed(
916                    "DeregisterParams(address operator,address avs,uint32[] operatorSetIds)",
917                )
918            }
919            #[inline]
920            fn eip712_components() -> alloy_sol_types::private::Vec<
921                alloy_sol_types::private::Cow<'static, str>,
922            > {
923                alloy_sol_types::private::Vec::new()
924            }
925            #[inline]
926            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
927                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
928            }
929            #[inline]
930            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
931                [
932                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
933                            &self.operator,
934                        )
935                        .0,
936                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
937                            &self.avs,
938                        )
939                        .0,
940                    <alloy::sol_types::sol_data::Array<
941                        alloy::sol_types::sol_data::Uint<32>,
942                    > as alloy_sol_types::SolType>::eip712_data_word(
943                            &self.operatorSetIds,
944                        )
945                        .0,
946                ]
947                    .concat()
948            }
949        }
950        #[automatically_derived]
951        impl alloy_sol_types::EventTopic for DeregisterParams {
952            #[inline]
953            fn topic_preimage_length(rust: &Self::RustType) -> usize {
954                0usize
955                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
956                        &rust.operator,
957                    )
958                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
959                        &rust.avs,
960                    )
961                    + <alloy::sol_types::sol_data::Array<
962                        alloy::sol_types::sol_data::Uint<32>,
963                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
964                        &rust.operatorSetIds,
965                    )
966            }
967            #[inline]
968            fn encode_topic_preimage(
969                rust: &Self::RustType,
970                out: &mut alloy_sol_types::private::Vec<u8>,
971            ) {
972                out.reserve(
973                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
974                );
975                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
976                    &rust.operator,
977                    out,
978                );
979                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
980                    &rust.avs,
981                    out,
982                );
983                <alloy::sol_types::sol_data::Array<
984                    alloy::sol_types::sol_data::Uint<32>,
985                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
986                    &rust.operatorSetIds,
987                    out,
988                );
989            }
990            #[inline]
991            fn encode_topic(
992                rust: &Self::RustType,
993            ) -> alloy_sol_types::abi::token::WordToken {
994                let mut out = alloy_sol_types::private::Vec::new();
995                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
996                    rust,
997                    &mut out,
998                );
999                alloy_sol_types::abi::token::WordToken(
1000                    alloy_sol_types::private::keccak256(out),
1001                )
1002            }
1003        }
1004    };
1005    #[derive(serde::Serialize, serde::Deserialize)]
1006    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1007    /**```solidity
1008struct RegisterParams { address avs; uint32[] operatorSetIds; bytes data; }
1009```*/
1010    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1011    #[derive(Clone)]
1012    pub struct RegisterParams {
1013        #[allow(missing_docs)]
1014        pub avs: alloy::sol_types::private::Address,
1015        #[allow(missing_docs)]
1016        pub operatorSetIds: alloy::sol_types::private::Vec<u32>,
1017        #[allow(missing_docs)]
1018        pub data: alloy::sol_types::private::Bytes,
1019    }
1020    #[allow(
1021        non_camel_case_types,
1022        non_snake_case,
1023        clippy::pub_underscore_fields,
1024        clippy::style
1025    )]
1026    const _: () = {
1027        use alloy::sol_types as alloy_sol_types;
1028        #[doc(hidden)]
1029        type UnderlyingSolTuple<'a> = (
1030            alloy::sol_types::sol_data::Address,
1031            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<32>>,
1032            alloy::sol_types::sol_data::Bytes,
1033        );
1034        #[doc(hidden)]
1035        type UnderlyingRustTuple<'a> = (
1036            alloy::sol_types::private::Address,
1037            alloy::sol_types::private::Vec<u32>,
1038            alloy::sol_types::private::Bytes,
1039        );
1040        #[cfg(test)]
1041        #[allow(dead_code, unreachable_patterns)]
1042        fn _type_assertion(
1043            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1044        ) {
1045            match _t {
1046                alloy_sol_types::private::AssertTypeEq::<
1047                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1048                >(_) => {}
1049            }
1050        }
1051        #[automatically_derived]
1052        #[doc(hidden)]
1053        impl ::core::convert::From<RegisterParams> for UnderlyingRustTuple<'_> {
1054            fn from(value: RegisterParams) -> Self {
1055                (value.avs, value.operatorSetIds, value.data)
1056            }
1057        }
1058        #[automatically_derived]
1059        #[doc(hidden)]
1060        impl ::core::convert::From<UnderlyingRustTuple<'_>> for RegisterParams {
1061            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1062                Self {
1063                    avs: tuple.0,
1064                    operatorSetIds: tuple.1,
1065                    data: tuple.2,
1066                }
1067            }
1068        }
1069        #[automatically_derived]
1070        impl alloy_sol_types::SolValue for RegisterParams {
1071            type SolType = Self;
1072        }
1073        #[automatically_derived]
1074        impl alloy_sol_types::private::SolTypeValue<Self> for RegisterParams {
1075            #[inline]
1076            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1077                (
1078                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1079                        &self.avs,
1080                    ),
1081                    <alloy::sol_types::sol_data::Array<
1082                        alloy::sol_types::sol_data::Uint<32>,
1083                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetIds),
1084                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1085                        &self.data,
1086                    ),
1087                )
1088            }
1089            #[inline]
1090            fn stv_abi_encoded_size(&self) -> usize {
1091                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1092                    return size;
1093                }
1094                let tuple = <UnderlyingRustTuple<
1095                    '_,
1096                > as ::core::convert::From<Self>>::from(self.clone());
1097                <UnderlyingSolTuple<
1098                    '_,
1099                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1100            }
1101            #[inline]
1102            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1103                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1104            }
1105            #[inline]
1106            fn stv_abi_encode_packed_to(
1107                &self,
1108                out: &mut alloy_sol_types::private::Vec<u8>,
1109            ) {
1110                let tuple = <UnderlyingRustTuple<
1111                    '_,
1112                > as ::core::convert::From<Self>>::from(self.clone());
1113                <UnderlyingSolTuple<
1114                    '_,
1115                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1116            }
1117            #[inline]
1118            fn stv_abi_packed_encoded_size(&self) -> usize {
1119                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1120                    return size;
1121                }
1122                let tuple = <UnderlyingRustTuple<
1123                    '_,
1124                > as ::core::convert::From<Self>>::from(self.clone());
1125                <UnderlyingSolTuple<
1126                    '_,
1127                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1128            }
1129        }
1130        #[automatically_derived]
1131        impl alloy_sol_types::SolType for RegisterParams {
1132            type RustType = Self;
1133            type Token<'a> = <UnderlyingSolTuple<
1134                'a,
1135            > as alloy_sol_types::SolType>::Token<'a>;
1136            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1137            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1138                '_,
1139            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1140            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1141                '_,
1142            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1143            #[inline]
1144            fn valid_token(token: &Self::Token<'_>) -> bool {
1145                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1146            }
1147            #[inline]
1148            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1149                let tuple = <UnderlyingSolTuple<
1150                    '_,
1151                > as alloy_sol_types::SolType>::detokenize(token);
1152                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1153            }
1154        }
1155        #[automatically_derived]
1156        impl alloy_sol_types::SolStruct for RegisterParams {
1157            const NAME: &'static str = "RegisterParams";
1158            #[inline]
1159            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1160                alloy_sol_types::private::Cow::Borrowed(
1161                    "RegisterParams(address avs,uint32[] operatorSetIds,bytes data)",
1162                )
1163            }
1164            #[inline]
1165            fn eip712_components() -> alloy_sol_types::private::Vec<
1166                alloy_sol_types::private::Cow<'static, str>,
1167            > {
1168                alloy_sol_types::private::Vec::new()
1169            }
1170            #[inline]
1171            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1172                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1173            }
1174            #[inline]
1175            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1176                [
1177                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1178                            &self.avs,
1179                        )
1180                        .0,
1181                    <alloy::sol_types::sol_data::Array<
1182                        alloy::sol_types::sol_data::Uint<32>,
1183                    > as alloy_sol_types::SolType>::eip712_data_word(
1184                            &self.operatorSetIds,
1185                        )
1186                        .0,
1187                    <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::eip712_data_word(
1188                            &self.data,
1189                        )
1190                        .0,
1191                ]
1192                    .concat()
1193            }
1194        }
1195        #[automatically_derived]
1196        impl alloy_sol_types::EventTopic for RegisterParams {
1197            #[inline]
1198            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1199                0usize
1200                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1201                        &rust.avs,
1202                    )
1203                    + <alloy::sol_types::sol_data::Array<
1204                        alloy::sol_types::sol_data::Uint<32>,
1205                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1206                        &rust.operatorSetIds,
1207                    )
1208                    + <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::topic_preimage_length(
1209                        &rust.data,
1210                    )
1211            }
1212            #[inline]
1213            fn encode_topic_preimage(
1214                rust: &Self::RustType,
1215                out: &mut alloy_sol_types::private::Vec<u8>,
1216            ) {
1217                out.reserve(
1218                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1219                );
1220                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1221                    &rust.avs,
1222                    out,
1223                );
1224                <alloy::sol_types::sol_data::Array<
1225                    alloy::sol_types::sol_data::Uint<32>,
1226                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1227                    &rust.operatorSetIds,
1228                    out,
1229                );
1230                <alloy::sol_types::sol_data::Bytes as alloy_sol_types::EventTopic>::encode_topic_preimage(
1231                    &rust.data,
1232                    out,
1233                );
1234            }
1235            #[inline]
1236            fn encode_topic(
1237                rust: &Self::RustType,
1238            ) -> alloy_sol_types::abi::token::WordToken {
1239                let mut out = alloy_sol_types::private::Vec::new();
1240                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1241                    rust,
1242                    &mut out,
1243                );
1244                alloy_sol_types::abi::token::WordToken(
1245                    alloy_sol_types::private::keccak256(out),
1246                )
1247            }
1248        }
1249    };
1250    #[derive(serde::Serialize, serde::Deserialize)]
1251    #[derive(Default, Debug, PartialEq, Eq, Hash)]
1252    /**```solidity
1253struct SlashingParams { address operator; uint32 operatorSetId; address[] strategies; uint256[] wadsToSlash; string description; }
1254```*/
1255    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1256    #[derive(Clone)]
1257    pub struct SlashingParams {
1258        #[allow(missing_docs)]
1259        pub operator: alloy::sol_types::private::Address,
1260        #[allow(missing_docs)]
1261        pub operatorSetId: u32,
1262        #[allow(missing_docs)]
1263        pub strategies: alloy::sol_types::private::Vec<
1264            alloy::sol_types::private::Address,
1265        >,
1266        #[allow(missing_docs)]
1267        pub wadsToSlash: alloy::sol_types::private::Vec<
1268            alloy::sol_types::private::primitives::aliases::U256,
1269        >,
1270        #[allow(missing_docs)]
1271        pub description: alloy::sol_types::private::String,
1272    }
1273    #[allow(
1274        non_camel_case_types,
1275        non_snake_case,
1276        clippy::pub_underscore_fields,
1277        clippy::style
1278    )]
1279    const _: () = {
1280        use alloy::sol_types as alloy_sol_types;
1281        #[doc(hidden)]
1282        type UnderlyingSolTuple<'a> = (
1283            alloy::sol_types::sol_data::Address,
1284            alloy::sol_types::sol_data::Uint<32>,
1285            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
1286            alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
1287            alloy::sol_types::sol_data::String,
1288        );
1289        #[doc(hidden)]
1290        type UnderlyingRustTuple<'a> = (
1291            alloy::sol_types::private::Address,
1292            u32,
1293            alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1294            alloy::sol_types::private::Vec<
1295                alloy::sol_types::private::primitives::aliases::U256,
1296            >,
1297            alloy::sol_types::private::String,
1298        );
1299        #[cfg(test)]
1300        #[allow(dead_code, unreachable_patterns)]
1301        fn _type_assertion(
1302            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1303        ) {
1304            match _t {
1305                alloy_sol_types::private::AssertTypeEq::<
1306                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1307                >(_) => {}
1308            }
1309        }
1310        #[automatically_derived]
1311        #[doc(hidden)]
1312        impl ::core::convert::From<SlashingParams> for UnderlyingRustTuple<'_> {
1313            fn from(value: SlashingParams) -> Self {
1314                (
1315                    value.operator,
1316                    value.operatorSetId,
1317                    value.strategies,
1318                    value.wadsToSlash,
1319                    value.description,
1320                )
1321            }
1322        }
1323        #[automatically_derived]
1324        #[doc(hidden)]
1325        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SlashingParams {
1326            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1327                Self {
1328                    operator: tuple.0,
1329                    operatorSetId: tuple.1,
1330                    strategies: tuple.2,
1331                    wadsToSlash: tuple.3,
1332                    description: tuple.4,
1333                }
1334            }
1335        }
1336        #[automatically_derived]
1337        impl alloy_sol_types::SolValue for SlashingParams {
1338            type SolType = Self;
1339        }
1340        #[automatically_derived]
1341        impl alloy_sol_types::private::SolTypeValue<Self> for SlashingParams {
1342            #[inline]
1343            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
1344                (
1345                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1346                        &self.operator,
1347                    ),
1348                    <alloy::sol_types::sol_data::Uint<
1349                        32,
1350                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
1351                    <alloy::sol_types::sol_data::Array<
1352                        alloy::sol_types::sol_data::Address,
1353                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
1354                    <alloy::sol_types::sol_data::Array<
1355                        alloy::sol_types::sol_data::Uint<256>,
1356                    > as alloy_sol_types::SolType>::tokenize(&self.wadsToSlash),
1357                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1358                        &self.description,
1359                    ),
1360                )
1361            }
1362            #[inline]
1363            fn stv_abi_encoded_size(&self) -> usize {
1364                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
1365                    return size;
1366                }
1367                let tuple = <UnderlyingRustTuple<
1368                    '_,
1369                > as ::core::convert::From<Self>>::from(self.clone());
1370                <UnderlyingSolTuple<
1371                    '_,
1372                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
1373            }
1374            #[inline]
1375            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
1376                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
1377            }
1378            #[inline]
1379            fn stv_abi_encode_packed_to(
1380                &self,
1381                out: &mut alloy_sol_types::private::Vec<u8>,
1382            ) {
1383                let tuple = <UnderlyingRustTuple<
1384                    '_,
1385                > as ::core::convert::From<Self>>::from(self.clone());
1386                <UnderlyingSolTuple<
1387                    '_,
1388                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
1389            }
1390            #[inline]
1391            fn stv_abi_packed_encoded_size(&self) -> usize {
1392                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
1393                    return size;
1394                }
1395                let tuple = <UnderlyingRustTuple<
1396                    '_,
1397                > as ::core::convert::From<Self>>::from(self.clone());
1398                <UnderlyingSolTuple<
1399                    '_,
1400                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
1401            }
1402        }
1403        #[automatically_derived]
1404        impl alloy_sol_types::SolType for SlashingParams {
1405            type RustType = Self;
1406            type Token<'a> = <UnderlyingSolTuple<
1407                'a,
1408            > as alloy_sol_types::SolType>::Token<'a>;
1409            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
1410            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1411                '_,
1412            > as alloy_sol_types::SolType>::ENCODED_SIZE;
1413            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
1414                '_,
1415            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
1416            #[inline]
1417            fn valid_token(token: &Self::Token<'_>) -> bool {
1418                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
1419            }
1420            #[inline]
1421            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
1422                let tuple = <UnderlyingSolTuple<
1423                    '_,
1424                > as alloy_sol_types::SolType>::detokenize(token);
1425                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
1426            }
1427        }
1428        #[automatically_derived]
1429        impl alloy_sol_types::SolStruct for SlashingParams {
1430            const NAME: &'static str = "SlashingParams";
1431            #[inline]
1432            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
1433                alloy_sol_types::private::Cow::Borrowed(
1434                    "SlashingParams(address operator,uint32 operatorSetId,address[] strategies,uint256[] wadsToSlash,string description)",
1435                )
1436            }
1437            #[inline]
1438            fn eip712_components() -> alloy_sol_types::private::Vec<
1439                alloy_sol_types::private::Cow<'static, str>,
1440            > {
1441                alloy_sol_types::private::Vec::new()
1442            }
1443            #[inline]
1444            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
1445                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
1446            }
1447            #[inline]
1448            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
1449                [
1450                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
1451                            &self.operator,
1452                        )
1453                        .0,
1454                    <alloy::sol_types::sol_data::Uint<
1455                        32,
1456                    > as alloy_sol_types::SolType>::eip712_data_word(&self.operatorSetId)
1457                        .0,
1458                    <alloy::sol_types::sol_data::Array<
1459                        alloy::sol_types::sol_data::Address,
1460                    > as alloy_sol_types::SolType>::eip712_data_word(&self.strategies)
1461                        .0,
1462                    <alloy::sol_types::sol_data::Array<
1463                        alloy::sol_types::sol_data::Uint<256>,
1464                    > as alloy_sol_types::SolType>::eip712_data_word(&self.wadsToSlash)
1465                        .0,
1466                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::eip712_data_word(
1467                            &self.description,
1468                        )
1469                        .0,
1470                ]
1471                    .concat()
1472            }
1473        }
1474        #[automatically_derived]
1475        impl alloy_sol_types::EventTopic for SlashingParams {
1476            #[inline]
1477            fn topic_preimage_length(rust: &Self::RustType) -> usize {
1478                0usize
1479                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
1480                        &rust.operator,
1481                    )
1482                    + <alloy::sol_types::sol_data::Uint<
1483                        32,
1484                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1485                        &rust.operatorSetId,
1486                    )
1487                    + <alloy::sol_types::sol_data::Array<
1488                        alloy::sol_types::sol_data::Address,
1489                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1490                        &rust.strategies,
1491                    )
1492                    + <alloy::sol_types::sol_data::Array<
1493                        alloy::sol_types::sol_data::Uint<256>,
1494                    > as alloy_sol_types::EventTopic>::topic_preimage_length(
1495                        &rust.wadsToSlash,
1496                    )
1497                    + <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::topic_preimage_length(
1498                        &rust.description,
1499                    )
1500            }
1501            #[inline]
1502            fn encode_topic_preimage(
1503                rust: &Self::RustType,
1504                out: &mut alloy_sol_types::private::Vec<u8>,
1505            ) {
1506                out.reserve(
1507                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
1508                );
1509                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
1510                    &rust.operator,
1511                    out,
1512                );
1513                <alloy::sol_types::sol_data::Uint<
1514                    32,
1515                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1516                    &rust.operatorSetId,
1517                    out,
1518                );
1519                <alloy::sol_types::sol_data::Array<
1520                    alloy::sol_types::sol_data::Address,
1521                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1522                    &rust.strategies,
1523                    out,
1524                );
1525                <alloy::sol_types::sol_data::Array<
1526                    alloy::sol_types::sol_data::Uint<256>,
1527                > as alloy_sol_types::EventTopic>::encode_topic_preimage(
1528                    &rust.wadsToSlash,
1529                    out,
1530                );
1531                <alloy::sol_types::sol_data::String as alloy_sol_types::EventTopic>::encode_topic_preimage(
1532                    &rust.description,
1533                    out,
1534                );
1535            }
1536            #[inline]
1537            fn encode_topic(
1538                rust: &Self::RustType,
1539            ) -> alloy_sol_types::abi::token::WordToken {
1540                let mut out = alloy_sol_types::private::Vec::new();
1541                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
1542                    rust,
1543                    &mut out,
1544                );
1545                alloy_sol_types::abi::token::WordToken(
1546                    alloy_sol_types::private::keccak256(out),
1547                )
1548            }
1549        }
1550    };
1551    use alloy::contract as alloy_contract;
1552    /**Creates a new wrapper around an on-chain [`IAllocationManagerTypes`](self) contract instance.
1553
1554See the [wrapper's documentation](`IAllocationManagerTypesInstance`) for more details.*/
1555    #[inline]
1556    pub const fn new<
1557        P: alloy_contract::private::Provider<N>,
1558        N: alloy_contract::private::Network,
1559    >(
1560        address: alloy_sol_types::private::Address,
1561        provider: P,
1562    ) -> IAllocationManagerTypesInstance<P, N> {
1563        IAllocationManagerTypesInstance::<P, N>::new(address, provider)
1564    }
1565    /**A [`IAllocationManagerTypes`](self) instance.
1566
1567Contains type-safe methods for interacting with an on-chain instance of the
1568[`IAllocationManagerTypes`](self) contract located at a given `address`, using a given
1569provider `P`.
1570
1571If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1572documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1573be used to deploy a new instance of the contract.
1574
1575See the [module-level documentation](self) for all the available methods.*/
1576    #[derive(Clone)]
1577    pub struct IAllocationManagerTypesInstance<
1578        P,
1579        N = alloy_contract::private::Ethereum,
1580    > {
1581        address: alloy_sol_types::private::Address,
1582        provider: P,
1583        _network: ::core::marker::PhantomData<N>,
1584    }
1585    #[automatically_derived]
1586    impl<P, N> ::core::fmt::Debug for IAllocationManagerTypesInstance<P, N> {
1587        #[inline]
1588        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1589            f.debug_tuple("IAllocationManagerTypesInstance")
1590                .field(&self.address)
1591                .finish()
1592        }
1593    }
1594    /// Instantiation and getters/setters.
1595    #[automatically_derived]
1596    impl<
1597        P: alloy_contract::private::Provider<N>,
1598        N: alloy_contract::private::Network,
1599    > IAllocationManagerTypesInstance<P, N> {
1600        /**Creates a new wrapper around an on-chain [`IAllocationManagerTypes`](self) contract instance.
1601
1602See the [wrapper's documentation](`IAllocationManagerTypesInstance`) for more details.*/
1603        #[inline]
1604        pub const fn new(
1605            address: alloy_sol_types::private::Address,
1606            provider: P,
1607        ) -> Self {
1608            Self {
1609                address,
1610                provider,
1611                _network: ::core::marker::PhantomData,
1612            }
1613        }
1614        /// Returns a reference to the address.
1615        #[inline]
1616        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1617            &self.address
1618        }
1619        /// Sets the address.
1620        #[inline]
1621        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1622            self.address = address;
1623        }
1624        /// Sets the address and returns `self`.
1625        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1626            self.set_address(address);
1627            self
1628        }
1629        /// Returns a reference to the provider.
1630        #[inline]
1631        pub const fn provider(&self) -> &P {
1632            &self.provider
1633        }
1634    }
1635    impl<P: ::core::clone::Clone, N> IAllocationManagerTypesInstance<&P, N> {
1636        /// Clones the provider and returns a new instance with the cloned provider.
1637        #[inline]
1638        pub fn with_cloned_provider(self) -> IAllocationManagerTypesInstance<P, N> {
1639            IAllocationManagerTypesInstance {
1640                address: self.address,
1641                provider: ::core::clone::Clone::clone(&self.provider),
1642                _network: ::core::marker::PhantomData,
1643            }
1644        }
1645    }
1646    /// Function calls.
1647    #[automatically_derived]
1648    impl<
1649        P: alloy_contract::private::Provider<N>,
1650        N: alloy_contract::private::Network,
1651    > IAllocationManagerTypesInstance<P, N> {
1652        /// Creates a new call builder using this contract instance's provider and address.
1653        ///
1654        /// Note that the call can be any function call, not just those defined in this
1655        /// contract. Prefer using the other methods for building type-safe contract calls.
1656        pub fn call_builder<C: alloy_sol_types::SolCall>(
1657            &self,
1658            call: &C,
1659        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1660            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1661        }
1662    }
1663    /// Event filters.
1664    #[automatically_derived]
1665    impl<
1666        P: alloy_contract::private::Provider<N>,
1667        N: alloy_contract::private::Network,
1668    > IAllocationManagerTypesInstance<P, N> {
1669        /// Creates a new event filter using this contract instance's provider and address.
1670        ///
1671        /// Note that the type can be any event, not just those defined in this contract.
1672        /// Prefer using the other methods for building type-safe event filters.
1673        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1674            &self,
1675        ) -> alloy_contract::Event<&P, E, N> {
1676            alloy_contract::Event::new_sol(&self.provider, &self.address)
1677        }
1678    }
1679}
1680/**
1681
1682Generated by the following Solidity interface...
1683```solidity
1684library IAllocationManagerTypes {
1685    struct AllocateParams {
1686        OperatorSet operatorSet;
1687        address[] strategies;
1688        uint64[] newMagnitudes;
1689    }
1690    struct Allocation {
1691        uint64 currentMagnitude;
1692        int128 pendingDiff;
1693        uint32 effectBlock;
1694    }
1695    struct CreateSetParams {
1696        uint32 operatorSetId;
1697        address[] strategies;
1698    }
1699    struct DeregisterParams {
1700        address operator;
1701        address avs;
1702        uint32[] operatorSetIds;
1703    }
1704    struct RegisterParams {
1705        address avs;
1706        uint32[] operatorSetIds;
1707        bytes data;
1708    }
1709    struct SlashingParams {
1710        address operator;
1711        uint32 operatorSetId;
1712        address[] strategies;
1713        uint256[] wadsToSlash;
1714        string description;
1715    }
1716}
1717
1718interface IAllocationManager {
1719    struct OperatorSet {
1720        address avs;
1721        uint32 id;
1722    }
1723
1724    error AlreadyMemberOfSet();
1725    error InputArrayLengthMismatch();
1726    error InsufficientMagnitude();
1727    error InvalidAVSRegistrar();
1728    error InvalidCaller();
1729    error InvalidOperator();
1730    error InvalidOperatorSet();
1731    error InvalidWadToSlash();
1732    error ModificationAlreadyPending();
1733    error NonexistentAVSMetadata();
1734    error NotMemberOfSet();
1735    error OperatorNotSlashable();
1736    error SameMagnitude();
1737    error StrategiesMustBeInAscendingOrder();
1738    error StrategyAlreadyInOperatorSet();
1739    error StrategyNotInOperatorSet();
1740    error UninitializedAllocationDelay();
1741
1742    event AVSMetadataURIUpdated(address indexed avs, string metadataURI);
1743    event AVSRegistrarSet(address avs, address registrar);
1744    event AllocationDelaySet(address operator, uint32 delay, uint32 effectBlock);
1745    event AllocationUpdated(address operator, OperatorSet operatorSet, address strategy, uint64 magnitude, uint32 effectBlock);
1746    event EncumberedMagnitudeUpdated(address operator, address strategy, uint64 encumberedMagnitude);
1747    event MaxMagnitudeUpdated(address operator, address strategy, uint64 maxMagnitude);
1748    event OperatorAddedToOperatorSet(address indexed operator, OperatorSet operatorSet);
1749    event OperatorRemovedFromOperatorSet(address indexed operator, OperatorSet operatorSet);
1750    event OperatorSetCreated(OperatorSet operatorSet);
1751    event OperatorSlashed(address operator, OperatorSet operatorSet, address[] strategies, uint256[] wadSlashed, string description);
1752    event StrategyAddedToOperatorSet(OperatorSet operatorSet, address strategy);
1753    event StrategyRemovedFromOperatorSet(OperatorSet operatorSet, address strategy);
1754
1755    function addStrategiesToOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
1756    function clearDeallocationQueue(address operator, address[] memory strategies, uint16[] memory numToClear) external;
1757    function createOperatorSets(address avs, IAllocationManagerTypes.CreateSetParams[] memory params) external;
1758    function deregisterFromOperatorSets(IAllocationManagerTypes.DeregisterParams memory params) external;
1759    function getAVSRegistrar(address avs) external view returns (address);
1760    function getAllocatableMagnitude(address operator, address strategy) external view returns (uint64);
1761    function getAllocatedSets(address operator) external view returns (OperatorSet[] memory);
1762    function getAllocatedStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies) external view returns (uint256[][] memory slashableStake);
1763    function getAllocatedStrategies(address operator, OperatorSet memory operatorSet) external view returns (address[] memory);
1764    function getAllocation(address operator, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation memory);
1765    function getAllocationDelay(address operator) external view returns (bool isSet, uint32 delay);
1766    function getAllocations(address[] memory operators, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation[] memory);
1767    function getEncumberedMagnitude(address operator, address strategy) external view returns (uint64);
1768    function getMaxMagnitude(address operator, address strategy) external view returns (uint64);
1769    function getMaxMagnitudes(address[] memory operators, address strategy) external view returns (uint64[] memory);
1770    function getMaxMagnitudes(address operator, address[] memory strategies) external view returns (uint64[] memory);
1771    function getMaxMagnitudesAtBlock(address operator, address[] memory strategies, uint32 blockNumber) external view returns (uint64[] memory);
1772    function getMemberCount(OperatorSet memory operatorSet) external view returns (uint256);
1773    function getMembers(OperatorSet memory operatorSet) external view returns (address[] memory operators);
1774    function getMinimumSlashableStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies, uint32 futureBlock) external view returns (uint256[][] memory slashableStake);
1775    function getOperatorSetCount(address avs) external view returns (uint256);
1776    function getRegisteredSets(address operator) external view returns (OperatorSet[] memory operatorSets);
1777    function getStrategiesInOperatorSet(OperatorSet memory operatorSet) external view returns (address[] memory strategies);
1778    function getStrategyAllocations(address operator, address strategy) external view returns (OperatorSet[] memory, IAllocationManagerTypes.Allocation[] memory);
1779    function initialize(address initialOwner, uint256 initialPausedStatus) external;
1780    function isMemberOfOperatorSet(address operator, OperatorSet memory operatorSet) external view returns (bool);
1781    function isOperatorSet(OperatorSet memory operatorSet) external view returns (bool);
1782    function isOperatorSlashable(address operator, OperatorSet memory operatorSet) external view returns (bool);
1783    function modifyAllocations(address operator, IAllocationManagerTypes.AllocateParams[] memory params) external;
1784    function registerForOperatorSets(address operator, IAllocationManagerTypes.RegisterParams memory params) external;
1785    function removeStrategiesFromOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
1786    function setAVSRegistrar(address avs, address registrar) external;
1787    function setAllocationDelay(address operator, uint32 delay) external;
1788    function slashOperator(address avs, IAllocationManagerTypes.SlashingParams memory params) external;
1789    function updateAVSMetadataURI(address avs, string memory metadataURI) external;
1790    function version() external view returns (string memory);
1791}
1792```
1793
1794...which was generated by the following JSON ABI:
1795```json
1796[
1797  {
1798    "type": "function",
1799    "name": "addStrategiesToOperatorSet",
1800    "inputs": [
1801      {
1802        "name": "avs",
1803        "type": "address",
1804        "internalType": "address"
1805      },
1806      {
1807        "name": "operatorSetId",
1808        "type": "uint32",
1809        "internalType": "uint32"
1810      },
1811      {
1812        "name": "strategies",
1813        "type": "address[]",
1814        "internalType": "contract IStrategy[]"
1815      }
1816    ],
1817    "outputs": [],
1818    "stateMutability": "nonpayable"
1819  },
1820  {
1821    "type": "function",
1822    "name": "clearDeallocationQueue",
1823    "inputs": [
1824      {
1825        "name": "operator",
1826        "type": "address",
1827        "internalType": "address"
1828      },
1829      {
1830        "name": "strategies",
1831        "type": "address[]",
1832        "internalType": "contract IStrategy[]"
1833      },
1834      {
1835        "name": "numToClear",
1836        "type": "uint16[]",
1837        "internalType": "uint16[]"
1838      }
1839    ],
1840    "outputs": [],
1841    "stateMutability": "nonpayable"
1842  },
1843  {
1844    "type": "function",
1845    "name": "createOperatorSets",
1846    "inputs": [
1847      {
1848        "name": "avs",
1849        "type": "address",
1850        "internalType": "address"
1851      },
1852      {
1853        "name": "params",
1854        "type": "tuple[]",
1855        "internalType": "struct IAllocationManagerTypes.CreateSetParams[]",
1856        "components": [
1857          {
1858            "name": "operatorSetId",
1859            "type": "uint32",
1860            "internalType": "uint32"
1861          },
1862          {
1863            "name": "strategies",
1864            "type": "address[]",
1865            "internalType": "contract IStrategy[]"
1866          }
1867        ]
1868      }
1869    ],
1870    "outputs": [],
1871    "stateMutability": "nonpayable"
1872  },
1873  {
1874    "type": "function",
1875    "name": "deregisterFromOperatorSets",
1876    "inputs": [
1877      {
1878        "name": "params",
1879        "type": "tuple",
1880        "internalType": "struct IAllocationManagerTypes.DeregisterParams",
1881        "components": [
1882          {
1883            "name": "operator",
1884            "type": "address",
1885            "internalType": "address"
1886          },
1887          {
1888            "name": "avs",
1889            "type": "address",
1890            "internalType": "address"
1891          },
1892          {
1893            "name": "operatorSetIds",
1894            "type": "uint32[]",
1895            "internalType": "uint32[]"
1896          }
1897        ]
1898      }
1899    ],
1900    "outputs": [],
1901    "stateMutability": "nonpayable"
1902  },
1903  {
1904    "type": "function",
1905    "name": "getAVSRegistrar",
1906    "inputs": [
1907      {
1908        "name": "avs",
1909        "type": "address",
1910        "internalType": "address"
1911      }
1912    ],
1913    "outputs": [
1914      {
1915        "name": "",
1916        "type": "address",
1917        "internalType": "contract IAVSRegistrar"
1918      }
1919    ],
1920    "stateMutability": "view"
1921  },
1922  {
1923    "type": "function",
1924    "name": "getAllocatableMagnitude",
1925    "inputs": [
1926      {
1927        "name": "operator",
1928        "type": "address",
1929        "internalType": "address"
1930      },
1931      {
1932        "name": "strategy",
1933        "type": "address",
1934        "internalType": "contract IStrategy"
1935      }
1936    ],
1937    "outputs": [
1938      {
1939        "name": "",
1940        "type": "uint64",
1941        "internalType": "uint64"
1942      }
1943    ],
1944    "stateMutability": "view"
1945  },
1946  {
1947    "type": "function",
1948    "name": "getAllocatedSets",
1949    "inputs": [
1950      {
1951        "name": "operator",
1952        "type": "address",
1953        "internalType": "address"
1954      }
1955    ],
1956    "outputs": [
1957      {
1958        "name": "",
1959        "type": "tuple[]",
1960        "internalType": "struct OperatorSet[]",
1961        "components": [
1962          {
1963            "name": "avs",
1964            "type": "address",
1965            "internalType": "address"
1966          },
1967          {
1968            "name": "id",
1969            "type": "uint32",
1970            "internalType": "uint32"
1971          }
1972        ]
1973      }
1974    ],
1975    "stateMutability": "view"
1976  },
1977  {
1978    "type": "function",
1979    "name": "getAllocatedStake",
1980    "inputs": [
1981      {
1982        "name": "operatorSet",
1983        "type": "tuple",
1984        "internalType": "struct OperatorSet",
1985        "components": [
1986          {
1987            "name": "avs",
1988            "type": "address",
1989            "internalType": "address"
1990          },
1991          {
1992            "name": "id",
1993            "type": "uint32",
1994            "internalType": "uint32"
1995          }
1996        ]
1997      },
1998      {
1999        "name": "operators",
2000        "type": "address[]",
2001        "internalType": "address[]"
2002      },
2003      {
2004        "name": "strategies",
2005        "type": "address[]",
2006        "internalType": "contract IStrategy[]"
2007      }
2008    ],
2009    "outputs": [
2010      {
2011        "name": "slashableStake",
2012        "type": "uint256[][]",
2013        "internalType": "uint256[][]"
2014      }
2015    ],
2016    "stateMutability": "view"
2017  },
2018  {
2019    "type": "function",
2020    "name": "getAllocatedStrategies",
2021    "inputs": [
2022      {
2023        "name": "operator",
2024        "type": "address",
2025        "internalType": "address"
2026      },
2027      {
2028        "name": "operatorSet",
2029        "type": "tuple",
2030        "internalType": "struct OperatorSet",
2031        "components": [
2032          {
2033            "name": "avs",
2034            "type": "address",
2035            "internalType": "address"
2036          },
2037          {
2038            "name": "id",
2039            "type": "uint32",
2040            "internalType": "uint32"
2041          }
2042        ]
2043      }
2044    ],
2045    "outputs": [
2046      {
2047        "name": "",
2048        "type": "address[]",
2049        "internalType": "contract IStrategy[]"
2050      }
2051    ],
2052    "stateMutability": "view"
2053  },
2054  {
2055    "type": "function",
2056    "name": "getAllocation",
2057    "inputs": [
2058      {
2059        "name": "operator",
2060        "type": "address",
2061        "internalType": "address"
2062      },
2063      {
2064        "name": "operatorSet",
2065        "type": "tuple",
2066        "internalType": "struct OperatorSet",
2067        "components": [
2068          {
2069            "name": "avs",
2070            "type": "address",
2071            "internalType": "address"
2072          },
2073          {
2074            "name": "id",
2075            "type": "uint32",
2076            "internalType": "uint32"
2077          }
2078        ]
2079      },
2080      {
2081        "name": "strategy",
2082        "type": "address",
2083        "internalType": "contract IStrategy"
2084      }
2085    ],
2086    "outputs": [
2087      {
2088        "name": "",
2089        "type": "tuple",
2090        "internalType": "struct IAllocationManagerTypes.Allocation",
2091        "components": [
2092          {
2093            "name": "currentMagnitude",
2094            "type": "uint64",
2095            "internalType": "uint64"
2096          },
2097          {
2098            "name": "pendingDiff",
2099            "type": "int128",
2100            "internalType": "int128"
2101          },
2102          {
2103            "name": "effectBlock",
2104            "type": "uint32",
2105            "internalType": "uint32"
2106          }
2107        ]
2108      }
2109    ],
2110    "stateMutability": "view"
2111  },
2112  {
2113    "type": "function",
2114    "name": "getAllocationDelay",
2115    "inputs": [
2116      {
2117        "name": "operator",
2118        "type": "address",
2119        "internalType": "address"
2120      }
2121    ],
2122    "outputs": [
2123      {
2124        "name": "isSet",
2125        "type": "bool",
2126        "internalType": "bool"
2127      },
2128      {
2129        "name": "delay",
2130        "type": "uint32",
2131        "internalType": "uint32"
2132      }
2133    ],
2134    "stateMutability": "view"
2135  },
2136  {
2137    "type": "function",
2138    "name": "getAllocations",
2139    "inputs": [
2140      {
2141        "name": "operators",
2142        "type": "address[]",
2143        "internalType": "address[]"
2144      },
2145      {
2146        "name": "operatorSet",
2147        "type": "tuple",
2148        "internalType": "struct OperatorSet",
2149        "components": [
2150          {
2151            "name": "avs",
2152            "type": "address",
2153            "internalType": "address"
2154          },
2155          {
2156            "name": "id",
2157            "type": "uint32",
2158            "internalType": "uint32"
2159          }
2160        ]
2161      },
2162      {
2163        "name": "strategy",
2164        "type": "address",
2165        "internalType": "contract IStrategy"
2166      }
2167    ],
2168    "outputs": [
2169      {
2170        "name": "",
2171        "type": "tuple[]",
2172        "internalType": "struct IAllocationManagerTypes.Allocation[]",
2173        "components": [
2174          {
2175            "name": "currentMagnitude",
2176            "type": "uint64",
2177            "internalType": "uint64"
2178          },
2179          {
2180            "name": "pendingDiff",
2181            "type": "int128",
2182            "internalType": "int128"
2183          },
2184          {
2185            "name": "effectBlock",
2186            "type": "uint32",
2187            "internalType": "uint32"
2188          }
2189        ]
2190      }
2191    ],
2192    "stateMutability": "view"
2193  },
2194  {
2195    "type": "function",
2196    "name": "getEncumberedMagnitude",
2197    "inputs": [
2198      {
2199        "name": "operator",
2200        "type": "address",
2201        "internalType": "address"
2202      },
2203      {
2204        "name": "strategy",
2205        "type": "address",
2206        "internalType": "contract IStrategy"
2207      }
2208    ],
2209    "outputs": [
2210      {
2211        "name": "",
2212        "type": "uint64",
2213        "internalType": "uint64"
2214      }
2215    ],
2216    "stateMutability": "view"
2217  },
2218  {
2219    "type": "function",
2220    "name": "getMaxMagnitude",
2221    "inputs": [
2222      {
2223        "name": "operator",
2224        "type": "address",
2225        "internalType": "address"
2226      },
2227      {
2228        "name": "strategy",
2229        "type": "address",
2230        "internalType": "contract IStrategy"
2231      }
2232    ],
2233    "outputs": [
2234      {
2235        "name": "",
2236        "type": "uint64",
2237        "internalType": "uint64"
2238      }
2239    ],
2240    "stateMutability": "view"
2241  },
2242  {
2243    "type": "function",
2244    "name": "getMaxMagnitudes",
2245    "inputs": [
2246      {
2247        "name": "operators",
2248        "type": "address[]",
2249        "internalType": "address[]"
2250      },
2251      {
2252        "name": "strategy",
2253        "type": "address",
2254        "internalType": "contract IStrategy"
2255      }
2256    ],
2257    "outputs": [
2258      {
2259        "name": "",
2260        "type": "uint64[]",
2261        "internalType": "uint64[]"
2262      }
2263    ],
2264    "stateMutability": "view"
2265  },
2266  {
2267    "type": "function",
2268    "name": "getMaxMagnitudes",
2269    "inputs": [
2270      {
2271        "name": "operator",
2272        "type": "address",
2273        "internalType": "address"
2274      },
2275      {
2276        "name": "strategies",
2277        "type": "address[]",
2278        "internalType": "contract IStrategy[]"
2279      }
2280    ],
2281    "outputs": [
2282      {
2283        "name": "",
2284        "type": "uint64[]",
2285        "internalType": "uint64[]"
2286      }
2287    ],
2288    "stateMutability": "view"
2289  },
2290  {
2291    "type": "function",
2292    "name": "getMaxMagnitudesAtBlock",
2293    "inputs": [
2294      {
2295        "name": "operator",
2296        "type": "address",
2297        "internalType": "address"
2298      },
2299      {
2300        "name": "strategies",
2301        "type": "address[]",
2302        "internalType": "contract IStrategy[]"
2303      },
2304      {
2305        "name": "blockNumber",
2306        "type": "uint32",
2307        "internalType": "uint32"
2308      }
2309    ],
2310    "outputs": [
2311      {
2312        "name": "",
2313        "type": "uint64[]",
2314        "internalType": "uint64[]"
2315      }
2316    ],
2317    "stateMutability": "view"
2318  },
2319  {
2320    "type": "function",
2321    "name": "getMemberCount",
2322    "inputs": [
2323      {
2324        "name": "operatorSet",
2325        "type": "tuple",
2326        "internalType": "struct OperatorSet",
2327        "components": [
2328          {
2329            "name": "avs",
2330            "type": "address",
2331            "internalType": "address"
2332          },
2333          {
2334            "name": "id",
2335            "type": "uint32",
2336            "internalType": "uint32"
2337          }
2338        ]
2339      }
2340    ],
2341    "outputs": [
2342      {
2343        "name": "",
2344        "type": "uint256",
2345        "internalType": "uint256"
2346      }
2347    ],
2348    "stateMutability": "view"
2349  },
2350  {
2351    "type": "function",
2352    "name": "getMembers",
2353    "inputs": [
2354      {
2355        "name": "operatorSet",
2356        "type": "tuple",
2357        "internalType": "struct OperatorSet",
2358        "components": [
2359          {
2360            "name": "avs",
2361            "type": "address",
2362            "internalType": "address"
2363          },
2364          {
2365            "name": "id",
2366            "type": "uint32",
2367            "internalType": "uint32"
2368          }
2369        ]
2370      }
2371    ],
2372    "outputs": [
2373      {
2374        "name": "operators",
2375        "type": "address[]",
2376        "internalType": "address[]"
2377      }
2378    ],
2379    "stateMutability": "view"
2380  },
2381  {
2382    "type": "function",
2383    "name": "getMinimumSlashableStake",
2384    "inputs": [
2385      {
2386        "name": "operatorSet",
2387        "type": "tuple",
2388        "internalType": "struct OperatorSet",
2389        "components": [
2390          {
2391            "name": "avs",
2392            "type": "address",
2393            "internalType": "address"
2394          },
2395          {
2396            "name": "id",
2397            "type": "uint32",
2398            "internalType": "uint32"
2399          }
2400        ]
2401      },
2402      {
2403        "name": "operators",
2404        "type": "address[]",
2405        "internalType": "address[]"
2406      },
2407      {
2408        "name": "strategies",
2409        "type": "address[]",
2410        "internalType": "contract IStrategy[]"
2411      },
2412      {
2413        "name": "futureBlock",
2414        "type": "uint32",
2415        "internalType": "uint32"
2416      }
2417    ],
2418    "outputs": [
2419      {
2420        "name": "slashableStake",
2421        "type": "uint256[][]",
2422        "internalType": "uint256[][]"
2423      }
2424    ],
2425    "stateMutability": "view"
2426  },
2427  {
2428    "type": "function",
2429    "name": "getOperatorSetCount",
2430    "inputs": [
2431      {
2432        "name": "avs",
2433        "type": "address",
2434        "internalType": "address"
2435      }
2436    ],
2437    "outputs": [
2438      {
2439        "name": "",
2440        "type": "uint256",
2441        "internalType": "uint256"
2442      }
2443    ],
2444    "stateMutability": "view"
2445  },
2446  {
2447    "type": "function",
2448    "name": "getRegisteredSets",
2449    "inputs": [
2450      {
2451        "name": "operator",
2452        "type": "address",
2453        "internalType": "address"
2454      }
2455    ],
2456    "outputs": [
2457      {
2458        "name": "operatorSets",
2459        "type": "tuple[]",
2460        "internalType": "struct OperatorSet[]",
2461        "components": [
2462          {
2463            "name": "avs",
2464            "type": "address",
2465            "internalType": "address"
2466          },
2467          {
2468            "name": "id",
2469            "type": "uint32",
2470            "internalType": "uint32"
2471          }
2472        ]
2473      }
2474    ],
2475    "stateMutability": "view"
2476  },
2477  {
2478    "type": "function",
2479    "name": "getStrategiesInOperatorSet",
2480    "inputs": [
2481      {
2482        "name": "operatorSet",
2483        "type": "tuple",
2484        "internalType": "struct OperatorSet",
2485        "components": [
2486          {
2487            "name": "avs",
2488            "type": "address",
2489            "internalType": "address"
2490          },
2491          {
2492            "name": "id",
2493            "type": "uint32",
2494            "internalType": "uint32"
2495          }
2496        ]
2497      }
2498    ],
2499    "outputs": [
2500      {
2501        "name": "strategies",
2502        "type": "address[]",
2503        "internalType": "contract IStrategy[]"
2504      }
2505    ],
2506    "stateMutability": "view"
2507  },
2508  {
2509    "type": "function",
2510    "name": "getStrategyAllocations",
2511    "inputs": [
2512      {
2513        "name": "operator",
2514        "type": "address",
2515        "internalType": "address"
2516      },
2517      {
2518        "name": "strategy",
2519        "type": "address",
2520        "internalType": "contract IStrategy"
2521      }
2522    ],
2523    "outputs": [
2524      {
2525        "name": "",
2526        "type": "tuple[]",
2527        "internalType": "struct OperatorSet[]",
2528        "components": [
2529          {
2530            "name": "avs",
2531            "type": "address",
2532            "internalType": "address"
2533          },
2534          {
2535            "name": "id",
2536            "type": "uint32",
2537            "internalType": "uint32"
2538          }
2539        ]
2540      },
2541      {
2542        "name": "",
2543        "type": "tuple[]",
2544        "internalType": "struct IAllocationManagerTypes.Allocation[]",
2545        "components": [
2546          {
2547            "name": "currentMagnitude",
2548            "type": "uint64",
2549            "internalType": "uint64"
2550          },
2551          {
2552            "name": "pendingDiff",
2553            "type": "int128",
2554            "internalType": "int128"
2555          },
2556          {
2557            "name": "effectBlock",
2558            "type": "uint32",
2559            "internalType": "uint32"
2560          }
2561        ]
2562      }
2563    ],
2564    "stateMutability": "view"
2565  },
2566  {
2567    "type": "function",
2568    "name": "initialize",
2569    "inputs": [
2570      {
2571        "name": "initialOwner",
2572        "type": "address",
2573        "internalType": "address"
2574      },
2575      {
2576        "name": "initialPausedStatus",
2577        "type": "uint256",
2578        "internalType": "uint256"
2579      }
2580    ],
2581    "outputs": [],
2582    "stateMutability": "nonpayable"
2583  },
2584  {
2585    "type": "function",
2586    "name": "isMemberOfOperatorSet",
2587    "inputs": [
2588      {
2589        "name": "operator",
2590        "type": "address",
2591        "internalType": "address"
2592      },
2593      {
2594        "name": "operatorSet",
2595        "type": "tuple",
2596        "internalType": "struct OperatorSet",
2597        "components": [
2598          {
2599            "name": "avs",
2600            "type": "address",
2601            "internalType": "address"
2602          },
2603          {
2604            "name": "id",
2605            "type": "uint32",
2606            "internalType": "uint32"
2607          }
2608        ]
2609      }
2610    ],
2611    "outputs": [
2612      {
2613        "name": "",
2614        "type": "bool",
2615        "internalType": "bool"
2616      }
2617    ],
2618    "stateMutability": "view"
2619  },
2620  {
2621    "type": "function",
2622    "name": "isOperatorSet",
2623    "inputs": [
2624      {
2625        "name": "operatorSet",
2626        "type": "tuple",
2627        "internalType": "struct OperatorSet",
2628        "components": [
2629          {
2630            "name": "avs",
2631            "type": "address",
2632            "internalType": "address"
2633          },
2634          {
2635            "name": "id",
2636            "type": "uint32",
2637            "internalType": "uint32"
2638          }
2639        ]
2640      }
2641    ],
2642    "outputs": [
2643      {
2644        "name": "",
2645        "type": "bool",
2646        "internalType": "bool"
2647      }
2648    ],
2649    "stateMutability": "view"
2650  },
2651  {
2652    "type": "function",
2653    "name": "isOperatorSlashable",
2654    "inputs": [
2655      {
2656        "name": "operator",
2657        "type": "address",
2658        "internalType": "address"
2659      },
2660      {
2661        "name": "operatorSet",
2662        "type": "tuple",
2663        "internalType": "struct OperatorSet",
2664        "components": [
2665          {
2666            "name": "avs",
2667            "type": "address",
2668            "internalType": "address"
2669          },
2670          {
2671            "name": "id",
2672            "type": "uint32",
2673            "internalType": "uint32"
2674          }
2675        ]
2676      }
2677    ],
2678    "outputs": [
2679      {
2680        "name": "",
2681        "type": "bool",
2682        "internalType": "bool"
2683      }
2684    ],
2685    "stateMutability": "view"
2686  },
2687  {
2688    "type": "function",
2689    "name": "modifyAllocations",
2690    "inputs": [
2691      {
2692        "name": "operator",
2693        "type": "address",
2694        "internalType": "address"
2695      },
2696      {
2697        "name": "params",
2698        "type": "tuple[]",
2699        "internalType": "struct IAllocationManagerTypes.AllocateParams[]",
2700        "components": [
2701          {
2702            "name": "operatorSet",
2703            "type": "tuple",
2704            "internalType": "struct OperatorSet",
2705            "components": [
2706              {
2707                "name": "avs",
2708                "type": "address",
2709                "internalType": "address"
2710              },
2711              {
2712                "name": "id",
2713                "type": "uint32",
2714                "internalType": "uint32"
2715              }
2716            ]
2717          },
2718          {
2719            "name": "strategies",
2720            "type": "address[]",
2721            "internalType": "contract IStrategy[]"
2722          },
2723          {
2724            "name": "newMagnitudes",
2725            "type": "uint64[]",
2726            "internalType": "uint64[]"
2727          }
2728        ]
2729      }
2730    ],
2731    "outputs": [],
2732    "stateMutability": "nonpayable"
2733  },
2734  {
2735    "type": "function",
2736    "name": "registerForOperatorSets",
2737    "inputs": [
2738      {
2739        "name": "operator",
2740        "type": "address",
2741        "internalType": "address"
2742      },
2743      {
2744        "name": "params",
2745        "type": "tuple",
2746        "internalType": "struct IAllocationManagerTypes.RegisterParams",
2747        "components": [
2748          {
2749            "name": "avs",
2750            "type": "address",
2751            "internalType": "address"
2752          },
2753          {
2754            "name": "operatorSetIds",
2755            "type": "uint32[]",
2756            "internalType": "uint32[]"
2757          },
2758          {
2759            "name": "data",
2760            "type": "bytes",
2761            "internalType": "bytes"
2762          }
2763        ]
2764      }
2765    ],
2766    "outputs": [],
2767    "stateMutability": "nonpayable"
2768  },
2769  {
2770    "type": "function",
2771    "name": "removeStrategiesFromOperatorSet",
2772    "inputs": [
2773      {
2774        "name": "avs",
2775        "type": "address",
2776        "internalType": "address"
2777      },
2778      {
2779        "name": "operatorSetId",
2780        "type": "uint32",
2781        "internalType": "uint32"
2782      },
2783      {
2784        "name": "strategies",
2785        "type": "address[]",
2786        "internalType": "contract IStrategy[]"
2787      }
2788    ],
2789    "outputs": [],
2790    "stateMutability": "nonpayable"
2791  },
2792  {
2793    "type": "function",
2794    "name": "setAVSRegistrar",
2795    "inputs": [
2796      {
2797        "name": "avs",
2798        "type": "address",
2799        "internalType": "address"
2800      },
2801      {
2802        "name": "registrar",
2803        "type": "address",
2804        "internalType": "contract IAVSRegistrar"
2805      }
2806    ],
2807    "outputs": [],
2808    "stateMutability": "nonpayable"
2809  },
2810  {
2811    "type": "function",
2812    "name": "setAllocationDelay",
2813    "inputs": [
2814      {
2815        "name": "operator",
2816        "type": "address",
2817        "internalType": "address"
2818      },
2819      {
2820        "name": "delay",
2821        "type": "uint32",
2822        "internalType": "uint32"
2823      }
2824    ],
2825    "outputs": [],
2826    "stateMutability": "nonpayable"
2827  },
2828  {
2829    "type": "function",
2830    "name": "slashOperator",
2831    "inputs": [
2832      {
2833        "name": "avs",
2834        "type": "address",
2835        "internalType": "address"
2836      },
2837      {
2838        "name": "params",
2839        "type": "tuple",
2840        "internalType": "struct IAllocationManagerTypes.SlashingParams",
2841        "components": [
2842          {
2843            "name": "operator",
2844            "type": "address",
2845            "internalType": "address"
2846          },
2847          {
2848            "name": "operatorSetId",
2849            "type": "uint32",
2850            "internalType": "uint32"
2851          },
2852          {
2853            "name": "strategies",
2854            "type": "address[]",
2855            "internalType": "contract IStrategy[]"
2856          },
2857          {
2858            "name": "wadsToSlash",
2859            "type": "uint256[]",
2860            "internalType": "uint256[]"
2861          },
2862          {
2863            "name": "description",
2864            "type": "string",
2865            "internalType": "string"
2866          }
2867        ]
2868      }
2869    ],
2870    "outputs": [],
2871    "stateMutability": "nonpayable"
2872  },
2873  {
2874    "type": "function",
2875    "name": "updateAVSMetadataURI",
2876    "inputs": [
2877      {
2878        "name": "avs",
2879        "type": "address",
2880        "internalType": "address"
2881      },
2882      {
2883        "name": "metadataURI",
2884        "type": "string",
2885        "internalType": "string"
2886      }
2887    ],
2888    "outputs": [],
2889    "stateMutability": "nonpayable"
2890  },
2891  {
2892    "type": "function",
2893    "name": "version",
2894    "inputs": [],
2895    "outputs": [
2896      {
2897        "name": "",
2898        "type": "string",
2899        "internalType": "string"
2900      }
2901    ],
2902    "stateMutability": "view"
2903  },
2904  {
2905    "type": "event",
2906    "name": "AVSMetadataURIUpdated",
2907    "inputs": [
2908      {
2909        "name": "avs",
2910        "type": "address",
2911        "indexed": true,
2912        "internalType": "address"
2913      },
2914      {
2915        "name": "metadataURI",
2916        "type": "string",
2917        "indexed": false,
2918        "internalType": "string"
2919      }
2920    ],
2921    "anonymous": false
2922  },
2923  {
2924    "type": "event",
2925    "name": "AVSRegistrarSet",
2926    "inputs": [
2927      {
2928        "name": "avs",
2929        "type": "address",
2930        "indexed": false,
2931        "internalType": "address"
2932      },
2933      {
2934        "name": "registrar",
2935        "type": "address",
2936        "indexed": false,
2937        "internalType": "contract IAVSRegistrar"
2938      }
2939    ],
2940    "anonymous": false
2941  },
2942  {
2943    "type": "event",
2944    "name": "AllocationDelaySet",
2945    "inputs": [
2946      {
2947        "name": "operator",
2948        "type": "address",
2949        "indexed": false,
2950        "internalType": "address"
2951      },
2952      {
2953        "name": "delay",
2954        "type": "uint32",
2955        "indexed": false,
2956        "internalType": "uint32"
2957      },
2958      {
2959        "name": "effectBlock",
2960        "type": "uint32",
2961        "indexed": false,
2962        "internalType": "uint32"
2963      }
2964    ],
2965    "anonymous": false
2966  },
2967  {
2968    "type": "event",
2969    "name": "AllocationUpdated",
2970    "inputs": [
2971      {
2972        "name": "operator",
2973        "type": "address",
2974        "indexed": false,
2975        "internalType": "address"
2976      },
2977      {
2978        "name": "operatorSet",
2979        "type": "tuple",
2980        "indexed": false,
2981        "internalType": "struct OperatorSet",
2982        "components": [
2983          {
2984            "name": "avs",
2985            "type": "address",
2986            "internalType": "address"
2987          },
2988          {
2989            "name": "id",
2990            "type": "uint32",
2991            "internalType": "uint32"
2992          }
2993        ]
2994      },
2995      {
2996        "name": "strategy",
2997        "type": "address",
2998        "indexed": false,
2999        "internalType": "contract IStrategy"
3000      },
3001      {
3002        "name": "magnitude",
3003        "type": "uint64",
3004        "indexed": false,
3005        "internalType": "uint64"
3006      },
3007      {
3008        "name": "effectBlock",
3009        "type": "uint32",
3010        "indexed": false,
3011        "internalType": "uint32"
3012      }
3013    ],
3014    "anonymous": false
3015  },
3016  {
3017    "type": "event",
3018    "name": "EncumberedMagnitudeUpdated",
3019    "inputs": [
3020      {
3021        "name": "operator",
3022        "type": "address",
3023        "indexed": false,
3024        "internalType": "address"
3025      },
3026      {
3027        "name": "strategy",
3028        "type": "address",
3029        "indexed": false,
3030        "internalType": "contract IStrategy"
3031      },
3032      {
3033        "name": "encumberedMagnitude",
3034        "type": "uint64",
3035        "indexed": false,
3036        "internalType": "uint64"
3037      }
3038    ],
3039    "anonymous": false
3040  },
3041  {
3042    "type": "event",
3043    "name": "MaxMagnitudeUpdated",
3044    "inputs": [
3045      {
3046        "name": "operator",
3047        "type": "address",
3048        "indexed": false,
3049        "internalType": "address"
3050      },
3051      {
3052        "name": "strategy",
3053        "type": "address",
3054        "indexed": false,
3055        "internalType": "contract IStrategy"
3056      },
3057      {
3058        "name": "maxMagnitude",
3059        "type": "uint64",
3060        "indexed": false,
3061        "internalType": "uint64"
3062      }
3063    ],
3064    "anonymous": false
3065  },
3066  {
3067    "type": "event",
3068    "name": "OperatorAddedToOperatorSet",
3069    "inputs": [
3070      {
3071        "name": "operator",
3072        "type": "address",
3073        "indexed": true,
3074        "internalType": "address"
3075      },
3076      {
3077        "name": "operatorSet",
3078        "type": "tuple",
3079        "indexed": false,
3080        "internalType": "struct OperatorSet",
3081        "components": [
3082          {
3083            "name": "avs",
3084            "type": "address",
3085            "internalType": "address"
3086          },
3087          {
3088            "name": "id",
3089            "type": "uint32",
3090            "internalType": "uint32"
3091          }
3092        ]
3093      }
3094    ],
3095    "anonymous": false
3096  },
3097  {
3098    "type": "event",
3099    "name": "OperatorRemovedFromOperatorSet",
3100    "inputs": [
3101      {
3102        "name": "operator",
3103        "type": "address",
3104        "indexed": true,
3105        "internalType": "address"
3106      },
3107      {
3108        "name": "operatorSet",
3109        "type": "tuple",
3110        "indexed": false,
3111        "internalType": "struct OperatorSet",
3112        "components": [
3113          {
3114            "name": "avs",
3115            "type": "address",
3116            "internalType": "address"
3117          },
3118          {
3119            "name": "id",
3120            "type": "uint32",
3121            "internalType": "uint32"
3122          }
3123        ]
3124      }
3125    ],
3126    "anonymous": false
3127  },
3128  {
3129    "type": "event",
3130    "name": "OperatorSetCreated",
3131    "inputs": [
3132      {
3133        "name": "operatorSet",
3134        "type": "tuple",
3135        "indexed": false,
3136        "internalType": "struct OperatorSet",
3137        "components": [
3138          {
3139            "name": "avs",
3140            "type": "address",
3141            "internalType": "address"
3142          },
3143          {
3144            "name": "id",
3145            "type": "uint32",
3146            "internalType": "uint32"
3147          }
3148        ]
3149      }
3150    ],
3151    "anonymous": false
3152  },
3153  {
3154    "type": "event",
3155    "name": "OperatorSlashed",
3156    "inputs": [
3157      {
3158        "name": "operator",
3159        "type": "address",
3160        "indexed": false,
3161        "internalType": "address"
3162      },
3163      {
3164        "name": "operatorSet",
3165        "type": "tuple",
3166        "indexed": false,
3167        "internalType": "struct OperatorSet",
3168        "components": [
3169          {
3170            "name": "avs",
3171            "type": "address",
3172            "internalType": "address"
3173          },
3174          {
3175            "name": "id",
3176            "type": "uint32",
3177            "internalType": "uint32"
3178          }
3179        ]
3180      },
3181      {
3182        "name": "strategies",
3183        "type": "address[]",
3184        "indexed": false,
3185        "internalType": "contract IStrategy[]"
3186      },
3187      {
3188        "name": "wadSlashed",
3189        "type": "uint256[]",
3190        "indexed": false,
3191        "internalType": "uint256[]"
3192      },
3193      {
3194        "name": "description",
3195        "type": "string",
3196        "indexed": false,
3197        "internalType": "string"
3198      }
3199    ],
3200    "anonymous": false
3201  },
3202  {
3203    "type": "event",
3204    "name": "StrategyAddedToOperatorSet",
3205    "inputs": [
3206      {
3207        "name": "operatorSet",
3208        "type": "tuple",
3209        "indexed": false,
3210        "internalType": "struct OperatorSet",
3211        "components": [
3212          {
3213            "name": "avs",
3214            "type": "address",
3215            "internalType": "address"
3216          },
3217          {
3218            "name": "id",
3219            "type": "uint32",
3220            "internalType": "uint32"
3221          }
3222        ]
3223      },
3224      {
3225        "name": "strategy",
3226        "type": "address",
3227        "indexed": false,
3228        "internalType": "contract IStrategy"
3229      }
3230    ],
3231    "anonymous": false
3232  },
3233  {
3234    "type": "event",
3235    "name": "StrategyRemovedFromOperatorSet",
3236    "inputs": [
3237      {
3238        "name": "operatorSet",
3239        "type": "tuple",
3240        "indexed": false,
3241        "internalType": "struct OperatorSet",
3242        "components": [
3243          {
3244            "name": "avs",
3245            "type": "address",
3246            "internalType": "address"
3247          },
3248          {
3249            "name": "id",
3250            "type": "uint32",
3251            "internalType": "uint32"
3252          }
3253        ]
3254      },
3255      {
3256        "name": "strategy",
3257        "type": "address",
3258        "indexed": false,
3259        "internalType": "contract IStrategy"
3260      }
3261    ],
3262    "anonymous": false
3263  },
3264  {
3265    "type": "error",
3266    "name": "AlreadyMemberOfSet",
3267    "inputs": []
3268  },
3269  {
3270    "type": "error",
3271    "name": "InputArrayLengthMismatch",
3272    "inputs": []
3273  },
3274  {
3275    "type": "error",
3276    "name": "InsufficientMagnitude",
3277    "inputs": []
3278  },
3279  {
3280    "type": "error",
3281    "name": "InvalidAVSRegistrar",
3282    "inputs": []
3283  },
3284  {
3285    "type": "error",
3286    "name": "InvalidCaller",
3287    "inputs": []
3288  },
3289  {
3290    "type": "error",
3291    "name": "InvalidOperator",
3292    "inputs": []
3293  },
3294  {
3295    "type": "error",
3296    "name": "InvalidOperatorSet",
3297    "inputs": []
3298  },
3299  {
3300    "type": "error",
3301    "name": "InvalidWadToSlash",
3302    "inputs": []
3303  },
3304  {
3305    "type": "error",
3306    "name": "ModificationAlreadyPending",
3307    "inputs": []
3308  },
3309  {
3310    "type": "error",
3311    "name": "NonexistentAVSMetadata",
3312    "inputs": []
3313  },
3314  {
3315    "type": "error",
3316    "name": "NotMemberOfSet",
3317    "inputs": []
3318  },
3319  {
3320    "type": "error",
3321    "name": "OperatorNotSlashable",
3322    "inputs": []
3323  },
3324  {
3325    "type": "error",
3326    "name": "SameMagnitude",
3327    "inputs": []
3328  },
3329  {
3330    "type": "error",
3331    "name": "StrategiesMustBeInAscendingOrder",
3332    "inputs": []
3333  },
3334  {
3335    "type": "error",
3336    "name": "StrategyAlreadyInOperatorSet",
3337    "inputs": []
3338  },
3339  {
3340    "type": "error",
3341    "name": "StrategyNotInOperatorSet",
3342    "inputs": []
3343  },
3344  {
3345    "type": "error",
3346    "name": "UninitializedAllocationDelay",
3347    "inputs": []
3348  }
3349]
3350```*/
3351#[allow(
3352    non_camel_case_types,
3353    non_snake_case,
3354    clippy::pub_underscore_fields,
3355    clippy::style,
3356    clippy::empty_structs_with_brackets
3357)]
3358pub mod IAllocationManager {
3359    use super::*;
3360    use alloy::sol_types as alloy_sol_types;
3361    /// The creation / init bytecode of the contract.
3362    ///
3363    /// ```text
3364    ///0x
3365    /// ```
3366    #[rustfmt::skip]
3367    #[allow(clippy::all)]
3368    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
3369        b"",
3370    );
3371    /// The runtime bytecode of the contract, as deployed on the network.
3372    ///
3373    /// ```text
3374    ///0x
3375    /// ```
3376    #[rustfmt::skip]
3377    #[allow(clippy::all)]
3378    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
3379        b"",
3380    );
3381    #[derive(serde::Serialize, serde::Deserialize)]
3382    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3383    /**```solidity
3384struct OperatorSet { address avs; uint32 id; }
3385```*/
3386    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3387    #[derive(Clone)]
3388    pub struct OperatorSet {
3389        #[allow(missing_docs)]
3390        pub avs: alloy::sol_types::private::Address,
3391        #[allow(missing_docs)]
3392        pub id: u32,
3393    }
3394    #[allow(
3395        non_camel_case_types,
3396        non_snake_case,
3397        clippy::pub_underscore_fields,
3398        clippy::style
3399    )]
3400    const _: () = {
3401        use alloy::sol_types as alloy_sol_types;
3402        #[doc(hidden)]
3403        type UnderlyingSolTuple<'a> = (
3404            alloy::sol_types::sol_data::Address,
3405            alloy::sol_types::sol_data::Uint<32>,
3406        );
3407        #[doc(hidden)]
3408        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
3409        #[cfg(test)]
3410        #[allow(dead_code, unreachable_patterns)]
3411        fn _type_assertion(
3412            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3413        ) {
3414            match _t {
3415                alloy_sol_types::private::AssertTypeEq::<
3416                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3417                >(_) => {}
3418            }
3419        }
3420        #[automatically_derived]
3421        #[doc(hidden)]
3422        impl ::core::convert::From<OperatorSet> for UnderlyingRustTuple<'_> {
3423            fn from(value: OperatorSet) -> Self {
3424                (value.avs, value.id)
3425            }
3426        }
3427        #[automatically_derived]
3428        #[doc(hidden)]
3429        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorSet {
3430            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3431                Self { avs: tuple.0, id: tuple.1 }
3432            }
3433        }
3434        #[automatically_derived]
3435        impl alloy_sol_types::SolValue for OperatorSet {
3436            type SolType = Self;
3437        }
3438        #[automatically_derived]
3439        impl alloy_sol_types::private::SolTypeValue<Self> for OperatorSet {
3440            #[inline]
3441            fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
3442                (
3443                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3444                        &self.avs,
3445                    ),
3446                    <alloy::sol_types::sol_data::Uint<
3447                        32,
3448                    > as alloy_sol_types::SolType>::tokenize(&self.id),
3449                )
3450            }
3451            #[inline]
3452            fn stv_abi_encoded_size(&self) -> usize {
3453                if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
3454                    return size;
3455                }
3456                let tuple = <UnderlyingRustTuple<
3457                    '_,
3458                > as ::core::convert::From<Self>>::from(self.clone());
3459                <UnderlyingSolTuple<
3460                    '_,
3461                > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
3462            }
3463            #[inline]
3464            fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
3465                <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
3466            }
3467            #[inline]
3468            fn stv_abi_encode_packed_to(
3469                &self,
3470                out: &mut alloy_sol_types::private::Vec<u8>,
3471            ) {
3472                let tuple = <UnderlyingRustTuple<
3473                    '_,
3474                > as ::core::convert::From<Self>>::from(self.clone());
3475                <UnderlyingSolTuple<
3476                    '_,
3477                > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
3478            }
3479            #[inline]
3480            fn stv_abi_packed_encoded_size(&self) -> usize {
3481                if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
3482                    return size;
3483                }
3484                let tuple = <UnderlyingRustTuple<
3485                    '_,
3486                > as ::core::convert::From<Self>>::from(self.clone());
3487                <UnderlyingSolTuple<
3488                    '_,
3489                > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
3490            }
3491        }
3492        #[automatically_derived]
3493        impl alloy_sol_types::SolType for OperatorSet {
3494            type RustType = Self;
3495            type Token<'a> = <UnderlyingSolTuple<
3496                'a,
3497            > as alloy_sol_types::SolType>::Token<'a>;
3498            const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
3499            const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
3500                '_,
3501            > as alloy_sol_types::SolType>::ENCODED_SIZE;
3502            const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
3503                '_,
3504            > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
3505            #[inline]
3506            fn valid_token(token: &Self::Token<'_>) -> bool {
3507                <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
3508            }
3509            #[inline]
3510            fn detokenize(token: Self::Token<'_>) -> Self::RustType {
3511                let tuple = <UnderlyingSolTuple<
3512                    '_,
3513                > as alloy_sol_types::SolType>::detokenize(token);
3514                <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
3515            }
3516        }
3517        #[automatically_derived]
3518        impl alloy_sol_types::SolStruct for OperatorSet {
3519            const NAME: &'static str = "OperatorSet";
3520            #[inline]
3521            fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
3522                alloy_sol_types::private::Cow::Borrowed(
3523                    "OperatorSet(address avs,uint32 id)",
3524                )
3525            }
3526            #[inline]
3527            fn eip712_components() -> alloy_sol_types::private::Vec<
3528                alloy_sol_types::private::Cow<'static, str>,
3529            > {
3530                alloy_sol_types::private::Vec::new()
3531            }
3532            #[inline]
3533            fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
3534                <Self as alloy_sol_types::SolStruct>::eip712_root_type()
3535            }
3536            #[inline]
3537            fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
3538                [
3539                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::eip712_data_word(
3540                            &self.avs,
3541                        )
3542                        .0,
3543                    <alloy::sol_types::sol_data::Uint<
3544                        32,
3545                    > as alloy_sol_types::SolType>::eip712_data_word(&self.id)
3546                        .0,
3547                ]
3548                    .concat()
3549            }
3550        }
3551        #[automatically_derived]
3552        impl alloy_sol_types::EventTopic for OperatorSet {
3553            #[inline]
3554            fn topic_preimage_length(rust: &Self::RustType) -> usize {
3555                0usize
3556                    + <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::topic_preimage_length(
3557                        &rust.avs,
3558                    )
3559                    + <alloy::sol_types::sol_data::Uint<
3560                        32,
3561                    > as alloy_sol_types::EventTopic>::topic_preimage_length(&rust.id)
3562            }
3563            #[inline]
3564            fn encode_topic_preimage(
3565                rust: &Self::RustType,
3566                out: &mut alloy_sol_types::private::Vec<u8>,
3567            ) {
3568                out.reserve(
3569                    <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
3570                );
3571                <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic_preimage(
3572                    &rust.avs,
3573                    out,
3574                );
3575                <alloy::sol_types::sol_data::Uint<
3576                    32,
3577                > as alloy_sol_types::EventTopic>::encode_topic_preimage(&rust.id, out);
3578            }
3579            #[inline]
3580            fn encode_topic(
3581                rust: &Self::RustType,
3582            ) -> alloy_sol_types::abi::token::WordToken {
3583                let mut out = alloy_sol_types::private::Vec::new();
3584                <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
3585                    rust,
3586                    &mut out,
3587                );
3588                alloy_sol_types::abi::token::WordToken(
3589                    alloy_sol_types::private::keccak256(out),
3590                )
3591            }
3592        }
3593    };
3594    #[derive(serde::Serialize, serde::Deserialize)]
3595    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3596    /**Custom error with signature `AlreadyMemberOfSet()` and selector `0xd8d8dc4e`.
3597```solidity
3598error AlreadyMemberOfSet();
3599```*/
3600    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3601    #[derive(Clone)]
3602    pub struct AlreadyMemberOfSet;
3603    #[allow(
3604        non_camel_case_types,
3605        non_snake_case,
3606        clippy::pub_underscore_fields,
3607        clippy::style
3608    )]
3609    const _: () = {
3610        use alloy::sol_types as alloy_sol_types;
3611        #[doc(hidden)]
3612        type UnderlyingSolTuple<'a> = ();
3613        #[doc(hidden)]
3614        type UnderlyingRustTuple<'a> = ();
3615        #[cfg(test)]
3616        #[allow(dead_code, unreachable_patterns)]
3617        fn _type_assertion(
3618            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3619        ) {
3620            match _t {
3621                alloy_sol_types::private::AssertTypeEq::<
3622                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3623                >(_) => {}
3624            }
3625        }
3626        #[automatically_derived]
3627        #[doc(hidden)]
3628        impl ::core::convert::From<AlreadyMemberOfSet> for UnderlyingRustTuple<'_> {
3629            fn from(value: AlreadyMemberOfSet) -> Self {
3630                ()
3631            }
3632        }
3633        #[automatically_derived]
3634        #[doc(hidden)]
3635        impl ::core::convert::From<UnderlyingRustTuple<'_>> for AlreadyMemberOfSet {
3636            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3637                Self
3638            }
3639        }
3640        #[automatically_derived]
3641        impl alloy_sol_types::SolError for AlreadyMemberOfSet {
3642            type Parameters<'a> = UnderlyingSolTuple<'a>;
3643            type Token<'a> = <Self::Parameters<
3644                'a,
3645            > as alloy_sol_types::SolType>::Token<'a>;
3646            const SIGNATURE: &'static str = "AlreadyMemberOfSet()";
3647            const SELECTOR: [u8; 4] = [216u8, 216u8, 220u8, 78u8];
3648            #[inline]
3649            fn new<'a>(
3650                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3651            ) -> Self {
3652                tuple.into()
3653            }
3654            #[inline]
3655            fn tokenize(&self) -> Self::Token<'_> {
3656                ()
3657            }
3658            #[inline]
3659            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3660                <Self::Parameters<
3661                    '_,
3662                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3663                    .map(Self::new)
3664            }
3665        }
3666    };
3667    #[derive(serde::Serialize, serde::Deserialize)]
3668    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3669    /**Custom error with signature `InputArrayLengthMismatch()` and selector `0x43714afd`.
3670```solidity
3671error InputArrayLengthMismatch();
3672```*/
3673    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3674    #[derive(Clone)]
3675    pub struct InputArrayLengthMismatch;
3676    #[allow(
3677        non_camel_case_types,
3678        non_snake_case,
3679        clippy::pub_underscore_fields,
3680        clippy::style
3681    )]
3682    const _: () = {
3683        use alloy::sol_types as alloy_sol_types;
3684        #[doc(hidden)]
3685        type UnderlyingSolTuple<'a> = ();
3686        #[doc(hidden)]
3687        type UnderlyingRustTuple<'a> = ();
3688        #[cfg(test)]
3689        #[allow(dead_code, unreachable_patterns)]
3690        fn _type_assertion(
3691            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3692        ) {
3693            match _t {
3694                alloy_sol_types::private::AssertTypeEq::<
3695                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3696                >(_) => {}
3697            }
3698        }
3699        #[automatically_derived]
3700        #[doc(hidden)]
3701        impl ::core::convert::From<InputArrayLengthMismatch>
3702        for UnderlyingRustTuple<'_> {
3703            fn from(value: InputArrayLengthMismatch) -> Self {
3704                ()
3705            }
3706        }
3707        #[automatically_derived]
3708        #[doc(hidden)]
3709        impl ::core::convert::From<UnderlyingRustTuple<'_>>
3710        for InputArrayLengthMismatch {
3711            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3712                Self
3713            }
3714        }
3715        #[automatically_derived]
3716        impl alloy_sol_types::SolError for InputArrayLengthMismatch {
3717            type Parameters<'a> = UnderlyingSolTuple<'a>;
3718            type Token<'a> = <Self::Parameters<
3719                'a,
3720            > as alloy_sol_types::SolType>::Token<'a>;
3721            const SIGNATURE: &'static str = "InputArrayLengthMismatch()";
3722            const SELECTOR: [u8; 4] = [67u8, 113u8, 74u8, 253u8];
3723            #[inline]
3724            fn new<'a>(
3725                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3726            ) -> Self {
3727                tuple.into()
3728            }
3729            #[inline]
3730            fn tokenize(&self) -> Self::Token<'_> {
3731                ()
3732            }
3733            #[inline]
3734            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3735                <Self::Parameters<
3736                    '_,
3737                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3738                    .map(Self::new)
3739            }
3740        }
3741    };
3742    #[derive(serde::Serialize, serde::Deserialize)]
3743    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3744    /**Custom error with signature `InsufficientMagnitude()` and selector `0x6c9be0bf`.
3745```solidity
3746error InsufficientMagnitude();
3747```*/
3748    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3749    #[derive(Clone)]
3750    pub struct InsufficientMagnitude;
3751    #[allow(
3752        non_camel_case_types,
3753        non_snake_case,
3754        clippy::pub_underscore_fields,
3755        clippy::style
3756    )]
3757    const _: () = {
3758        use alloy::sol_types as alloy_sol_types;
3759        #[doc(hidden)]
3760        type UnderlyingSolTuple<'a> = ();
3761        #[doc(hidden)]
3762        type UnderlyingRustTuple<'a> = ();
3763        #[cfg(test)]
3764        #[allow(dead_code, unreachable_patterns)]
3765        fn _type_assertion(
3766            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3767        ) {
3768            match _t {
3769                alloy_sol_types::private::AssertTypeEq::<
3770                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3771                >(_) => {}
3772            }
3773        }
3774        #[automatically_derived]
3775        #[doc(hidden)]
3776        impl ::core::convert::From<InsufficientMagnitude> for UnderlyingRustTuple<'_> {
3777            fn from(value: InsufficientMagnitude) -> Self {
3778                ()
3779            }
3780        }
3781        #[automatically_derived]
3782        #[doc(hidden)]
3783        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientMagnitude {
3784            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3785                Self
3786            }
3787        }
3788        #[automatically_derived]
3789        impl alloy_sol_types::SolError for InsufficientMagnitude {
3790            type Parameters<'a> = UnderlyingSolTuple<'a>;
3791            type Token<'a> = <Self::Parameters<
3792                'a,
3793            > as alloy_sol_types::SolType>::Token<'a>;
3794            const SIGNATURE: &'static str = "InsufficientMagnitude()";
3795            const SELECTOR: [u8; 4] = [108u8, 155u8, 224u8, 191u8];
3796            #[inline]
3797            fn new<'a>(
3798                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3799            ) -> Self {
3800                tuple.into()
3801            }
3802            #[inline]
3803            fn tokenize(&self) -> Self::Token<'_> {
3804                ()
3805            }
3806            #[inline]
3807            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3808                <Self::Parameters<
3809                    '_,
3810                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3811                    .map(Self::new)
3812            }
3813        }
3814    };
3815    #[derive(serde::Serialize, serde::Deserialize)]
3816    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3817    /**Custom error with signature `InvalidAVSRegistrar()` and selector `0xe8589e08`.
3818```solidity
3819error InvalidAVSRegistrar();
3820```*/
3821    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3822    #[derive(Clone)]
3823    pub struct InvalidAVSRegistrar;
3824    #[allow(
3825        non_camel_case_types,
3826        non_snake_case,
3827        clippy::pub_underscore_fields,
3828        clippy::style
3829    )]
3830    const _: () = {
3831        use alloy::sol_types as alloy_sol_types;
3832        #[doc(hidden)]
3833        type UnderlyingSolTuple<'a> = ();
3834        #[doc(hidden)]
3835        type UnderlyingRustTuple<'a> = ();
3836        #[cfg(test)]
3837        #[allow(dead_code, unreachable_patterns)]
3838        fn _type_assertion(
3839            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3840        ) {
3841            match _t {
3842                alloy_sol_types::private::AssertTypeEq::<
3843                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3844                >(_) => {}
3845            }
3846        }
3847        #[automatically_derived]
3848        #[doc(hidden)]
3849        impl ::core::convert::From<InvalidAVSRegistrar> for UnderlyingRustTuple<'_> {
3850            fn from(value: InvalidAVSRegistrar) -> Self {
3851                ()
3852            }
3853        }
3854        #[automatically_derived]
3855        #[doc(hidden)]
3856        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidAVSRegistrar {
3857            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3858                Self
3859            }
3860        }
3861        #[automatically_derived]
3862        impl alloy_sol_types::SolError for InvalidAVSRegistrar {
3863            type Parameters<'a> = UnderlyingSolTuple<'a>;
3864            type Token<'a> = <Self::Parameters<
3865                'a,
3866            > as alloy_sol_types::SolType>::Token<'a>;
3867            const SIGNATURE: &'static str = "InvalidAVSRegistrar()";
3868            const SELECTOR: [u8; 4] = [232u8, 88u8, 158u8, 8u8];
3869            #[inline]
3870            fn new<'a>(
3871                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3872            ) -> Self {
3873                tuple.into()
3874            }
3875            #[inline]
3876            fn tokenize(&self) -> Self::Token<'_> {
3877                ()
3878            }
3879            #[inline]
3880            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3881                <Self::Parameters<
3882                    '_,
3883                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3884                    .map(Self::new)
3885            }
3886        }
3887    };
3888    #[derive(serde::Serialize, serde::Deserialize)]
3889    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3890    /**Custom error with signature `InvalidCaller()` and selector `0x48f5c3ed`.
3891```solidity
3892error InvalidCaller();
3893```*/
3894    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3895    #[derive(Clone)]
3896    pub struct InvalidCaller;
3897    #[allow(
3898        non_camel_case_types,
3899        non_snake_case,
3900        clippy::pub_underscore_fields,
3901        clippy::style
3902    )]
3903    const _: () = {
3904        use alloy::sol_types as alloy_sol_types;
3905        #[doc(hidden)]
3906        type UnderlyingSolTuple<'a> = ();
3907        #[doc(hidden)]
3908        type UnderlyingRustTuple<'a> = ();
3909        #[cfg(test)]
3910        #[allow(dead_code, unreachable_patterns)]
3911        fn _type_assertion(
3912            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3913        ) {
3914            match _t {
3915                alloy_sol_types::private::AssertTypeEq::<
3916                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3917                >(_) => {}
3918            }
3919        }
3920        #[automatically_derived]
3921        #[doc(hidden)]
3922        impl ::core::convert::From<InvalidCaller> for UnderlyingRustTuple<'_> {
3923            fn from(value: InvalidCaller) -> Self {
3924                ()
3925            }
3926        }
3927        #[automatically_derived]
3928        #[doc(hidden)]
3929        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidCaller {
3930            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3931                Self
3932            }
3933        }
3934        #[automatically_derived]
3935        impl alloy_sol_types::SolError for InvalidCaller {
3936            type Parameters<'a> = UnderlyingSolTuple<'a>;
3937            type Token<'a> = <Self::Parameters<
3938                'a,
3939            > as alloy_sol_types::SolType>::Token<'a>;
3940            const SIGNATURE: &'static str = "InvalidCaller()";
3941            const SELECTOR: [u8; 4] = [72u8, 245u8, 195u8, 237u8];
3942            #[inline]
3943            fn new<'a>(
3944                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3945            ) -> Self {
3946                tuple.into()
3947            }
3948            #[inline]
3949            fn tokenize(&self) -> Self::Token<'_> {
3950                ()
3951            }
3952            #[inline]
3953            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
3954                <Self::Parameters<
3955                    '_,
3956                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3957                    .map(Self::new)
3958            }
3959        }
3960    };
3961    #[derive(serde::Serialize, serde::Deserialize)]
3962    #[derive(Default, Debug, PartialEq, Eq, Hash)]
3963    /**Custom error with signature `InvalidOperator()` and selector `0xccea9e6f`.
3964```solidity
3965error InvalidOperator();
3966```*/
3967    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3968    #[derive(Clone)]
3969    pub struct InvalidOperator;
3970    #[allow(
3971        non_camel_case_types,
3972        non_snake_case,
3973        clippy::pub_underscore_fields,
3974        clippy::style
3975    )]
3976    const _: () = {
3977        use alloy::sol_types as alloy_sol_types;
3978        #[doc(hidden)]
3979        type UnderlyingSolTuple<'a> = ();
3980        #[doc(hidden)]
3981        type UnderlyingRustTuple<'a> = ();
3982        #[cfg(test)]
3983        #[allow(dead_code, unreachable_patterns)]
3984        fn _type_assertion(
3985            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3986        ) {
3987            match _t {
3988                alloy_sol_types::private::AssertTypeEq::<
3989                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3990                >(_) => {}
3991            }
3992        }
3993        #[automatically_derived]
3994        #[doc(hidden)]
3995        impl ::core::convert::From<InvalidOperator> for UnderlyingRustTuple<'_> {
3996            fn from(value: InvalidOperator) -> Self {
3997                ()
3998            }
3999        }
4000        #[automatically_derived]
4001        #[doc(hidden)]
4002        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidOperator {
4003            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4004                Self
4005            }
4006        }
4007        #[automatically_derived]
4008        impl alloy_sol_types::SolError for InvalidOperator {
4009            type Parameters<'a> = UnderlyingSolTuple<'a>;
4010            type Token<'a> = <Self::Parameters<
4011                'a,
4012            > as alloy_sol_types::SolType>::Token<'a>;
4013            const SIGNATURE: &'static str = "InvalidOperator()";
4014            const SELECTOR: [u8; 4] = [204u8, 234u8, 158u8, 111u8];
4015            #[inline]
4016            fn new<'a>(
4017                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4018            ) -> Self {
4019                tuple.into()
4020            }
4021            #[inline]
4022            fn tokenize(&self) -> Self::Token<'_> {
4023                ()
4024            }
4025            #[inline]
4026            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4027                <Self::Parameters<
4028                    '_,
4029                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4030                    .map(Self::new)
4031            }
4032        }
4033    };
4034    #[derive(serde::Serialize, serde::Deserialize)]
4035    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4036    /**Custom error with signature `InvalidOperatorSet()` and selector `0x7ec5c154`.
4037```solidity
4038error InvalidOperatorSet();
4039```*/
4040    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4041    #[derive(Clone)]
4042    pub struct InvalidOperatorSet;
4043    #[allow(
4044        non_camel_case_types,
4045        non_snake_case,
4046        clippy::pub_underscore_fields,
4047        clippy::style
4048    )]
4049    const _: () = {
4050        use alloy::sol_types as alloy_sol_types;
4051        #[doc(hidden)]
4052        type UnderlyingSolTuple<'a> = ();
4053        #[doc(hidden)]
4054        type UnderlyingRustTuple<'a> = ();
4055        #[cfg(test)]
4056        #[allow(dead_code, unreachable_patterns)]
4057        fn _type_assertion(
4058            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4059        ) {
4060            match _t {
4061                alloy_sol_types::private::AssertTypeEq::<
4062                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4063                >(_) => {}
4064            }
4065        }
4066        #[automatically_derived]
4067        #[doc(hidden)]
4068        impl ::core::convert::From<InvalidOperatorSet> for UnderlyingRustTuple<'_> {
4069            fn from(value: InvalidOperatorSet) -> Self {
4070                ()
4071            }
4072        }
4073        #[automatically_derived]
4074        #[doc(hidden)]
4075        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidOperatorSet {
4076            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4077                Self
4078            }
4079        }
4080        #[automatically_derived]
4081        impl alloy_sol_types::SolError for InvalidOperatorSet {
4082            type Parameters<'a> = UnderlyingSolTuple<'a>;
4083            type Token<'a> = <Self::Parameters<
4084                'a,
4085            > as alloy_sol_types::SolType>::Token<'a>;
4086            const SIGNATURE: &'static str = "InvalidOperatorSet()";
4087            const SELECTOR: [u8; 4] = [126u8, 197u8, 193u8, 84u8];
4088            #[inline]
4089            fn new<'a>(
4090                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4091            ) -> Self {
4092                tuple.into()
4093            }
4094            #[inline]
4095            fn tokenize(&self) -> Self::Token<'_> {
4096                ()
4097            }
4098            #[inline]
4099            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4100                <Self::Parameters<
4101                    '_,
4102                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4103                    .map(Self::new)
4104            }
4105        }
4106    };
4107    #[derive(serde::Serialize, serde::Deserialize)]
4108    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4109    /**Custom error with signature `InvalidWadToSlash()` and selector `0x13536031`.
4110```solidity
4111error InvalidWadToSlash();
4112```*/
4113    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4114    #[derive(Clone)]
4115    pub struct InvalidWadToSlash;
4116    #[allow(
4117        non_camel_case_types,
4118        non_snake_case,
4119        clippy::pub_underscore_fields,
4120        clippy::style
4121    )]
4122    const _: () = {
4123        use alloy::sol_types as alloy_sol_types;
4124        #[doc(hidden)]
4125        type UnderlyingSolTuple<'a> = ();
4126        #[doc(hidden)]
4127        type UnderlyingRustTuple<'a> = ();
4128        #[cfg(test)]
4129        #[allow(dead_code, unreachable_patterns)]
4130        fn _type_assertion(
4131            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4132        ) {
4133            match _t {
4134                alloy_sol_types::private::AssertTypeEq::<
4135                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4136                >(_) => {}
4137            }
4138        }
4139        #[automatically_derived]
4140        #[doc(hidden)]
4141        impl ::core::convert::From<InvalidWadToSlash> for UnderlyingRustTuple<'_> {
4142            fn from(value: InvalidWadToSlash) -> Self {
4143                ()
4144            }
4145        }
4146        #[automatically_derived]
4147        #[doc(hidden)]
4148        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidWadToSlash {
4149            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4150                Self
4151            }
4152        }
4153        #[automatically_derived]
4154        impl alloy_sol_types::SolError for InvalidWadToSlash {
4155            type Parameters<'a> = UnderlyingSolTuple<'a>;
4156            type Token<'a> = <Self::Parameters<
4157                'a,
4158            > as alloy_sol_types::SolType>::Token<'a>;
4159            const SIGNATURE: &'static str = "InvalidWadToSlash()";
4160            const SELECTOR: [u8; 4] = [19u8, 83u8, 96u8, 49u8];
4161            #[inline]
4162            fn new<'a>(
4163                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4164            ) -> Self {
4165                tuple.into()
4166            }
4167            #[inline]
4168            fn tokenize(&self) -> Self::Token<'_> {
4169                ()
4170            }
4171            #[inline]
4172            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4173                <Self::Parameters<
4174                    '_,
4175                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4176                    .map(Self::new)
4177            }
4178        }
4179    };
4180    #[derive(serde::Serialize, serde::Deserialize)]
4181    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4182    /**Custom error with signature `ModificationAlreadyPending()` and selector `0xd8fcbe30`.
4183```solidity
4184error ModificationAlreadyPending();
4185```*/
4186    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4187    #[derive(Clone)]
4188    pub struct ModificationAlreadyPending;
4189    #[allow(
4190        non_camel_case_types,
4191        non_snake_case,
4192        clippy::pub_underscore_fields,
4193        clippy::style
4194    )]
4195    const _: () = {
4196        use alloy::sol_types as alloy_sol_types;
4197        #[doc(hidden)]
4198        type UnderlyingSolTuple<'a> = ();
4199        #[doc(hidden)]
4200        type UnderlyingRustTuple<'a> = ();
4201        #[cfg(test)]
4202        #[allow(dead_code, unreachable_patterns)]
4203        fn _type_assertion(
4204            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4205        ) {
4206            match _t {
4207                alloy_sol_types::private::AssertTypeEq::<
4208                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4209                >(_) => {}
4210            }
4211        }
4212        #[automatically_derived]
4213        #[doc(hidden)]
4214        impl ::core::convert::From<ModificationAlreadyPending>
4215        for UnderlyingRustTuple<'_> {
4216            fn from(value: ModificationAlreadyPending) -> Self {
4217                ()
4218            }
4219        }
4220        #[automatically_derived]
4221        #[doc(hidden)]
4222        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4223        for ModificationAlreadyPending {
4224            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4225                Self
4226            }
4227        }
4228        #[automatically_derived]
4229        impl alloy_sol_types::SolError for ModificationAlreadyPending {
4230            type Parameters<'a> = UnderlyingSolTuple<'a>;
4231            type Token<'a> = <Self::Parameters<
4232                'a,
4233            > as alloy_sol_types::SolType>::Token<'a>;
4234            const SIGNATURE: &'static str = "ModificationAlreadyPending()";
4235            const SELECTOR: [u8; 4] = [216u8, 252u8, 190u8, 48u8];
4236            #[inline]
4237            fn new<'a>(
4238                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4239            ) -> Self {
4240                tuple.into()
4241            }
4242            #[inline]
4243            fn tokenize(&self) -> Self::Token<'_> {
4244                ()
4245            }
4246            #[inline]
4247            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4248                <Self::Parameters<
4249                    '_,
4250                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4251                    .map(Self::new)
4252            }
4253        }
4254    };
4255    #[derive(serde::Serialize, serde::Deserialize)]
4256    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4257    /**Custom error with signature `NonexistentAVSMetadata()` and selector `0x48f7dbb9`.
4258```solidity
4259error NonexistentAVSMetadata();
4260```*/
4261    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4262    #[derive(Clone)]
4263    pub struct NonexistentAVSMetadata;
4264    #[allow(
4265        non_camel_case_types,
4266        non_snake_case,
4267        clippy::pub_underscore_fields,
4268        clippy::style
4269    )]
4270    const _: () = {
4271        use alloy::sol_types as alloy_sol_types;
4272        #[doc(hidden)]
4273        type UnderlyingSolTuple<'a> = ();
4274        #[doc(hidden)]
4275        type UnderlyingRustTuple<'a> = ();
4276        #[cfg(test)]
4277        #[allow(dead_code, unreachable_patterns)]
4278        fn _type_assertion(
4279            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4280        ) {
4281            match _t {
4282                alloy_sol_types::private::AssertTypeEq::<
4283                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4284                >(_) => {}
4285            }
4286        }
4287        #[automatically_derived]
4288        #[doc(hidden)]
4289        impl ::core::convert::From<NonexistentAVSMetadata> for UnderlyingRustTuple<'_> {
4290            fn from(value: NonexistentAVSMetadata) -> Self {
4291                ()
4292            }
4293        }
4294        #[automatically_derived]
4295        #[doc(hidden)]
4296        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NonexistentAVSMetadata {
4297            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4298                Self
4299            }
4300        }
4301        #[automatically_derived]
4302        impl alloy_sol_types::SolError for NonexistentAVSMetadata {
4303            type Parameters<'a> = UnderlyingSolTuple<'a>;
4304            type Token<'a> = <Self::Parameters<
4305                'a,
4306            > as alloy_sol_types::SolType>::Token<'a>;
4307            const SIGNATURE: &'static str = "NonexistentAVSMetadata()";
4308            const SELECTOR: [u8; 4] = [72u8, 247u8, 219u8, 185u8];
4309            #[inline]
4310            fn new<'a>(
4311                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4312            ) -> Self {
4313                tuple.into()
4314            }
4315            #[inline]
4316            fn tokenize(&self) -> Self::Token<'_> {
4317                ()
4318            }
4319            #[inline]
4320            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4321                <Self::Parameters<
4322                    '_,
4323                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4324                    .map(Self::new)
4325            }
4326        }
4327    };
4328    #[derive(serde::Serialize, serde::Deserialize)]
4329    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4330    /**Custom error with signature `NotMemberOfSet()` and selector `0x25131d4f`.
4331```solidity
4332error NotMemberOfSet();
4333```*/
4334    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4335    #[derive(Clone)]
4336    pub struct NotMemberOfSet;
4337    #[allow(
4338        non_camel_case_types,
4339        non_snake_case,
4340        clippy::pub_underscore_fields,
4341        clippy::style
4342    )]
4343    const _: () = {
4344        use alloy::sol_types as alloy_sol_types;
4345        #[doc(hidden)]
4346        type UnderlyingSolTuple<'a> = ();
4347        #[doc(hidden)]
4348        type UnderlyingRustTuple<'a> = ();
4349        #[cfg(test)]
4350        #[allow(dead_code, unreachable_patterns)]
4351        fn _type_assertion(
4352            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4353        ) {
4354            match _t {
4355                alloy_sol_types::private::AssertTypeEq::<
4356                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4357                >(_) => {}
4358            }
4359        }
4360        #[automatically_derived]
4361        #[doc(hidden)]
4362        impl ::core::convert::From<NotMemberOfSet> for UnderlyingRustTuple<'_> {
4363            fn from(value: NotMemberOfSet) -> Self {
4364                ()
4365            }
4366        }
4367        #[automatically_derived]
4368        #[doc(hidden)]
4369        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotMemberOfSet {
4370            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4371                Self
4372            }
4373        }
4374        #[automatically_derived]
4375        impl alloy_sol_types::SolError for NotMemberOfSet {
4376            type Parameters<'a> = UnderlyingSolTuple<'a>;
4377            type Token<'a> = <Self::Parameters<
4378                'a,
4379            > as alloy_sol_types::SolType>::Token<'a>;
4380            const SIGNATURE: &'static str = "NotMemberOfSet()";
4381            const SELECTOR: [u8; 4] = [37u8, 19u8, 29u8, 79u8];
4382            #[inline]
4383            fn new<'a>(
4384                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4385            ) -> Self {
4386                tuple.into()
4387            }
4388            #[inline]
4389            fn tokenize(&self) -> Self::Token<'_> {
4390                ()
4391            }
4392            #[inline]
4393            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4394                <Self::Parameters<
4395                    '_,
4396                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4397                    .map(Self::new)
4398            }
4399        }
4400    };
4401    #[derive(serde::Serialize, serde::Deserialize)]
4402    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4403    /**Custom error with signature `OperatorNotSlashable()` and selector `0xebbff497`.
4404```solidity
4405error OperatorNotSlashable();
4406```*/
4407    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4408    #[derive(Clone)]
4409    pub struct OperatorNotSlashable;
4410    #[allow(
4411        non_camel_case_types,
4412        non_snake_case,
4413        clippy::pub_underscore_fields,
4414        clippy::style
4415    )]
4416    const _: () = {
4417        use alloy::sol_types as alloy_sol_types;
4418        #[doc(hidden)]
4419        type UnderlyingSolTuple<'a> = ();
4420        #[doc(hidden)]
4421        type UnderlyingRustTuple<'a> = ();
4422        #[cfg(test)]
4423        #[allow(dead_code, unreachable_patterns)]
4424        fn _type_assertion(
4425            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4426        ) {
4427            match _t {
4428                alloy_sol_types::private::AssertTypeEq::<
4429                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4430                >(_) => {}
4431            }
4432        }
4433        #[automatically_derived]
4434        #[doc(hidden)]
4435        impl ::core::convert::From<OperatorNotSlashable> for UnderlyingRustTuple<'_> {
4436            fn from(value: OperatorNotSlashable) -> Self {
4437                ()
4438            }
4439        }
4440        #[automatically_derived]
4441        #[doc(hidden)]
4442        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OperatorNotSlashable {
4443            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4444                Self
4445            }
4446        }
4447        #[automatically_derived]
4448        impl alloy_sol_types::SolError for OperatorNotSlashable {
4449            type Parameters<'a> = UnderlyingSolTuple<'a>;
4450            type Token<'a> = <Self::Parameters<
4451                'a,
4452            > as alloy_sol_types::SolType>::Token<'a>;
4453            const SIGNATURE: &'static str = "OperatorNotSlashable()";
4454            const SELECTOR: [u8; 4] = [235u8, 191u8, 244u8, 151u8];
4455            #[inline]
4456            fn new<'a>(
4457                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4458            ) -> Self {
4459                tuple.into()
4460            }
4461            #[inline]
4462            fn tokenize(&self) -> Self::Token<'_> {
4463                ()
4464            }
4465            #[inline]
4466            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4467                <Self::Parameters<
4468                    '_,
4469                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4470                    .map(Self::new)
4471            }
4472        }
4473    };
4474    #[derive(serde::Serialize, serde::Deserialize)]
4475    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4476    /**Custom error with signature `SameMagnitude()` and selector `0x8c0c2f26`.
4477```solidity
4478error SameMagnitude();
4479```*/
4480    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4481    #[derive(Clone)]
4482    pub struct SameMagnitude;
4483    #[allow(
4484        non_camel_case_types,
4485        non_snake_case,
4486        clippy::pub_underscore_fields,
4487        clippy::style
4488    )]
4489    const _: () = {
4490        use alloy::sol_types as alloy_sol_types;
4491        #[doc(hidden)]
4492        type UnderlyingSolTuple<'a> = ();
4493        #[doc(hidden)]
4494        type UnderlyingRustTuple<'a> = ();
4495        #[cfg(test)]
4496        #[allow(dead_code, unreachable_patterns)]
4497        fn _type_assertion(
4498            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4499        ) {
4500            match _t {
4501                alloy_sol_types::private::AssertTypeEq::<
4502                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4503                >(_) => {}
4504            }
4505        }
4506        #[automatically_derived]
4507        #[doc(hidden)]
4508        impl ::core::convert::From<SameMagnitude> for UnderlyingRustTuple<'_> {
4509            fn from(value: SameMagnitude) -> Self {
4510                ()
4511            }
4512        }
4513        #[automatically_derived]
4514        #[doc(hidden)]
4515        impl ::core::convert::From<UnderlyingRustTuple<'_>> for SameMagnitude {
4516            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4517                Self
4518            }
4519        }
4520        #[automatically_derived]
4521        impl alloy_sol_types::SolError for SameMagnitude {
4522            type Parameters<'a> = UnderlyingSolTuple<'a>;
4523            type Token<'a> = <Self::Parameters<
4524                'a,
4525            > as alloy_sol_types::SolType>::Token<'a>;
4526            const SIGNATURE: &'static str = "SameMagnitude()";
4527            const SELECTOR: [u8; 4] = [140u8, 12u8, 47u8, 38u8];
4528            #[inline]
4529            fn new<'a>(
4530                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4531            ) -> Self {
4532                tuple.into()
4533            }
4534            #[inline]
4535            fn tokenize(&self) -> Self::Token<'_> {
4536                ()
4537            }
4538            #[inline]
4539            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4540                <Self::Parameters<
4541                    '_,
4542                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4543                    .map(Self::new)
4544            }
4545        }
4546    };
4547    #[derive(serde::Serialize, serde::Deserialize)]
4548    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4549    /**Custom error with signature `StrategiesMustBeInAscendingOrder()` and selector `0x9f1c8053`.
4550```solidity
4551error StrategiesMustBeInAscendingOrder();
4552```*/
4553    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4554    #[derive(Clone)]
4555    pub struct StrategiesMustBeInAscendingOrder;
4556    #[allow(
4557        non_camel_case_types,
4558        non_snake_case,
4559        clippy::pub_underscore_fields,
4560        clippy::style
4561    )]
4562    const _: () = {
4563        use alloy::sol_types as alloy_sol_types;
4564        #[doc(hidden)]
4565        type UnderlyingSolTuple<'a> = ();
4566        #[doc(hidden)]
4567        type UnderlyingRustTuple<'a> = ();
4568        #[cfg(test)]
4569        #[allow(dead_code, unreachable_patterns)]
4570        fn _type_assertion(
4571            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4572        ) {
4573            match _t {
4574                alloy_sol_types::private::AssertTypeEq::<
4575                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4576                >(_) => {}
4577            }
4578        }
4579        #[automatically_derived]
4580        #[doc(hidden)]
4581        impl ::core::convert::From<StrategiesMustBeInAscendingOrder>
4582        for UnderlyingRustTuple<'_> {
4583            fn from(value: StrategiesMustBeInAscendingOrder) -> Self {
4584                ()
4585            }
4586        }
4587        #[automatically_derived]
4588        #[doc(hidden)]
4589        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4590        for StrategiesMustBeInAscendingOrder {
4591            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4592                Self
4593            }
4594        }
4595        #[automatically_derived]
4596        impl alloy_sol_types::SolError for StrategiesMustBeInAscendingOrder {
4597            type Parameters<'a> = UnderlyingSolTuple<'a>;
4598            type Token<'a> = <Self::Parameters<
4599                'a,
4600            > as alloy_sol_types::SolType>::Token<'a>;
4601            const SIGNATURE: &'static str = "StrategiesMustBeInAscendingOrder()";
4602            const SELECTOR: [u8; 4] = [159u8, 28u8, 128u8, 83u8];
4603            #[inline]
4604            fn new<'a>(
4605                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4606            ) -> Self {
4607                tuple.into()
4608            }
4609            #[inline]
4610            fn tokenize(&self) -> Self::Token<'_> {
4611                ()
4612            }
4613            #[inline]
4614            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4615                <Self::Parameters<
4616                    '_,
4617                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4618                    .map(Self::new)
4619            }
4620        }
4621    };
4622    #[derive(serde::Serialize, serde::Deserialize)]
4623    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4624    /**Custom error with signature `StrategyAlreadyInOperatorSet()` and selector `0x585cfb2f`.
4625```solidity
4626error StrategyAlreadyInOperatorSet();
4627```*/
4628    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4629    #[derive(Clone)]
4630    pub struct StrategyAlreadyInOperatorSet;
4631    #[allow(
4632        non_camel_case_types,
4633        non_snake_case,
4634        clippy::pub_underscore_fields,
4635        clippy::style
4636    )]
4637    const _: () = {
4638        use alloy::sol_types as alloy_sol_types;
4639        #[doc(hidden)]
4640        type UnderlyingSolTuple<'a> = ();
4641        #[doc(hidden)]
4642        type UnderlyingRustTuple<'a> = ();
4643        #[cfg(test)]
4644        #[allow(dead_code, unreachable_patterns)]
4645        fn _type_assertion(
4646            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4647        ) {
4648            match _t {
4649                alloy_sol_types::private::AssertTypeEq::<
4650                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4651                >(_) => {}
4652            }
4653        }
4654        #[automatically_derived]
4655        #[doc(hidden)]
4656        impl ::core::convert::From<StrategyAlreadyInOperatorSet>
4657        for UnderlyingRustTuple<'_> {
4658            fn from(value: StrategyAlreadyInOperatorSet) -> Self {
4659                ()
4660            }
4661        }
4662        #[automatically_derived]
4663        #[doc(hidden)]
4664        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4665        for StrategyAlreadyInOperatorSet {
4666            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4667                Self
4668            }
4669        }
4670        #[automatically_derived]
4671        impl alloy_sol_types::SolError for StrategyAlreadyInOperatorSet {
4672            type Parameters<'a> = UnderlyingSolTuple<'a>;
4673            type Token<'a> = <Self::Parameters<
4674                'a,
4675            > as alloy_sol_types::SolType>::Token<'a>;
4676            const SIGNATURE: &'static str = "StrategyAlreadyInOperatorSet()";
4677            const SELECTOR: [u8; 4] = [88u8, 92u8, 251u8, 47u8];
4678            #[inline]
4679            fn new<'a>(
4680                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4681            ) -> Self {
4682                tuple.into()
4683            }
4684            #[inline]
4685            fn tokenize(&self) -> Self::Token<'_> {
4686                ()
4687            }
4688            #[inline]
4689            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4690                <Self::Parameters<
4691                    '_,
4692                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4693                    .map(Self::new)
4694            }
4695        }
4696    };
4697    #[derive(serde::Serialize, serde::Deserialize)]
4698    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4699    /**Custom error with signature `StrategyNotInOperatorSet()` and selector `0x6378684e`.
4700```solidity
4701error StrategyNotInOperatorSet();
4702```*/
4703    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4704    #[derive(Clone)]
4705    pub struct StrategyNotInOperatorSet;
4706    #[allow(
4707        non_camel_case_types,
4708        non_snake_case,
4709        clippy::pub_underscore_fields,
4710        clippy::style
4711    )]
4712    const _: () = {
4713        use alloy::sol_types as alloy_sol_types;
4714        #[doc(hidden)]
4715        type UnderlyingSolTuple<'a> = ();
4716        #[doc(hidden)]
4717        type UnderlyingRustTuple<'a> = ();
4718        #[cfg(test)]
4719        #[allow(dead_code, unreachable_patterns)]
4720        fn _type_assertion(
4721            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4722        ) {
4723            match _t {
4724                alloy_sol_types::private::AssertTypeEq::<
4725                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4726                >(_) => {}
4727            }
4728        }
4729        #[automatically_derived]
4730        #[doc(hidden)]
4731        impl ::core::convert::From<StrategyNotInOperatorSet>
4732        for UnderlyingRustTuple<'_> {
4733            fn from(value: StrategyNotInOperatorSet) -> Self {
4734                ()
4735            }
4736        }
4737        #[automatically_derived]
4738        #[doc(hidden)]
4739        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4740        for StrategyNotInOperatorSet {
4741            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4742                Self
4743            }
4744        }
4745        #[automatically_derived]
4746        impl alloy_sol_types::SolError for StrategyNotInOperatorSet {
4747            type Parameters<'a> = UnderlyingSolTuple<'a>;
4748            type Token<'a> = <Self::Parameters<
4749                'a,
4750            > as alloy_sol_types::SolType>::Token<'a>;
4751            const SIGNATURE: &'static str = "StrategyNotInOperatorSet()";
4752            const SELECTOR: [u8; 4] = [99u8, 120u8, 104u8, 78u8];
4753            #[inline]
4754            fn new<'a>(
4755                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4756            ) -> Self {
4757                tuple.into()
4758            }
4759            #[inline]
4760            fn tokenize(&self) -> Self::Token<'_> {
4761                ()
4762            }
4763            #[inline]
4764            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4765                <Self::Parameters<
4766                    '_,
4767                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4768                    .map(Self::new)
4769            }
4770        }
4771    };
4772    #[derive(serde::Serialize, serde::Deserialize)]
4773    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4774    /**Custom error with signature `UninitializedAllocationDelay()` and selector `0xfa55fc81`.
4775```solidity
4776error UninitializedAllocationDelay();
4777```*/
4778    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4779    #[derive(Clone)]
4780    pub struct UninitializedAllocationDelay;
4781    #[allow(
4782        non_camel_case_types,
4783        non_snake_case,
4784        clippy::pub_underscore_fields,
4785        clippy::style
4786    )]
4787    const _: () = {
4788        use alloy::sol_types as alloy_sol_types;
4789        #[doc(hidden)]
4790        type UnderlyingSolTuple<'a> = ();
4791        #[doc(hidden)]
4792        type UnderlyingRustTuple<'a> = ();
4793        #[cfg(test)]
4794        #[allow(dead_code, unreachable_patterns)]
4795        fn _type_assertion(
4796            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4797        ) {
4798            match _t {
4799                alloy_sol_types::private::AssertTypeEq::<
4800                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4801                >(_) => {}
4802            }
4803        }
4804        #[automatically_derived]
4805        #[doc(hidden)]
4806        impl ::core::convert::From<UninitializedAllocationDelay>
4807        for UnderlyingRustTuple<'_> {
4808            fn from(value: UninitializedAllocationDelay) -> Self {
4809                ()
4810            }
4811        }
4812        #[automatically_derived]
4813        #[doc(hidden)]
4814        impl ::core::convert::From<UnderlyingRustTuple<'_>>
4815        for UninitializedAllocationDelay {
4816            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4817                Self
4818            }
4819        }
4820        #[automatically_derived]
4821        impl alloy_sol_types::SolError for UninitializedAllocationDelay {
4822            type Parameters<'a> = UnderlyingSolTuple<'a>;
4823            type Token<'a> = <Self::Parameters<
4824                'a,
4825            > as alloy_sol_types::SolType>::Token<'a>;
4826            const SIGNATURE: &'static str = "UninitializedAllocationDelay()";
4827            const SELECTOR: [u8; 4] = [250u8, 85u8, 252u8, 129u8];
4828            #[inline]
4829            fn new<'a>(
4830                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4831            ) -> Self {
4832                tuple.into()
4833            }
4834            #[inline]
4835            fn tokenize(&self) -> Self::Token<'_> {
4836                ()
4837            }
4838            #[inline]
4839            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
4840                <Self::Parameters<
4841                    '_,
4842                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4843                    .map(Self::new)
4844            }
4845        }
4846    };
4847    #[derive(serde::Serialize, serde::Deserialize)]
4848    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4849    /**Event with signature `AVSMetadataURIUpdated(address,string)` and selector `0xa89c1dc243d8908a96dd84944bcc97d6bc6ac00dd78e20621576be6a3c943713`.
4850```solidity
4851event AVSMetadataURIUpdated(address indexed avs, string metadataURI);
4852```*/
4853    #[allow(
4854        non_camel_case_types,
4855        non_snake_case,
4856        clippy::pub_underscore_fields,
4857        clippy::style
4858    )]
4859    #[derive(Clone)]
4860    pub struct AVSMetadataURIUpdated {
4861        #[allow(missing_docs)]
4862        pub avs: alloy::sol_types::private::Address,
4863        #[allow(missing_docs)]
4864        pub metadataURI: alloy::sol_types::private::String,
4865    }
4866    #[allow(
4867        non_camel_case_types,
4868        non_snake_case,
4869        clippy::pub_underscore_fields,
4870        clippy::style
4871    )]
4872    const _: () = {
4873        use alloy::sol_types as alloy_sol_types;
4874        #[automatically_derived]
4875        impl alloy_sol_types::SolEvent for AVSMetadataURIUpdated {
4876            type DataTuple<'a> = (alloy::sol_types::sol_data::String,);
4877            type DataToken<'a> = <Self::DataTuple<
4878                'a,
4879            > as alloy_sol_types::SolType>::Token<'a>;
4880            type TopicList = (
4881                alloy_sol_types::sol_data::FixedBytes<32>,
4882                alloy::sol_types::sol_data::Address,
4883            );
4884            const SIGNATURE: &'static str = "AVSMetadataURIUpdated(address,string)";
4885            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
4886                168u8, 156u8, 29u8, 194u8, 67u8, 216u8, 144u8, 138u8, 150u8, 221u8,
4887                132u8, 148u8, 75u8, 204u8, 151u8, 214u8, 188u8, 106u8, 192u8, 13u8,
4888                215u8, 142u8, 32u8, 98u8, 21u8, 118u8, 190u8, 106u8, 60u8, 148u8, 55u8,
4889                19u8,
4890            ]);
4891            const ANONYMOUS: bool = false;
4892            #[allow(unused_variables)]
4893            #[inline]
4894            fn new(
4895                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
4896                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
4897            ) -> Self {
4898                Self {
4899                    avs: topics.1,
4900                    metadataURI: data.0,
4901                }
4902            }
4903            #[inline]
4904            fn check_signature(
4905                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
4906            ) -> alloy_sol_types::Result<()> {
4907                if topics.0 != Self::SIGNATURE_HASH {
4908                    return Err(
4909                        alloy_sol_types::Error::invalid_event_signature_hash(
4910                            Self::SIGNATURE,
4911                            topics.0,
4912                            Self::SIGNATURE_HASH,
4913                        ),
4914                    );
4915                }
4916                Ok(())
4917            }
4918            #[inline]
4919            fn tokenize_body(&self) -> Self::DataToken<'_> {
4920                (
4921                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
4922                        &self.metadataURI,
4923                    ),
4924                )
4925            }
4926            #[inline]
4927            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
4928                (Self::SIGNATURE_HASH.into(), self.avs.clone())
4929            }
4930            #[inline]
4931            fn encode_topics_raw(
4932                &self,
4933                out: &mut [alloy_sol_types::abi::token::WordToken],
4934            ) -> alloy_sol_types::Result<()> {
4935                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
4936                    return Err(alloy_sol_types::Error::Overrun);
4937                }
4938                out[0usize] = alloy_sol_types::abi::token::WordToken(
4939                    Self::SIGNATURE_HASH,
4940                );
4941                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
4942                    &self.avs,
4943                );
4944                Ok(())
4945            }
4946        }
4947        #[automatically_derived]
4948        impl alloy_sol_types::private::IntoLogData for AVSMetadataURIUpdated {
4949            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4950                From::from(self)
4951            }
4952            fn into_log_data(self) -> alloy_sol_types::private::LogData {
4953                From::from(&self)
4954            }
4955        }
4956        #[automatically_derived]
4957        impl From<&AVSMetadataURIUpdated> for alloy_sol_types::private::LogData {
4958            #[inline]
4959            fn from(this: &AVSMetadataURIUpdated) -> alloy_sol_types::private::LogData {
4960                alloy_sol_types::SolEvent::encode_log_data(this)
4961            }
4962        }
4963    };
4964    #[derive(serde::Serialize, serde::Deserialize)]
4965    #[derive(Default, Debug, PartialEq, Eq, Hash)]
4966    /**Event with signature `AVSRegistrarSet(address,address)` and selector `0x2ae945c40c44dc0ec263f95609c3fdc6952e0aefa22d6374e44f2c997acedf85`.
4967```solidity
4968event AVSRegistrarSet(address avs, address registrar);
4969```*/
4970    #[allow(
4971        non_camel_case_types,
4972        non_snake_case,
4973        clippy::pub_underscore_fields,
4974        clippy::style
4975    )]
4976    #[derive(Clone)]
4977    pub struct AVSRegistrarSet {
4978        #[allow(missing_docs)]
4979        pub avs: alloy::sol_types::private::Address,
4980        #[allow(missing_docs)]
4981        pub registrar: alloy::sol_types::private::Address,
4982    }
4983    #[allow(
4984        non_camel_case_types,
4985        non_snake_case,
4986        clippy::pub_underscore_fields,
4987        clippy::style
4988    )]
4989    const _: () = {
4990        use alloy::sol_types as alloy_sol_types;
4991        #[automatically_derived]
4992        impl alloy_sol_types::SolEvent for AVSRegistrarSet {
4993            type DataTuple<'a> = (
4994                alloy::sol_types::sol_data::Address,
4995                alloy::sol_types::sol_data::Address,
4996            );
4997            type DataToken<'a> = <Self::DataTuple<
4998                'a,
4999            > as alloy_sol_types::SolType>::Token<'a>;
5000            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5001            const SIGNATURE: &'static str = "AVSRegistrarSet(address,address)";
5002            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5003                42u8, 233u8, 69u8, 196u8, 12u8, 68u8, 220u8, 14u8, 194u8, 99u8, 249u8,
5004                86u8, 9u8, 195u8, 253u8, 198u8, 149u8, 46u8, 10u8, 239u8, 162u8, 45u8,
5005                99u8, 116u8, 228u8, 79u8, 44u8, 153u8, 122u8, 206u8, 223u8, 133u8,
5006            ]);
5007            const ANONYMOUS: bool = false;
5008            #[allow(unused_variables)]
5009            #[inline]
5010            fn new(
5011                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5012                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5013            ) -> Self {
5014                Self {
5015                    avs: data.0,
5016                    registrar: data.1,
5017                }
5018            }
5019            #[inline]
5020            fn check_signature(
5021                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5022            ) -> alloy_sol_types::Result<()> {
5023                if topics.0 != Self::SIGNATURE_HASH {
5024                    return Err(
5025                        alloy_sol_types::Error::invalid_event_signature_hash(
5026                            Self::SIGNATURE,
5027                            topics.0,
5028                            Self::SIGNATURE_HASH,
5029                        ),
5030                    );
5031                }
5032                Ok(())
5033            }
5034            #[inline]
5035            fn tokenize_body(&self) -> Self::DataToken<'_> {
5036                (
5037                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5038                        &self.avs,
5039                    ),
5040                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5041                        &self.registrar,
5042                    ),
5043                )
5044            }
5045            #[inline]
5046            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5047                (Self::SIGNATURE_HASH.into(),)
5048            }
5049            #[inline]
5050            fn encode_topics_raw(
5051                &self,
5052                out: &mut [alloy_sol_types::abi::token::WordToken],
5053            ) -> alloy_sol_types::Result<()> {
5054                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5055                    return Err(alloy_sol_types::Error::Overrun);
5056                }
5057                out[0usize] = alloy_sol_types::abi::token::WordToken(
5058                    Self::SIGNATURE_HASH,
5059                );
5060                Ok(())
5061            }
5062        }
5063        #[automatically_derived]
5064        impl alloy_sol_types::private::IntoLogData for AVSRegistrarSet {
5065            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5066                From::from(self)
5067            }
5068            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5069                From::from(&self)
5070            }
5071        }
5072        #[automatically_derived]
5073        impl From<&AVSRegistrarSet> for alloy_sol_types::private::LogData {
5074            #[inline]
5075            fn from(this: &AVSRegistrarSet) -> alloy_sol_types::private::LogData {
5076                alloy_sol_types::SolEvent::encode_log_data(this)
5077            }
5078        }
5079    };
5080    #[derive(serde::Serialize, serde::Deserialize)]
5081    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5082    /**Event with signature `AllocationDelaySet(address,uint32,uint32)` and selector `0x4e85751d6331506c6c62335f207eb31f12a61e570f34f5c17640308785c6d4db`.
5083```solidity
5084event AllocationDelaySet(address operator, uint32 delay, uint32 effectBlock);
5085```*/
5086    #[allow(
5087        non_camel_case_types,
5088        non_snake_case,
5089        clippy::pub_underscore_fields,
5090        clippy::style
5091    )]
5092    #[derive(Clone)]
5093    pub struct AllocationDelaySet {
5094        #[allow(missing_docs)]
5095        pub operator: alloy::sol_types::private::Address,
5096        #[allow(missing_docs)]
5097        pub delay: u32,
5098        #[allow(missing_docs)]
5099        pub effectBlock: u32,
5100    }
5101    #[allow(
5102        non_camel_case_types,
5103        non_snake_case,
5104        clippy::pub_underscore_fields,
5105        clippy::style
5106    )]
5107    const _: () = {
5108        use alloy::sol_types as alloy_sol_types;
5109        #[automatically_derived]
5110        impl alloy_sol_types::SolEvent for AllocationDelaySet {
5111            type DataTuple<'a> = (
5112                alloy::sol_types::sol_data::Address,
5113                alloy::sol_types::sol_data::Uint<32>,
5114                alloy::sol_types::sol_data::Uint<32>,
5115            );
5116            type DataToken<'a> = <Self::DataTuple<
5117                'a,
5118            > as alloy_sol_types::SolType>::Token<'a>;
5119            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5120            const SIGNATURE: &'static str = "AllocationDelaySet(address,uint32,uint32)";
5121            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5122                78u8, 133u8, 117u8, 29u8, 99u8, 49u8, 80u8, 108u8, 108u8, 98u8, 51u8,
5123                95u8, 32u8, 126u8, 179u8, 31u8, 18u8, 166u8, 30u8, 87u8, 15u8, 52u8,
5124                245u8, 193u8, 118u8, 64u8, 48u8, 135u8, 133u8, 198u8, 212u8, 219u8,
5125            ]);
5126            const ANONYMOUS: bool = false;
5127            #[allow(unused_variables)]
5128            #[inline]
5129            fn new(
5130                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5131                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5132            ) -> Self {
5133                Self {
5134                    operator: data.0,
5135                    delay: data.1,
5136                    effectBlock: data.2,
5137                }
5138            }
5139            #[inline]
5140            fn check_signature(
5141                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5142            ) -> alloy_sol_types::Result<()> {
5143                if topics.0 != Self::SIGNATURE_HASH {
5144                    return Err(
5145                        alloy_sol_types::Error::invalid_event_signature_hash(
5146                            Self::SIGNATURE,
5147                            topics.0,
5148                            Self::SIGNATURE_HASH,
5149                        ),
5150                    );
5151                }
5152                Ok(())
5153            }
5154            #[inline]
5155            fn tokenize_body(&self) -> Self::DataToken<'_> {
5156                (
5157                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5158                        &self.operator,
5159                    ),
5160                    <alloy::sol_types::sol_data::Uint<
5161                        32,
5162                    > as alloy_sol_types::SolType>::tokenize(&self.delay),
5163                    <alloy::sol_types::sol_data::Uint<
5164                        32,
5165                    > as alloy_sol_types::SolType>::tokenize(&self.effectBlock),
5166                )
5167            }
5168            #[inline]
5169            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5170                (Self::SIGNATURE_HASH.into(),)
5171            }
5172            #[inline]
5173            fn encode_topics_raw(
5174                &self,
5175                out: &mut [alloy_sol_types::abi::token::WordToken],
5176            ) -> alloy_sol_types::Result<()> {
5177                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5178                    return Err(alloy_sol_types::Error::Overrun);
5179                }
5180                out[0usize] = alloy_sol_types::abi::token::WordToken(
5181                    Self::SIGNATURE_HASH,
5182                );
5183                Ok(())
5184            }
5185        }
5186        #[automatically_derived]
5187        impl alloy_sol_types::private::IntoLogData for AllocationDelaySet {
5188            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5189                From::from(self)
5190            }
5191            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5192                From::from(&self)
5193            }
5194        }
5195        #[automatically_derived]
5196        impl From<&AllocationDelaySet> for alloy_sol_types::private::LogData {
5197            #[inline]
5198            fn from(this: &AllocationDelaySet) -> alloy_sol_types::private::LogData {
5199                alloy_sol_types::SolEvent::encode_log_data(this)
5200            }
5201        }
5202    };
5203    #[derive(serde::Serialize, serde::Deserialize)]
5204    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5205    /**Event with signature `AllocationUpdated(address,(address,uint32),address,uint64,uint32)` and selector `0x1487af5418c47ee5ea45ef4a93398668120890774a9e13487e61e9dc3baf76dd`.
5206```solidity
5207event AllocationUpdated(address operator, OperatorSet operatorSet, address strategy, uint64 magnitude, uint32 effectBlock);
5208```*/
5209    #[allow(
5210        non_camel_case_types,
5211        non_snake_case,
5212        clippy::pub_underscore_fields,
5213        clippy::style
5214    )]
5215    #[derive(Clone)]
5216    pub struct AllocationUpdated {
5217        #[allow(missing_docs)]
5218        pub operator: alloy::sol_types::private::Address,
5219        #[allow(missing_docs)]
5220        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
5221        #[allow(missing_docs)]
5222        pub strategy: alloy::sol_types::private::Address,
5223        #[allow(missing_docs)]
5224        pub magnitude: u64,
5225        #[allow(missing_docs)]
5226        pub effectBlock: u32,
5227    }
5228    #[allow(
5229        non_camel_case_types,
5230        non_snake_case,
5231        clippy::pub_underscore_fields,
5232        clippy::style
5233    )]
5234    const _: () = {
5235        use alloy::sol_types as alloy_sol_types;
5236        #[automatically_derived]
5237        impl alloy_sol_types::SolEvent for AllocationUpdated {
5238            type DataTuple<'a> = (
5239                alloy::sol_types::sol_data::Address,
5240                OperatorSet,
5241                alloy::sol_types::sol_data::Address,
5242                alloy::sol_types::sol_data::Uint<64>,
5243                alloy::sol_types::sol_data::Uint<32>,
5244            );
5245            type DataToken<'a> = <Self::DataTuple<
5246                'a,
5247            > as alloy_sol_types::SolType>::Token<'a>;
5248            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5249            const SIGNATURE: &'static str = "AllocationUpdated(address,(address,uint32),address,uint64,uint32)";
5250            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5251                20u8, 135u8, 175u8, 84u8, 24u8, 196u8, 126u8, 229u8, 234u8, 69u8, 239u8,
5252                74u8, 147u8, 57u8, 134u8, 104u8, 18u8, 8u8, 144u8, 119u8, 74u8, 158u8,
5253                19u8, 72u8, 126u8, 97u8, 233u8, 220u8, 59u8, 175u8, 118u8, 221u8,
5254            ]);
5255            const ANONYMOUS: bool = false;
5256            #[allow(unused_variables)]
5257            #[inline]
5258            fn new(
5259                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5260                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5261            ) -> Self {
5262                Self {
5263                    operator: data.0,
5264                    operatorSet: data.1,
5265                    strategy: data.2,
5266                    magnitude: data.3,
5267                    effectBlock: data.4,
5268                }
5269            }
5270            #[inline]
5271            fn check_signature(
5272                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5273            ) -> alloy_sol_types::Result<()> {
5274                if topics.0 != Self::SIGNATURE_HASH {
5275                    return Err(
5276                        alloy_sol_types::Error::invalid_event_signature_hash(
5277                            Self::SIGNATURE,
5278                            topics.0,
5279                            Self::SIGNATURE_HASH,
5280                        ),
5281                    );
5282                }
5283                Ok(())
5284            }
5285            #[inline]
5286            fn tokenize_body(&self) -> Self::DataToken<'_> {
5287                (
5288                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5289                        &self.operator,
5290                    ),
5291                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
5292                        &self.operatorSet,
5293                    ),
5294                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5295                        &self.strategy,
5296                    ),
5297                    <alloy::sol_types::sol_data::Uint<
5298                        64,
5299                    > as alloy_sol_types::SolType>::tokenize(&self.magnitude),
5300                    <alloy::sol_types::sol_data::Uint<
5301                        32,
5302                    > as alloy_sol_types::SolType>::tokenize(&self.effectBlock),
5303                )
5304            }
5305            #[inline]
5306            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5307                (Self::SIGNATURE_HASH.into(),)
5308            }
5309            #[inline]
5310            fn encode_topics_raw(
5311                &self,
5312                out: &mut [alloy_sol_types::abi::token::WordToken],
5313            ) -> alloy_sol_types::Result<()> {
5314                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5315                    return Err(alloy_sol_types::Error::Overrun);
5316                }
5317                out[0usize] = alloy_sol_types::abi::token::WordToken(
5318                    Self::SIGNATURE_HASH,
5319                );
5320                Ok(())
5321            }
5322        }
5323        #[automatically_derived]
5324        impl alloy_sol_types::private::IntoLogData for AllocationUpdated {
5325            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5326                From::from(self)
5327            }
5328            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5329                From::from(&self)
5330            }
5331        }
5332        #[automatically_derived]
5333        impl From<&AllocationUpdated> for alloy_sol_types::private::LogData {
5334            #[inline]
5335            fn from(this: &AllocationUpdated) -> alloy_sol_types::private::LogData {
5336                alloy_sol_types::SolEvent::encode_log_data(this)
5337            }
5338        }
5339    };
5340    #[derive(serde::Serialize, serde::Deserialize)]
5341    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5342    /**Event with signature `EncumberedMagnitudeUpdated(address,address,uint64)` and selector `0xacf9095feb3a370c9cf692421c69ef320d4db5c66e6a7d29c7694eb02364fc55`.
5343```solidity
5344event EncumberedMagnitudeUpdated(address operator, address strategy, uint64 encumberedMagnitude);
5345```*/
5346    #[allow(
5347        non_camel_case_types,
5348        non_snake_case,
5349        clippy::pub_underscore_fields,
5350        clippy::style
5351    )]
5352    #[derive(Clone)]
5353    pub struct EncumberedMagnitudeUpdated {
5354        #[allow(missing_docs)]
5355        pub operator: alloy::sol_types::private::Address,
5356        #[allow(missing_docs)]
5357        pub strategy: alloy::sol_types::private::Address,
5358        #[allow(missing_docs)]
5359        pub encumberedMagnitude: u64,
5360    }
5361    #[allow(
5362        non_camel_case_types,
5363        non_snake_case,
5364        clippy::pub_underscore_fields,
5365        clippy::style
5366    )]
5367    const _: () = {
5368        use alloy::sol_types as alloy_sol_types;
5369        #[automatically_derived]
5370        impl alloy_sol_types::SolEvent for EncumberedMagnitudeUpdated {
5371            type DataTuple<'a> = (
5372                alloy::sol_types::sol_data::Address,
5373                alloy::sol_types::sol_data::Address,
5374                alloy::sol_types::sol_data::Uint<64>,
5375            );
5376            type DataToken<'a> = <Self::DataTuple<
5377                'a,
5378            > as alloy_sol_types::SolType>::Token<'a>;
5379            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5380            const SIGNATURE: &'static str = "EncumberedMagnitudeUpdated(address,address,uint64)";
5381            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5382                172u8, 249u8, 9u8, 95u8, 235u8, 58u8, 55u8, 12u8, 156u8, 246u8, 146u8,
5383                66u8, 28u8, 105u8, 239u8, 50u8, 13u8, 77u8, 181u8, 198u8, 110u8, 106u8,
5384                125u8, 41u8, 199u8, 105u8, 78u8, 176u8, 35u8, 100u8, 252u8, 85u8,
5385            ]);
5386            const ANONYMOUS: bool = false;
5387            #[allow(unused_variables)]
5388            #[inline]
5389            fn new(
5390                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5391                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5392            ) -> Self {
5393                Self {
5394                    operator: data.0,
5395                    strategy: data.1,
5396                    encumberedMagnitude: data.2,
5397                }
5398            }
5399            #[inline]
5400            fn check_signature(
5401                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5402            ) -> alloy_sol_types::Result<()> {
5403                if topics.0 != Self::SIGNATURE_HASH {
5404                    return Err(
5405                        alloy_sol_types::Error::invalid_event_signature_hash(
5406                            Self::SIGNATURE,
5407                            topics.0,
5408                            Self::SIGNATURE_HASH,
5409                        ),
5410                    );
5411                }
5412                Ok(())
5413            }
5414            #[inline]
5415            fn tokenize_body(&self) -> Self::DataToken<'_> {
5416                (
5417                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5418                        &self.operator,
5419                    ),
5420                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5421                        &self.strategy,
5422                    ),
5423                    <alloy::sol_types::sol_data::Uint<
5424                        64,
5425                    > as alloy_sol_types::SolType>::tokenize(&self.encumberedMagnitude),
5426                )
5427            }
5428            #[inline]
5429            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5430                (Self::SIGNATURE_HASH.into(),)
5431            }
5432            #[inline]
5433            fn encode_topics_raw(
5434                &self,
5435                out: &mut [alloy_sol_types::abi::token::WordToken],
5436            ) -> alloy_sol_types::Result<()> {
5437                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5438                    return Err(alloy_sol_types::Error::Overrun);
5439                }
5440                out[0usize] = alloy_sol_types::abi::token::WordToken(
5441                    Self::SIGNATURE_HASH,
5442                );
5443                Ok(())
5444            }
5445        }
5446        #[automatically_derived]
5447        impl alloy_sol_types::private::IntoLogData for EncumberedMagnitudeUpdated {
5448            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5449                From::from(self)
5450            }
5451            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5452                From::from(&self)
5453            }
5454        }
5455        #[automatically_derived]
5456        impl From<&EncumberedMagnitudeUpdated> for alloy_sol_types::private::LogData {
5457            #[inline]
5458            fn from(
5459                this: &EncumberedMagnitudeUpdated,
5460            ) -> alloy_sol_types::private::LogData {
5461                alloy_sol_types::SolEvent::encode_log_data(this)
5462            }
5463        }
5464    };
5465    #[derive(serde::Serialize, serde::Deserialize)]
5466    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5467    /**Event with signature `MaxMagnitudeUpdated(address,address,uint64)` and selector `0x1c6458079a41077d003c11faf9bf097e693bd67979e4e6500bac7b29db779b5c`.
5468```solidity
5469event MaxMagnitudeUpdated(address operator, address strategy, uint64 maxMagnitude);
5470```*/
5471    #[allow(
5472        non_camel_case_types,
5473        non_snake_case,
5474        clippy::pub_underscore_fields,
5475        clippy::style
5476    )]
5477    #[derive(Clone)]
5478    pub struct MaxMagnitudeUpdated {
5479        #[allow(missing_docs)]
5480        pub operator: alloy::sol_types::private::Address,
5481        #[allow(missing_docs)]
5482        pub strategy: alloy::sol_types::private::Address,
5483        #[allow(missing_docs)]
5484        pub maxMagnitude: u64,
5485    }
5486    #[allow(
5487        non_camel_case_types,
5488        non_snake_case,
5489        clippy::pub_underscore_fields,
5490        clippy::style
5491    )]
5492    const _: () = {
5493        use alloy::sol_types as alloy_sol_types;
5494        #[automatically_derived]
5495        impl alloy_sol_types::SolEvent for MaxMagnitudeUpdated {
5496            type DataTuple<'a> = (
5497                alloy::sol_types::sol_data::Address,
5498                alloy::sol_types::sol_data::Address,
5499                alloy::sol_types::sol_data::Uint<64>,
5500            );
5501            type DataToken<'a> = <Self::DataTuple<
5502                'a,
5503            > as alloy_sol_types::SolType>::Token<'a>;
5504            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5505            const SIGNATURE: &'static str = "MaxMagnitudeUpdated(address,address,uint64)";
5506            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5507                28u8, 100u8, 88u8, 7u8, 154u8, 65u8, 7u8, 125u8, 0u8, 60u8, 17u8, 250u8,
5508                249u8, 191u8, 9u8, 126u8, 105u8, 59u8, 214u8, 121u8, 121u8, 228u8, 230u8,
5509                80u8, 11u8, 172u8, 123u8, 41u8, 219u8, 119u8, 155u8, 92u8,
5510            ]);
5511            const ANONYMOUS: bool = false;
5512            #[allow(unused_variables)]
5513            #[inline]
5514            fn new(
5515                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5516                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5517            ) -> Self {
5518                Self {
5519                    operator: data.0,
5520                    strategy: data.1,
5521                    maxMagnitude: data.2,
5522                }
5523            }
5524            #[inline]
5525            fn check_signature(
5526                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5527            ) -> alloy_sol_types::Result<()> {
5528                if topics.0 != Self::SIGNATURE_HASH {
5529                    return Err(
5530                        alloy_sol_types::Error::invalid_event_signature_hash(
5531                            Self::SIGNATURE,
5532                            topics.0,
5533                            Self::SIGNATURE_HASH,
5534                        ),
5535                    );
5536                }
5537                Ok(())
5538            }
5539            #[inline]
5540            fn tokenize_body(&self) -> Self::DataToken<'_> {
5541                (
5542                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5543                        &self.operator,
5544                    ),
5545                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
5546                        &self.strategy,
5547                    ),
5548                    <alloy::sol_types::sol_data::Uint<
5549                        64,
5550                    > as alloy_sol_types::SolType>::tokenize(&self.maxMagnitude),
5551                )
5552            }
5553            #[inline]
5554            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5555                (Self::SIGNATURE_HASH.into(),)
5556            }
5557            #[inline]
5558            fn encode_topics_raw(
5559                &self,
5560                out: &mut [alloy_sol_types::abi::token::WordToken],
5561            ) -> alloy_sol_types::Result<()> {
5562                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5563                    return Err(alloy_sol_types::Error::Overrun);
5564                }
5565                out[0usize] = alloy_sol_types::abi::token::WordToken(
5566                    Self::SIGNATURE_HASH,
5567                );
5568                Ok(())
5569            }
5570        }
5571        #[automatically_derived]
5572        impl alloy_sol_types::private::IntoLogData for MaxMagnitudeUpdated {
5573            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5574                From::from(self)
5575            }
5576            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5577                From::from(&self)
5578            }
5579        }
5580        #[automatically_derived]
5581        impl From<&MaxMagnitudeUpdated> for alloy_sol_types::private::LogData {
5582            #[inline]
5583            fn from(this: &MaxMagnitudeUpdated) -> alloy_sol_types::private::LogData {
5584                alloy_sol_types::SolEvent::encode_log_data(this)
5585            }
5586        }
5587    };
5588    #[derive(serde::Serialize, serde::Deserialize)]
5589    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5590    /**Event with signature `OperatorAddedToOperatorSet(address,(address,uint32))` and selector `0x43232edf9071753d2321e5fa7e018363ee248e5f2142e6c08edd3265bfb4895e`.
5591```solidity
5592event OperatorAddedToOperatorSet(address indexed operator, OperatorSet operatorSet);
5593```*/
5594    #[allow(
5595        non_camel_case_types,
5596        non_snake_case,
5597        clippy::pub_underscore_fields,
5598        clippy::style
5599    )]
5600    #[derive(Clone)]
5601    pub struct OperatorAddedToOperatorSet {
5602        #[allow(missing_docs)]
5603        pub operator: alloy::sol_types::private::Address,
5604        #[allow(missing_docs)]
5605        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
5606    }
5607    #[allow(
5608        non_camel_case_types,
5609        non_snake_case,
5610        clippy::pub_underscore_fields,
5611        clippy::style
5612    )]
5613    const _: () = {
5614        use alloy::sol_types as alloy_sol_types;
5615        #[automatically_derived]
5616        impl alloy_sol_types::SolEvent for OperatorAddedToOperatorSet {
5617            type DataTuple<'a> = (OperatorSet,);
5618            type DataToken<'a> = <Self::DataTuple<
5619                'a,
5620            > as alloy_sol_types::SolType>::Token<'a>;
5621            type TopicList = (
5622                alloy_sol_types::sol_data::FixedBytes<32>,
5623                alloy::sol_types::sol_data::Address,
5624            );
5625            const SIGNATURE: &'static str = "OperatorAddedToOperatorSet(address,(address,uint32))";
5626            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5627                67u8, 35u8, 46u8, 223u8, 144u8, 113u8, 117u8, 61u8, 35u8, 33u8, 229u8,
5628                250u8, 126u8, 1u8, 131u8, 99u8, 238u8, 36u8, 142u8, 95u8, 33u8, 66u8,
5629                230u8, 192u8, 142u8, 221u8, 50u8, 101u8, 191u8, 180u8, 137u8, 94u8,
5630            ]);
5631            const ANONYMOUS: bool = false;
5632            #[allow(unused_variables)]
5633            #[inline]
5634            fn new(
5635                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5636                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5637            ) -> Self {
5638                Self {
5639                    operator: topics.1,
5640                    operatorSet: data.0,
5641                }
5642            }
5643            #[inline]
5644            fn check_signature(
5645                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5646            ) -> alloy_sol_types::Result<()> {
5647                if topics.0 != Self::SIGNATURE_HASH {
5648                    return Err(
5649                        alloy_sol_types::Error::invalid_event_signature_hash(
5650                            Self::SIGNATURE,
5651                            topics.0,
5652                            Self::SIGNATURE_HASH,
5653                        ),
5654                    );
5655                }
5656                Ok(())
5657            }
5658            #[inline]
5659            fn tokenize_body(&self) -> Self::DataToken<'_> {
5660                (<OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),)
5661            }
5662            #[inline]
5663            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5664                (Self::SIGNATURE_HASH.into(), self.operator.clone())
5665            }
5666            #[inline]
5667            fn encode_topics_raw(
5668                &self,
5669                out: &mut [alloy_sol_types::abi::token::WordToken],
5670            ) -> alloy_sol_types::Result<()> {
5671                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5672                    return Err(alloy_sol_types::Error::Overrun);
5673                }
5674                out[0usize] = alloy_sol_types::abi::token::WordToken(
5675                    Self::SIGNATURE_HASH,
5676                );
5677                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5678                    &self.operator,
5679                );
5680                Ok(())
5681            }
5682        }
5683        #[automatically_derived]
5684        impl alloy_sol_types::private::IntoLogData for OperatorAddedToOperatorSet {
5685            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5686                From::from(self)
5687            }
5688            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5689                From::from(&self)
5690            }
5691        }
5692        #[automatically_derived]
5693        impl From<&OperatorAddedToOperatorSet> for alloy_sol_types::private::LogData {
5694            #[inline]
5695            fn from(
5696                this: &OperatorAddedToOperatorSet,
5697            ) -> alloy_sol_types::private::LogData {
5698                alloy_sol_types::SolEvent::encode_log_data(this)
5699            }
5700        }
5701    };
5702    #[derive(serde::Serialize, serde::Deserialize)]
5703    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5704    /**Event with signature `OperatorRemovedFromOperatorSet(address,(address,uint32))` and selector `0xad34c3070be1dffbcaa499d000ba2b8d9848aefcac3059df245dd95c4ece14fe`.
5705```solidity
5706event OperatorRemovedFromOperatorSet(address indexed operator, OperatorSet operatorSet);
5707```*/
5708    #[allow(
5709        non_camel_case_types,
5710        non_snake_case,
5711        clippy::pub_underscore_fields,
5712        clippy::style
5713    )]
5714    #[derive(Clone)]
5715    pub struct OperatorRemovedFromOperatorSet {
5716        #[allow(missing_docs)]
5717        pub operator: alloy::sol_types::private::Address,
5718        #[allow(missing_docs)]
5719        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
5720    }
5721    #[allow(
5722        non_camel_case_types,
5723        non_snake_case,
5724        clippy::pub_underscore_fields,
5725        clippy::style
5726    )]
5727    const _: () = {
5728        use alloy::sol_types as alloy_sol_types;
5729        #[automatically_derived]
5730        impl alloy_sol_types::SolEvent for OperatorRemovedFromOperatorSet {
5731            type DataTuple<'a> = (OperatorSet,);
5732            type DataToken<'a> = <Self::DataTuple<
5733                'a,
5734            > as alloy_sol_types::SolType>::Token<'a>;
5735            type TopicList = (
5736                alloy_sol_types::sol_data::FixedBytes<32>,
5737                alloy::sol_types::sol_data::Address,
5738            );
5739            const SIGNATURE: &'static str = "OperatorRemovedFromOperatorSet(address,(address,uint32))";
5740            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5741                173u8, 52u8, 195u8, 7u8, 11u8, 225u8, 223u8, 251u8, 202u8, 164u8, 153u8,
5742                208u8, 0u8, 186u8, 43u8, 141u8, 152u8, 72u8, 174u8, 252u8, 172u8, 48u8,
5743                89u8, 223u8, 36u8, 93u8, 217u8, 92u8, 78u8, 206u8, 20u8, 254u8,
5744            ]);
5745            const ANONYMOUS: bool = false;
5746            #[allow(unused_variables)]
5747            #[inline]
5748            fn new(
5749                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5750                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5751            ) -> Self {
5752                Self {
5753                    operator: topics.1,
5754                    operatorSet: data.0,
5755                }
5756            }
5757            #[inline]
5758            fn check_signature(
5759                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5760            ) -> alloy_sol_types::Result<()> {
5761                if topics.0 != Self::SIGNATURE_HASH {
5762                    return Err(
5763                        alloy_sol_types::Error::invalid_event_signature_hash(
5764                            Self::SIGNATURE,
5765                            topics.0,
5766                            Self::SIGNATURE_HASH,
5767                        ),
5768                    );
5769                }
5770                Ok(())
5771            }
5772            #[inline]
5773            fn tokenize_body(&self) -> Self::DataToken<'_> {
5774                (<OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),)
5775            }
5776            #[inline]
5777            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5778                (Self::SIGNATURE_HASH.into(), self.operator.clone())
5779            }
5780            #[inline]
5781            fn encode_topics_raw(
5782                &self,
5783                out: &mut [alloy_sol_types::abi::token::WordToken],
5784            ) -> alloy_sol_types::Result<()> {
5785                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5786                    return Err(alloy_sol_types::Error::Overrun);
5787                }
5788                out[0usize] = alloy_sol_types::abi::token::WordToken(
5789                    Self::SIGNATURE_HASH,
5790                );
5791                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
5792                    &self.operator,
5793                );
5794                Ok(())
5795            }
5796        }
5797        #[automatically_derived]
5798        impl alloy_sol_types::private::IntoLogData for OperatorRemovedFromOperatorSet {
5799            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5800                From::from(self)
5801            }
5802            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5803                From::from(&self)
5804            }
5805        }
5806        #[automatically_derived]
5807        impl From<&OperatorRemovedFromOperatorSet>
5808        for alloy_sol_types::private::LogData {
5809            #[inline]
5810            fn from(
5811                this: &OperatorRemovedFromOperatorSet,
5812            ) -> alloy_sol_types::private::LogData {
5813                alloy_sol_types::SolEvent::encode_log_data(this)
5814            }
5815        }
5816    };
5817    #[derive(serde::Serialize, serde::Deserialize)]
5818    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5819    /**Event with signature `OperatorSetCreated((address,uint32))` and selector `0x31629285ead2335ae0933f86ed2ae63321f7af77b4e6eaabc42c057880977e6c`.
5820```solidity
5821event OperatorSetCreated(OperatorSet operatorSet);
5822```*/
5823    #[allow(
5824        non_camel_case_types,
5825        non_snake_case,
5826        clippy::pub_underscore_fields,
5827        clippy::style
5828    )]
5829    #[derive(Clone)]
5830    pub struct OperatorSetCreated {
5831        #[allow(missing_docs)]
5832        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
5833    }
5834    #[allow(
5835        non_camel_case_types,
5836        non_snake_case,
5837        clippy::pub_underscore_fields,
5838        clippy::style
5839    )]
5840    const _: () = {
5841        use alloy::sol_types as alloy_sol_types;
5842        #[automatically_derived]
5843        impl alloy_sol_types::SolEvent for OperatorSetCreated {
5844            type DataTuple<'a> = (OperatorSet,);
5845            type DataToken<'a> = <Self::DataTuple<
5846                'a,
5847            > as alloy_sol_types::SolType>::Token<'a>;
5848            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5849            const SIGNATURE: &'static str = "OperatorSetCreated((address,uint32))";
5850            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5851                49u8, 98u8, 146u8, 133u8, 234u8, 210u8, 51u8, 90u8, 224u8, 147u8, 63u8,
5852                134u8, 237u8, 42u8, 230u8, 51u8, 33u8, 247u8, 175u8, 119u8, 180u8, 230u8,
5853                234u8, 171u8, 196u8, 44u8, 5u8, 120u8, 128u8, 151u8, 126u8, 108u8,
5854            ]);
5855            const ANONYMOUS: bool = false;
5856            #[allow(unused_variables)]
5857            #[inline]
5858            fn new(
5859                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5860                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5861            ) -> Self {
5862                Self { operatorSet: data.0 }
5863            }
5864            #[inline]
5865            fn check_signature(
5866                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5867            ) -> alloy_sol_types::Result<()> {
5868                if topics.0 != Self::SIGNATURE_HASH {
5869                    return Err(
5870                        alloy_sol_types::Error::invalid_event_signature_hash(
5871                            Self::SIGNATURE,
5872                            topics.0,
5873                            Self::SIGNATURE_HASH,
5874                        ),
5875                    );
5876                }
5877                Ok(())
5878            }
5879            #[inline]
5880            fn tokenize_body(&self) -> Self::DataToken<'_> {
5881                (<OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),)
5882            }
5883            #[inline]
5884            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
5885                (Self::SIGNATURE_HASH.into(),)
5886            }
5887            #[inline]
5888            fn encode_topics_raw(
5889                &self,
5890                out: &mut [alloy_sol_types::abi::token::WordToken],
5891            ) -> alloy_sol_types::Result<()> {
5892                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
5893                    return Err(alloy_sol_types::Error::Overrun);
5894                }
5895                out[0usize] = alloy_sol_types::abi::token::WordToken(
5896                    Self::SIGNATURE_HASH,
5897                );
5898                Ok(())
5899            }
5900        }
5901        #[automatically_derived]
5902        impl alloy_sol_types::private::IntoLogData for OperatorSetCreated {
5903            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5904                From::from(self)
5905            }
5906            fn into_log_data(self) -> alloy_sol_types::private::LogData {
5907                From::from(&self)
5908            }
5909        }
5910        #[automatically_derived]
5911        impl From<&OperatorSetCreated> for alloy_sol_types::private::LogData {
5912            #[inline]
5913            fn from(this: &OperatorSetCreated) -> alloy_sol_types::private::LogData {
5914                alloy_sol_types::SolEvent::encode_log_data(this)
5915            }
5916        }
5917    };
5918    #[derive(serde::Serialize, serde::Deserialize)]
5919    #[derive(Default, Debug, PartialEq, Eq, Hash)]
5920    /**Event with signature `OperatorSlashed(address,(address,uint32),address[],uint256[],string)` and selector `0x80969ad29428d6797ee7aad084f9e4a42a82fc506dcd2ca3b6fb431f85ccebe5`.
5921```solidity
5922event OperatorSlashed(address operator, OperatorSet operatorSet, address[] strategies, uint256[] wadSlashed, string description);
5923```*/
5924    #[allow(
5925        non_camel_case_types,
5926        non_snake_case,
5927        clippy::pub_underscore_fields,
5928        clippy::style
5929    )]
5930    #[derive(Clone)]
5931    pub struct OperatorSlashed {
5932        #[allow(missing_docs)]
5933        pub operator: alloy::sol_types::private::Address,
5934        #[allow(missing_docs)]
5935        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
5936        #[allow(missing_docs)]
5937        pub strategies: alloy::sol_types::private::Vec<
5938            alloy::sol_types::private::Address,
5939        >,
5940        #[allow(missing_docs)]
5941        pub wadSlashed: alloy::sol_types::private::Vec<
5942            alloy::sol_types::private::primitives::aliases::U256,
5943        >,
5944        #[allow(missing_docs)]
5945        pub description: alloy::sol_types::private::String,
5946    }
5947    #[allow(
5948        non_camel_case_types,
5949        non_snake_case,
5950        clippy::pub_underscore_fields,
5951        clippy::style
5952    )]
5953    const _: () = {
5954        use alloy::sol_types as alloy_sol_types;
5955        #[automatically_derived]
5956        impl alloy_sol_types::SolEvent for OperatorSlashed {
5957            type DataTuple<'a> = (
5958                alloy::sol_types::sol_data::Address,
5959                OperatorSet,
5960                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
5961                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<256>>,
5962                alloy::sol_types::sol_data::String,
5963            );
5964            type DataToken<'a> = <Self::DataTuple<
5965                'a,
5966            > as alloy_sol_types::SolType>::Token<'a>;
5967            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
5968            const SIGNATURE: &'static str = "OperatorSlashed(address,(address,uint32),address[],uint256[],string)";
5969            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
5970                128u8, 150u8, 154u8, 210u8, 148u8, 40u8, 214u8, 121u8, 126u8, 231u8,
5971                170u8, 208u8, 132u8, 249u8, 228u8, 164u8, 42u8, 130u8, 252u8, 80u8,
5972                109u8, 205u8, 44u8, 163u8, 182u8, 251u8, 67u8, 31u8, 133u8, 204u8, 235u8,
5973                229u8,
5974            ]);
5975            const ANONYMOUS: bool = false;
5976            #[allow(unused_variables)]
5977            #[inline]
5978            fn new(
5979                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
5980                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
5981            ) -> Self {
5982                Self {
5983                    operator: data.0,
5984                    operatorSet: data.1,
5985                    strategies: data.2,
5986                    wadSlashed: data.3,
5987                    description: data.4,
5988                }
5989            }
5990            #[inline]
5991            fn check_signature(
5992                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
5993            ) -> alloy_sol_types::Result<()> {
5994                if topics.0 != Self::SIGNATURE_HASH {
5995                    return Err(
5996                        alloy_sol_types::Error::invalid_event_signature_hash(
5997                            Self::SIGNATURE,
5998                            topics.0,
5999                            Self::SIGNATURE_HASH,
6000                        ),
6001                    );
6002                }
6003                Ok(())
6004            }
6005            #[inline]
6006            fn tokenize_body(&self) -> Self::DataToken<'_> {
6007                (
6008                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6009                        &self.operator,
6010                    ),
6011                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
6012                        &self.operatorSet,
6013                    ),
6014                    <alloy::sol_types::sol_data::Array<
6015                        alloy::sol_types::sol_data::Address,
6016                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
6017                    <alloy::sol_types::sol_data::Array<
6018                        alloy::sol_types::sol_data::Uint<256>,
6019                    > as alloy_sol_types::SolType>::tokenize(&self.wadSlashed),
6020                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
6021                        &self.description,
6022                    ),
6023                )
6024            }
6025            #[inline]
6026            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6027                (Self::SIGNATURE_HASH.into(),)
6028            }
6029            #[inline]
6030            fn encode_topics_raw(
6031                &self,
6032                out: &mut [alloy_sol_types::abi::token::WordToken],
6033            ) -> alloy_sol_types::Result<()> {
6034                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6035                    return Err(alloy_sol_types::Error::Overrun);
6036                }
6037                out[0usize] = alloy_sol_types::abi::token::WordToken(
6038                    Self::SIGNATURE_HASH,
6039                );
6040                Ok(())
6041            }
6042        }
6043        #[automatically_derived]
6044        impl alloy_sol_types::private::IntoLogData for OperatorSlashed {
6045            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6046                From::from(self)
6047            }
6048            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6049                From::from(&self)
6050            }
6051        }
6052        #[automatically_derived]
6053        impl From<&OperatorSlashed> for alloy_sol_types::private::LogData {
6054            #[inline]
6055            fn from(this: &OperatorSlashed) -> alloy_sol_types::private::LogData {
6056                alloy_sol_types::SolEvent::encode_log_data(this)
6057            }
6058        }
6059    };
6060    #[derive(serde::Serialize, serde::Deserialize)]
6061    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6062    /**Event with signature `StrategyAddedToOperatorSet((address,uint32),address)` and selector `0x7ab260fe0af193db5f4986770d831bda4ea46099dc817e8b6716dcae8af8e88b`.
6063```solidity
6064event StrategyAddedToOperatorSet(OperatorSet operatorSet, address strategy);
6065```*/
6066    #[allow(
6067        non_camel_case_types,
6068        non_snake_case,
6069        clippy::pub_underscore_fields,
6070        clippy::style
6071    )]
6072    #[derive(Clone)]
6073    pub struct StrategyAddedToOperatorSet {
6074        #[allow(missing_docs)]
6075        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
6076        #[allow(missing_docs)]
6077        pub strategy: alloy::sol_types::private::Address,
6078    }
6079    #[allow(
6080        non_camel_case_types,
6081        non_snake_case,
6082        clippy::pub_underscore_fields,
6083        clippy::style
6084    )]
6085    const _: () = {
6086        use alloy::sol_types as alloy_sol_types;
6087        #[automatically_derived]
6088        impl alloy_sol_types::SolEvent for StrategyAddedToOperatorSet {
6089            type DataTuple<'a> = (OperatorSet, alloy::sol_types::sol_data::Address);
6090            type DataToken<'a> = <Self::DataTuple<
6091                'a,
6092            > as alloy_sol_types::SolType>::Token<'a>;
6093            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6094            const SIGNATURE: &'static str = "StrategyAddedToOperatorSet((address,uint32),address)";
6095            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
6096                122u8, 178u8, 96u8, 254u8, 10u8, 241u8, 147u8, 219u8, 95u8, 73u8, 134u8,
6097                119u8, 13u8, 131u8, 27u8, 218u8, 78u8, 164u8, 96u8, 153u8, 220u8, 129u8,
6098                126u8, 139u8, 103u8, 22u8, 220u8, 174u8, 138u8, 248u8, 232u8, 139u8,
6099            ]);
6100            const ANONYMOUS: bool = false;
6101            #[allow(unused_variables)]
6102            #[inline]
6103            fn new(
6104                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6105                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6106            ) -> Self {
6107                Self {
6108                    operatorSet: data.0,
6109                    strategy: data.1,
6110                }
6111            }
6112            #[inline]
6113            fn check_signature(
6114                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6115            ) -> alloy_sol_types::Result<()> {
6116                if topics.0 != Self::SIGNATURE_HASH {
6117                    return Err(
6118                        alloy_sol_types::Error::invalid_event_signature_hash(
6119                            Self::SIGNATURE,
6120                            topics.0,
6121                            Self::SIGNATURE_HASH,
6122                        ),
6123                    );
6124                }
6125                Ok(())
6126            }
6127            #[inline]
6128            fn tokenize_body(&self) -> Self::DataToken<'_> {
6129                (
6130                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
6131                        &self.operatorSet,
6132                    ),
6133                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6134                        &self.strategy,
6135                    ),
6136                )
6137            }
6138            #[inline]
6139            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6140                (Self::SIGNATURE_HASH.into(),)
6141            }
6142            #[inline]
6143            fn encode_topics_raw(
6144                &self,
6145                out: &mut [alloy_sol_types::abi::token::WordToken],
6146            ) -> alloy_sol_types::Result<()> {
6147                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6148                    return Err(alloy_sol_types::Error::Overrun);
6149                }
6150                out[0usize] = alloy_sol_types::abi::token::WordToken(
6151                    Self::SIGNATURE_HASH,
6152                );
6153                Ok(())
6154            }
6155        }
6156        #[automatically_derived]
6157        impl alloy_sol_types::private::IntoLogData for StrategyAddedToOperatorSet {
6158            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6159                From::from(self)
6160            }
6161            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6162                From::from(&self)
6163            }
6164        }
6165        #[automatically_derived]
6166        impl From<&StrategyAddedToOperatorSet> for alloy_sol_types::private::LogData {
6167            #[inline]
6168            fn from(
6169                this: &StrategyAddedToOperatorSet,
6170            ) -> alloy_sol_types::private::LogData {
6171                alloy_sol_types::SolEvent::encode_log_data(this)
6172            }
6173        }
6174    };
6175    #[derive(serde::Serialize, serde::Deserialize)]
6176    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6177    /**Event with signature `StrategyRemovedFromOperatorSet((address,uint32),address)` and selector `0x7b4b073d80dcac55a11177d8459ad9f664ceeb91f71f27167bb14f8152a7eeee`.
6178```solidity
6179event StrategyRemovedFromOperatorSet(OperatorSet operatorSet, address strategy);
6180```*/
6181    #[allow(
6182        non_camel_case_types,
6183        non_snake_case,
6184        clippy::pub_underscore_fields,
6185        clippy::style
6186    )]
6187    #[derive(Clone)]
6188    pub struct StrategyRemovedFromOperatorSet {
6189        #[allow(missing_docs)]
6190        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
6191        #[allow(missing_docs)]
6192        pub strategy: alloy::sol_types::private::Address,
6193    }
6194    #[allow(
6195        non_camel_case_types,
6196        non_snake_case,
6197        clippy::pub_underscore_fields,
6198        clippy::style
6199    )]
6200    const _: () = {
6201        use alloy::sol_types as alloy_sol_types;
6202        #[automatically_derived]
6203        impl alloy_sol_types::SolEvent for StrategyRemovedFromOperatorSet {
6204            type DataTuple<'a> = (OperatorSet, alloy::sol_types::sol_data::Address);
6205            type DataToken<'a> = <Self::DataTuple<
6206                'a,
6207            > as alloy_sol_types::SolType>::Token<'a>;
6208            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
6209            const SIGNATURE: &'static str = "StrategyRemovedFromOperatorSet((address,uint32),address)";
6210            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
6211                123u8, 75u8, 7u8, 61u8, 128u8, 220u8, 172u8, 85u8, 161u8, 17u8, 119u8,
6212                216u8, 69u8, 154u8, 217u8, 246u8, 100u8, 206u8, 235u8, 145u8, 247u8,
6213                31u8, 39u8, 22u8, 123u8, 177u8, 79u8, 129u8, 82u8, 167u8, 238u8, 238u8,
6214            ]);
6215            const ANONYMOUS: bool = false;
6216            #[allow(unused_variables)]
6217            #[inline]
6218            fn new(
6219                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
6220                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
6221            ) -> Self {
6222                Self {
6223                    operatorSet: data.0,
6224                    strategy: data.1,
6225                }
6226            }
6227            #[inline]
6228            fn check_signature(
6229                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
6230            ) -> alloy_sol_types::Result<()> {
6231                if topics.0 != Self::SIGNATURE_HASH {
6232                    return Err(
6233                        alloy_sol_types::Error::invalid_event_signature_hash(
6234                            Self::SIGNATURE,
6235                            topics.0,
6236                            Self::SIGNATURE_HASH,
6237                        ),
6238                    );
6239                }
6240                Ok(())
6241            }
6242            #[inline]
6243            fn tokenize_body(&self) -> Self::DataToken<'_> {
6244                (
6245                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
6246                        &self.operatorSet,
6247                    ),
6248                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6249                        &self.strategy,
6250                    ),
6251                )
6252            }
6253            #[inline]
6254            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
6255                (Self::SIGNATURE_HASH.into(),)
6256            }
6257            #[inline]
6258            fn encode_topics_raw(
6259                &self,
6260                out: &mut [alloy_sol_types::abi::token::WordToken],
6261            ) -> alloy_sol_types::Result<()> {
6262                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
6263                    return Err(alloy_sol_types::Error::Overrun);
6264                }
6265                out[0usize] = alloy_sol_types::abi::token::WordToken(
6266                    Self::SIGNATURE_HASH,
6267                );
6268                Ok(())
6269            }
6270        }
6271        #[automatically_derived]
6272        impl alloy_sol_types::private::IntoLogData for StrategyRemovedFromOperatorSet {
6273            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
6274                From::from(self)
6275            }
6276            fn into_log_data(self) -> alloy_sol_types::private::LogData {
6277                From::from(&self)
6278            }
6279        }
6280        #[automatically_derived]
6281        impl From<&StrategyRemovedFromOperatorSet>
6282        for alloy_sol_types::private::LogData {
6283            #[inline]
6284            fn from(
6285                this: &StrategyRemovedFromOperatorSet,
6286            ) -> alloy_sol_types::private::LogData {
6287                alloy_sol_types::SolEvent::encode_log_data(this)
6288            }
6289        }
6290    };
6291    #[derive(serde::Serialize, serde::Deserialize)]
6292    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6293    /**Function with signature `addStrategiesToOperatorSet(address,uint32,address[])` and selector `0x50feea20`.
6294```solidity
6295function addStrategiesToOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
6296```*/
6297    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6298    #[derive(Clone)]
6299    pub struct addStrategiesToOperatorSetCall {
6300        #[allow(missing_docs)]
6301        pub avs: alloy::sol_types::private::Address,
6302        #[allow(missing_docs)]
6303        pub operatorSetId: u32,
6304        #[allow(missing_docs)]
6305        pub strategies: alloy::sol_types::private::Vec<
6306            alloy::sol_types::private::Address,
6307        >,
6308    }
6309    ///Container type for the return parameters of the [`addStrategiesToOperatorSet(address,uint32,address[])`](addStrategiesToOperatorSetCall) function.
6310    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6311    #[derive(Clone)]
6312    pub struct addStrategiesToOperatorSetReturn {}
6313    #[allow(
6314        non_camel_case_types,
6315        non_snake_case,
6316        clippy::pub_underscore_fields,
6317        clippy::style
6318    )]
6319    const _: () = {
6320        use alloy::sol_types as alloy_sol_types;
6321        {
6322            #[doc(hidden)]
6323            type UnderlyingSolTuple<'a> = (
6324                alloy::sol_types::sol_data::Address,
6325                alloy::sol_types::sol_data::Uint<32>,
6326                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6327            );
6328            #[doc(hidden)]
6329            type UnderlyingRustTuple<'a> = (
6330                alloy::sol_types::private::Address,
6331                u32,
6332                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6333            );
6334            #[cfg(test)]
6335            #[allow(dead_code, unreachable_patterns)]
6336            fn _type_assertion(
6337                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6338            ) {
6339                match _t {
6340                    alloy_sol_types::private::AssertTypeEq::<
6341                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6342                    >(_) => {}
6343                }
6344            }
6345            #[automatically_derived]
6346            #[doc(hidden)]
6347            impl ::core::convert::From<addStrategiesToOperatorSetCall>
6348            for UnderlyingRustTuple<'_> {
6349                fn from(value: addStrategiesToOperatorSetCall) -> Self {
6350                    (value.avs, value.operatorSetId, value.strategies)
6351                }
6352            }
6353            #[automatically_derived]
6354            #[doc(hidden)]
6355            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6356            for addStrategiesToOperatorSetCall {
6357                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6358                    Self {
6359                        avs: tuple.0,
6360                        operatorSetId: tuple.1,
6361                        strategies: tuple.2,
6362                    }
6363                }
6364            }
6365        }
6366        {
6367            #[doc(hidden)]
6368            type UnderlyingSolTuple<'a> = ();
6369            #[doc(hidden)]
6370            type UnderlyingRustTuple<'a> = ();
6371            #[cfg(test)]
6372            #[allow(dead_code, unreachable_patterns)]
6373            fn _type_assertion(
6374                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6375            ) {
6376                match _t {
6377                    alloy_sol_types::private::AssertTypeEq::<
6378                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6379                    >(_) => {}
6380                }
6381            }
6382            #[automatically_derived]
6383            #[doc(hidden)]
6384            impl ::core::convert::From<addStrategiesToOperatorSetReturn>
6385            for UnderlyingRustTuple<'_> {
6386                fn from(value: addStrategiesToOperatorSetReturn) -> Self {
6387                    ()
6388                }
6389            }
6390            #[automatically_derived]
6391            #[doc(hidden)]
6392            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6393            for addStrategiesToOperatorSetReturn {
6394                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6395                    Self {}
6396                }
6397            }
6398        }
6399        impl addStrategiesToOperatorSetReturn {
6400            fn _tokenize(
6401                &self,
6402            ) -> <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::ReturnToken<
6403                '_,
6404            > {
6405                ()
6406            }
6407        }
6408        #[automatically_derived]
6409        impl alloy_sol_types::SolCall for addStrategiesToOperatorSetCall {
6410            type Parameters<'a> = (
6411                alloy::sol_types::sol_data::Address,
6412                alloy::sol_types::sol_data::Uint<32>,
6413                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6414            );
6415            type Token<'a> = <Self::Parameters<
6416                'a,
6417            > as alloy_sol_types::SolType>::Token<'a>;
6418            type Return = addStrategiesToOperatorSetReturn;
6419            type ReturnTuple<'a> = ();
6420            type ReturnToken<'a> = <Self::ReturnTuple<
6421                'a,
6422            > as alloy_sol_types::SolType>::Token<'a>;
6423            const SIGNATURE: &'static str = "addStrategiesToOperatorSet(address,uint32,address[])";
6424            const SELECTOR: [u8; 4] = [80u8, 254u8, 234u8, 32u8];
6425            #[inline]
6426            fn new<'a>(
6427                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6428            ) -> Self {
6429                tuple.into()
6430            }
6431            #[inline]
6432            fn tokenize(&self) -> Self::Token<'_> {
6433                (
6434                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6435                        &self.avs,
6436                    ),
6437                    <alloy::sol_types::sol_data::Uint<
6438                        32,
6439                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
6440                    <alloy::sol_types::sol_data::Array<
6441                        alloy::sol_types::sol_data::Address,
6442                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
6443                )
6444            }
6445            #[inline]
6446            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6447                addStrategiesToOperatorSetReturn::_tokenize(ret)
6448            }
6449            #[inline]
6450            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6451                <Self::ReturnTuple<
6452                    '_,
6453                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6454                    .map(Into::into)
6455            }
6456            #[inline]
6457            fn abi_decode_returns_validate(
6458                data: &[u8],
6459            ) -> alloy_sol_types::Result<Self::Return> {
6460                <Self::ReturnTuple<
6461                    '_,
6462                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6463                    .map(Into::into)
6464            }
6465        }
6466    };
6467    #[derive(serde::Serialize, serde::Deserialize)]
6468    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6469    /**Function with signature `clearDeallocationQueue(address,address[],uint16[])` and selector `0x4b5046ef`.
6470```solidity
6471function clearDeallocationQueue(address operator, address[] memory strategies, uint16[] memory numToClear) external;
6472```*/
6473    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6474    #[derive(Clone)]
6475    pub struct clearDeallocationQueueCall {
6476        #[allow(missing_docs)]
6477        pub operator: alloy::sol_types::private::Address,
6478        #[allow(missing_docs)]
6479        pub strategies: alloy::sol_types::private::Vec<
6480            alloy::sol_types::private::Address,
6481        >,
6482        #[allow(missing_docs)]
6483        pub numToClear: alloy::sol_types::private::Vec<u16>,
6484    }
6485    ///Container type for the return parameters of the [`clearDeallocationQueue(address,address[],uint16[])`](clearDeallocationQueueCall) function.
6486    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6487    #[derive(Clone)]
6488    pub struct clearDeallocationQueueReturn {}
6489    #[allow(
6490        non_camel_case_types,
6491        non_snake_case,
6492        clippy::pub_underscore_fields,
6493        clippy::style
6494    )]
6495    const _: () = {
6496        use alloy::sol_types as alloy_sol_types;
6497        {
6498            #[doc(hidden)]
6499            type UnderlyingSolTuple<'a> = (
6500                alloy::sol_types::sol_data::Address,
6501                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6502                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<16>>,
6503            );
6504            #[doc(hidden)]
6505            type UnderlyingRustTuple<'a> = (
6506                alloy::sol_types::private::Address,
6507                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
6508                alloy::sol_types::private::Vec<u16>,
6509            );
6510            #[cfg(test)]
6511            #[allow(dead_code, unreachable_patterns)]
6512            fn _type_assertion(
6513                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6514            ) {
6515                match _t {
6516                    alloy_sol_types::private::AssertTypeEq::<
6517                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6518                    >(_) => {}
6519                }
6520            }
6521            #[automatically_derived]
6522            #[doc(hidden)]
6523            impl ::core::convert::From<clearDeallocationQueueCall>
6524            for UnderlyingRustTuple<'_> {
6525                fn from(value: clearDeallocationQueueCall) -> Self {
6526                    (value.operator, value.strategies, value.numToClear)
6527                }
6528            }
6529            #[automatically_derived]
6530            #[doc(hidden)]
6531            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6532            for clearDeallocationQueueCall {
6533                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6534                    Self {
6535                        operator: tuple.0,
6536                        strategies: tuple.1,
6537                        numToClear: tuple.2,
6538                    }
6539                }
6540            }
6541        }
6542        {
6543            #[doc(hidden)]
6544            type UnderlyingSolTuple<'a> = ();
6545            #[doc(hidden)]
6546            type UnderlyingRustTuple<'a> = ();
6547            #[cfg(test)]
6548            #[allow(dead_code, unreachable_patterns)]
6549            fn _type_assertion(
6550                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6551            ) {
6552                match _t {
6553                    alloy_sol_types::private::AssertTypeEq::<
6554                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6555                    >(_) => {}
6556                }
6557            }
6558            #[automatically_derived]
6559            #[doc(hidden)]
6560            impl ::core::convert::From<clearDeallocationQueueReturn>
6561            for UnderlyingRustTuple<'_> {
6562                fn from(value: clearDeallocationQueueReturn) -> Self {
6563                    ()
6564                }
6565            }
6566            #[automatically_derived]
6567            #[doc(hidden)]
6568            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6569            for clearDeallocationQueueReturn {
6570                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6571                    Self {}
6572                }
6573            }
6574        }
6575        impl clearDeallocationQueueReturn {
6576            fn _tokenize(
6577                &self,
6578            ) -> <clearDeallocationQueueCall as alloy_sol_types::SolCall>::ReturnToken<
6579                '_,
6580            > {
6581                ()
6582            }
6583        }
6584        #[automatically_derived]
6585        impl alloy_sol_types::SolCall for clearDeallocationQueueCall {
6586            type Parameters<'a> = (
6587                alloy::sol_types::sol_data::Address,
6588                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
6589                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<16>>,
6590            );
6591            type Token<'a> = <Self::Parameters<
6592                'a,
6593            > as alloy_sol_types::SolType>::Token<'a>;
6594            type Return = clearDeallocationQueueReturn;
6595            type ReturnTuple<'a> = ();
6596            type ReturnToken<'a> = <Self::ReturnTuple<
6597                'a,
6598            > as alloy_sol_types::SolType>::Token<'a>;
6599            const SIGNATURE: &'static str = "clearDeallocationQueue(address,address[],uint16[])";
6600            const SELECTOR: [u8; 4] = [75u8, 80u8, 70u8, 239u8];
6601            #[inline]
6602            fn new<'a>(
6603                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6604            ) -> Self {
6605                tuple.into()
6606            }
6607            #[inline]
6608            fn tokenize(&self) -> Self::Token<'_> {
6609                (
6610                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6611                        &self.operator,
6612                    ),
6613                    <alloy::sol_types::sol_data::Array<
6614                        alloy::sol_types::sol_data::Address,
6615                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
6616                    <alloy::sol_types::sol_data::Array<
6617                        alloy::sol_types::sol_data::Uint<16>,
6618                    > as alloy_sol_types::SolType>::tokenize(&self.numToClear),
6619                )
6620            }
6621            #[inline]
6622            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6623                clearDeallocationQueueReturn::_tokenize(ret)
6624            }
6625            #[inline]
6626            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6627                <Self::ReturnTuple<
6628                    '_,
6629                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6630                    .map(Into::into)
6631            }
6632            #[inline]
6633            fn abi_decode_returns_validate(
6634                data: &[u8],
6635            ) -> alloy_sol_types::Result<Self::Return> {
6636                <Self::ReturnTuple<
6637                    '_,
6638                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6639                    .map(Into::into)
6640            }
6641        }
6642    };
6643    #[derive(serde::Serialize, serde::Deserialize)]
6644    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6645    /**Function with signature `createOperatorSets(address,(uint32,address[])[])` and selector `0x261f84e0`.
6646```solidity
6647function createOperatorSets(address avs, IAllocationManagerTypes.CreateSetParams[] memory params) external;
6648```*/
6649    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6650    #[derive(Clone)]
6651    pub struct createOperatorSetsCall {
6652        #[allow(missing_docs)]
6653        pub avs: alloy::sol_types::private::Address,
6654        #[allow(missing_docs)]
6655        pub params: alloy::sol_types::private::Vec<
6656            <IAllocationManagerTypes::CreateSetParams as alloy::sol_types::SolType>::RustType,
6657        >,
6658    }
6659    ///Container type for the return parameters of the [`createOperatorSets(address,(uint32,address[])[])`](createOperatorSetsCall) function.
6660    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6661    #[derive(Clone)]
6662    pub struct createOperatorSetsReturn {}
6663    #[allow(
6664        non_camel_case_types,
6665        non_snake_case,
6666        clippy::pub_underscore_fields,
6667        clippy::style
6668    )]
6669    const _: () = {
6670        use alloy::sol_types as alloy_sol_types;
6671        {
6672            #[doc(hidden)]
6673            type UnderlyingSolTuple<'a> = (
6674                alloy::sol_types::sol_data::Address,
6675                alloy::sol_types::sol_data::Array<
6676                    IAllocationManagerTypes::CreateSetParams,
6677                >,
6678            );
6679            #[doc(hidden)]
6680            type UnderlyingRustTuple<'a> = (
6681                alloy::sol_types::private::Address,
6682                alloy::sol_types::private::Vec<
6683                    <IAllocationManagerTypes::CreateSetParams as alloy::sol_types::SolType>::RustType,
6684                >,
6685            );
6686            #[cfg(test)]
6687            #[allow(dead_code, unreachable_patterns)]
6688            fn _type_assertion(
6689                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6690            ) {
6691                match _t {
6692                    alloy_sol_types::private::AssertTypeEq::<
6693                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6694                    >(_) => {}
6695                }
6696            }
6697            #[automatically_derived]
6698            #[doc(hidden)]
6699            impl ::core::convert::From<createOperatorSetsCall>
6700            for UnderlyingRustTuple<'_> {
6701                fn from(value: createOperatorSetsCall) -> Self {
6702                    (value.avs, value.params)
6703                }
6704            }
6705            #[automatically_derived]
6706            #[doc(hidden)]
6707            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6708            for createOperatorSetsCall {
6709                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6710                    Self {
6711                        avs: tuple.0,
6712                        params: tuple.1,
6713                    }
6714                }
6715            }
6716        }
6717        {
6718            #[doc(hidden)]
6719            type UnderlyingSolTuple<'a> = ();
6720            #[doc(hidden)]
6721            type UnderlyingRustTuple<'a> = ();
6722            #[cfg(test)]
6723            #[allow(dead_code, unreachable_patterns)]
6724            fn _type_assertion(
6725                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6726            ) {
6727                match _t {
6728                    alloy_sol_types::private::AssertTypeEq::<
6729                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6730                    >(_) => {}
6731                }
6732            }
6733            #[automatically_derived]
6734            #[doc(hidden)]
6735            impl ::core::convert::From<createOperatorSetsReturn>
6736            for UnderlyingRustTuple<'_> {
6737                fn from(value: createOperatorSetsReturn) -> Self {
6738                    ()
6739                }
6740            }
6741            #[automatically_derived]
6742            #[doc(hidden)]
6743            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6744            for createOperatorSetsReturn {
6745                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6746                    Self {}
6747                }
6748            }
6749        }
6750        impl createOperatorSetsReturn {
6751            fn _tokenize(
6752                &self,
6753            ) -> <createOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
6754                ()
6755            }
6756        }
6757        #[automatically_derived]
6758        impl alloy_sol_types::SolCall for createOperatorSetsCall {
6759            type Parameters<'a> = (
6760                alloy::sol_types::sol_data::Address,
6761                alloy::sol_types::sol_data::Array<
6762                    IAllocationManagerTypes::CreateSetParams,
6763                >,
6764            );
6765            type Token<'a> = <Self::Parameters<
6766                'a,
6767            > as alloy_sol_types::SolType>::Token<'a>;
6768            type Return = createOperatorSetsReturn;
6769            type ReturnTuple<'a> = ();
6770            type ReturnToken<'a> = <Self::ReturnTuple<
6771                'a,
6772            > as alloy_sol_types::SolType>::Token<'a>;
6773            const SIGNATURE: &'static str = "createOperatorSets(address,(uint32,address[])[])";
6774            const SELECTOR: [u8; 4] = [38u8, 31u8, 132u8, 224u8];
6775            #[inline]
6776            fn new<'a>(
6777                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6778            ) -> Self {
6779                tuple.into()
6780            }
6781            #[inline]
6782            fn tokenize(&self) -> Self::Token<'_> {
6783                (
6784                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
6785                        &self.avs,
6786                    ),
6787                    <alloy::sol_types::sol_data::Array<
6788                        IAllocationManagerTypes::CreateSetParams,
6789                    > as alloy_sol_types::SolType>::tokenize(&self.params),
6790                )
6791            }
6792            #[inline]
6793            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6794                createOperatorSetsReturn::_tokenize(ret)
6795            }
6796            #[inline]
6797            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6798                <Self::ReturnTuple<
6799                    '_,
6800                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6801                    .map(Into::into)
6802            }
6803            #[inline]
6804            fn abi_decode_returns_validate(
6805                data: &[u8],
6806            ) -> alloy_sol_types::Result<Self::Return> {
6807                <Self::ReturnTuple<
6808                    '_,
6809                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6810                    .map(Into::into)
6811            }
6812        }
6813    };
6814    #[derive(serde::Serialize, serde::Deserialize)]
6815    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6816    /**Function with signature `deregisterFromOperatorSets((address,address,uint32[]))` and selector `0x6e3492b5`.
6817```solidity
6818function deregisterFromOperatorSets(IAllocationManagerTypes.DeregisterParams memory params) external;
6819```*/
6820    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6821    #[derive(Clone)]
6822    pub struct deregisterFromOperatorSetsCall {
6823        #[allow(missing_docs)]
6824        pub params: <IAllocationManagerTypes::DeregisterParams as alloy::sol_types::SolType>::RustType,
6825    }
6826    ///Container type for the return parameters of the [`deregisterFromOperatorSets((address,address,uint32[]))`](deregisterFromOperatorSetsCall) function.
6827    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6828    #[derive(Clone)]
6829    pub struct deregisterFromOperatorSetsReturn {}
6830    #[allow(
6831        non_camel_case_types,
6832        non_snake_case,
6833        clippy::pub_underscore_fields,
6834        clippy::style
6835    )]
6836    const _: () = {
6837        use alloy::sol_types as alloy_sol_types;
6838        {
6839            #[doc(hidden)]
6840            type UnderlyingSolTuple<'a> = (IAllocationManagerTypes::DeregisterParams,);
6841            #[doc(hidden)]
6842            type UnderlyingRustTuple<'a> = (
6843                <IAllocationManagerTypes::DeregisterParams as alloy::sol_types::SolType>::RustType,
6844            );
6845            #[cfg(test)]
6846            #[allow(dead_code, unreachable_patterns)]
6847            fn _type_assertion(
6848                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6849            ) {
6850                match _t {
6851                    alloy_sol_types::private::AssertTypeEq::<
6852                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6853                    >(_) => {}
6854                }
6855            }
6856            #[automatically_derived]
6857            #[doc(hidden)]
6858            impl ::core::convert::From<deregisterFromOperatorSetsCall>
6859            for UnderlyingRustTuple<'_> {
6860                fn from(value: deregisterFromOperatorSetsCall) -> Self {
6861                    (value.params,)
6862                }
6863            }
6864            #[automatically_derived]
6865            #[doc(hidden)]
6866            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6867            for deregisterFromOperatorSetsCall {
6868                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6869                    Self { params: tuple.0 }
6870                }
6871            }
6872        }
6873        {
6874            #[doc(hidden)]
6875            type UnderlyingSolTuple<'a> = ();
6876            #[doc(hidden)]
6877            type UnderlyingRustTuple<'a> = ();
6878            #[cfg(test)]
6879            #[allow(dead_code, unreachable_patterns)]
6880            fn _type_assertion(
6881                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
6882            ) {
6883                match _t {
6884                    alloy_sol_types::private::AssertTypeEq::<
6885                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
6886                    >(_) => {}
6887                }
6888            }
6889            #[automatically_derived]
6890            #[doc(hidden)]
6891            impl ::core::convert::From<deregisterFromOperatorSetsReturn>
6892            for UnderlyingRustTuple<'_> {
6893                fn from(value: deregisterFromOperatorSetsReturn) -> Self {
6894                    ()
6895                }
6896            }
6897            #[automatically_derived]
6898            #[doc(hidden)]
6899            impl ::core::convert::From<UnderlyingRustTuple<'_>>
6900            for deregisterFromOperatorSetsReturn {
6901                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
6902                    Self {}
6903                }
6904            }
6905        }
6906        impl deregisterFromOperatorSetsReturn {
6907            fn _tokenize(
6908                &self,
6909            ) -> <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<
6910                '_,
6911            > {
6912                ()
6913            }
6914        }
6915        #[automatically_derived]
6916        impl alloy_sol_types::SolCall for deregisterFromOperatorSetsCall {
6917            type Parameters<'a> = (IAllocationManagerTypes::DeregisterParams,);
6918            type Token<'a> = <Self::Parameters<
6919                'a,
6920            > as alloy_sol_types::SolType>::Token<'a>;
6921            type Return = deregisterFromOperatorSetsReturn;
6922            type ReturnTuple<'a> = ();
6923            type ReturnToken<'a> = <Self::ReturnTuple<
6924                'a,
6925            > as alloy_sol_types::SolType>::Token<'a>;
6926            const SIGNATURE: &'static str = "deregisterFromOperatorSets((address,address,uint32[]))";
6927            const SELECTOR: [u8; 4] = [110u8, 52u8, 146u8, 181u8];
6928            #[inline]
6929            fn new<'a>(
6930                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
6931            ) -> Self {
6932                tuple.into()
6933            }
6934            #[inline]
6935            fn tokenize(&self) -> Self::Token<'_> {
6936                (
6937                    <IAllocationManagerTypes::DeregisterParams as alloy_sol_types::SolType>::tokenize(
6938                        &self.params,
6939                    ),
6940                )
6941            }
6942            #[inline]
6943            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
6944                deregisterFromOperatorSetsReturn::_tokenize(ret)
6945            }
6946            #[inline]
6947            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
6948                <Self::ReturnTuple<
6949                    '_,
6950                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
6951                    .map(Into::into)
6952            }
6953            #[inline]
6954            fn abi_decode_returns_validate(
6955                data: &[u8],
6956            ) -> alloy_sol_types::Result<Self::Return> {
6957                <Self::ReturnTuple<
6958                    '_,
6959                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
6960                    .map(Into::into)
6961            }
6962        }
6963    };
6964    #[derive(serde::Serialize, serde::Deserialize)]
6965    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6966    /**Function with signature `getAVSRegistrar(address)` and selector `0x304c10cd`.
6967```solidity
6968function getAVSRegistrar(address avs) external view returns (address);
6969```*/
6970    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6971    #[derive(Clone)]
6972    pub struct getAVSRegistrarCall {
6973        #[allow(missing_docs)]
6974        pub avs: alloy::sol_types::private::Address,
6975    }
6976    #[derive(serde::Serialize, serde::Deserialize)]
6977    #[derive(Default, Debug, PartialEq, Eq, Hash)]
6978    ///Container type for the return parameters of the [`getAVSRegistrar(address)`](getAVSRegistrarCall) function.
6979    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
6980    #[derive(Clone)]
6981    pub struct getAVSRegistrarReturn {
6982        #[allow(missing_docs)]
6983        pub _0: alloy::sol_types::private::Address,
6984    }
6985    #[allow(
6986        non_camel_case_types,
6987        non_snake_case,
6988        clippy::pub_underscore_fields,
6989        clippy::style
6990    )]
6991    const _: () = {
6992        use alloy::sol_types as alloy_sol_types;
6993        {
6994            #[doc(hidden)]
6995            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
6996            #[doc(hidden)]
6997            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
6998            #[cfg(test)]
6999            #[allow(dead_code, unreachable_patterns)]
7000            fn _type_assertion(
7001                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7002            ) {
7003                match _t {
7004                    alloy_sol_types::private::AssertTypeEq::<
7005                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7006                    >(_) => {}
7007                }
7008            }
7009            #[automatically_derived]
7010            #[doc(hidden)]
7011            impl ::core::convert::From<getAVSRegistrarCall> for UnderlyingRustTuple<'_> {
7012                fn from(value: getAVSRegistrarCall) -> Self {
7013                    (value.avs,)
7014                }
7015            }
7016            #[automatically_derived]
7017            #[doc(hidden)]
7018            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAVSRegistrarCall {
7019                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7020                    Self { avs: tuple.0 }
7021                }
7022            }
7023        }
7024        {
7025            #[doc(hidden)]
7026            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7027            #[doc(hidden)]
7028            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7029            #[cfg(test)]
7030            #[allow(dead_code, unreachable_patterns)]
7031            fn _type_assertion(
7032                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7033            ) {
7034                match _t {
7035                    alloy_sol_types::private::AssertTypeEq::<
7036                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7037                    >(_) => {}
7038                }
7039            }
7040            #[automatically_derived]
7041            #[doc(hidden)]
7042            impl ::core::convert::From<getAVSRegistrarReturn>
7043            for UnderlyingRustTuple<'_> {
7044                fn from(value: getAVSRegistrarReturn) -> Self {
7045                    (value._0,)
7046                }
7047            }
7048            #[automatically_derived]
7049            #[doc(hidden)]
7050            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7051            for getAVSRegistrarReturn {
7052                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7053                    Self { _0: tuple.0 }
7054                }
7055            }
7056        }
7057        #[automatically_derived]
7058        impl alloy_sol_types::SolCall for getAVSRegistrarCall {
7059            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
7060            type Token<'a> = <Self::Parameters<
7061                'a,
7062            > as alloy_sol_types::SolType>::Token<'a>;
7063            type Return = alloy::sol_types::private::Address;
7064            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
7065            type ReturnToken<'a> = <Self::ReturnTuple<
7066                'a,
7067            > as alloy_sol_types::SolType>::Token<'a>;
7068            const SIGNATURE: &'static str = "getAVSRegistrar(address)";
7069            const SELECTOR: [u8; 4] = [48u8, 76u8, 16u8, 205u8];
7070            #[inline]
7071            fn new<'a>(
7072                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7073            ) -> Self {
7074                tuple.into()
7075            }
7076            #[inline]
7077            fn tokenize(&self) -> Self::Token<'_> {
7078                (
7079                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7080                        &self.avs,
7081                    ),
7082                )
7083            }
7084            #[inline]
7085            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7086                (
7087                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7088                        ret,
7089                    ),
7090                )
7091            }
7092            #[inline]
7093            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7094                <Self::ReturnTuple<
7095                    '_,
7096                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7097                    .map(|r| {
7098                        let r: getAVSRegistrarReturn = r.into();
7099                        r._0
7100                    })
7101            }
7102            #[inline]
7103            fn abi_decode_returns_validate(
7104                data: &[u8],
7105            ) -> alloy_sol_types::Result<Self::Return> {
7106                <Self::ReturnTuple<
7107                    '_,
7108                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7109                    .map(|r| {
7110                        let r: getAVSRegistrarReturn = r.into();
7111                        r._0
7112                    })
7113            }
7114        }
7115    };
7116    #[derive(serde::Serialize, serde::Deserialize)]
7117    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7118    /**Function with signature `getAllocatableMagnitude(address,address)` and selector `0x6cfb4481`.
7119```solidity
7120function getAllocatableMagnitude(address operator, address strategy) external view returns (uint64);
7121```*/
7122    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7123    #[derive(Clone)]
7124    pub struct getAllocatableMagnitudeCall {
7125        #[allow(missing_docs)]
7126        pub operator: alloy::sol_types::private::Address,
7127        #[allow(missing_docs)]
7128        pub strategy: alloy::sol_types::private::Address,
7129    }
7130    #[derive(serde::Serialize, serde::Deserialize)]
7131    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7132    ///Container type for the return parameters of the [`getAllocatableMagnitude(address,address)`](getAllocatableMagnitudeCall) function.
7133    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7134    #[derive(Clone)]
7135    pub struct getAllocatableMagnitudeReturn {
7136        #[allow(missing_docs)]
7137        pub _0: u64,
7138    }
7139    #[allow(
7140        non_camel_case_types,
7141        non_snake_case,
7142        clippy::pub_underscore_fields,
7143        clippy::style
7144    )]
7145    const _: () = {
7146        use alloy::sol_types as alloy_sol_types;
7147        {
7148            #[doc(hidden)]
7149            type UnderlyingSolTuple<'a> = (
7150                alloy::sol_types::sol_data::Address,
7151                alloy::sol_types::sol_data::Address,
7152            );
7153            #[doc(hidden)]
7154            type UnderlyingRustTuple<'a> = (
7155                alloy::sol_types::private::Address,
7156                alloy::sol_types::private::Address,
7157            );
7158            #[cfg(test)]
7159            #[allow(dead_code, unreachable_patterns)]
7160            fn _type_assertion(
7161                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7162            ) {
7163                match _t {
7164                    alloy_sol_types::private::AssertTypeEq::<
7165                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7166                    >(_) => {}
7167                }
7168            }
7169            #[automatically_derived]
7170            #[doc(hidden)]
7171            impl ::core::convert::From<getAllocatableMagnitudeCall>
7172            for UnderlyingRustTuple<'_> {
7173                fn from(value: getAllocatableMagnitudeCall) -> Self {
7174                    (value.operator, value.strategy)
7175                }
7176            }
7177            #[automatically_derived]
7178            #[doc(hidden)]
7179            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7180            for getAllocatableMagnitudeCall {
7181                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7182                    Self {
7183                        operator: tuple.0,
7184                        strategy: tuple.1,
7185                    }
7186                }
7187            }
7188        }
7189        {
7190            #[doc(hidden)]
7191            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
7192            #[doc(hidden)]
7193            type UnderlyingRustTuple<'a> = (u64,);
7194            #[cfg(test)]
7195            #[allow(dead_code, unreachable_patterns)]
7196            fn _type_assertion(
7197                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7198            ) {
7199                match _t {
7200                    alloy_sol_types::private::AssertTypeEq::<
7201                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7202                    >(_) => {}
7203                }
7204            }
7205            #[automatically_derived]
7206            #[doc(hidden)]
7207            impl ::core::convert::From<getAllocatableMagnitudeReturn>
7208            for UnderlyingRustTuple<'_> {
7209                fn from(value: getAllocatableMagnitudeReturn) -> Self {
7210                    (value._0,)
7211                }
7212            }
7213            #[automatically_derived]
7214            #[doc(hidden)]
7215            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7216            for getAllocatableMagnitudeReturn {
7217                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7218                    Self { _0: tuple.0 }
7219                }
7220            }
7221        }
7222        #[automatically_derived]
7223        impl alloy_sol_types::SolCall for getAllocatableMagnitudeCall {
7224            type Parameters<'a> = (
7225                alloy::sol_types::sol_data::Address,
7226                alloy::sol_types::sol_data::Address,
7227            );
7228            type Token<'a> = <Self::Parameters<
7229                'a,
7230            > as alloy_sol_types::SolType>::Token<'a>;
7231            type Return = u64;
7232            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
7233            type ReturnToken<'a> = <Self::ReturnTuple<
7234                'a,
7235            > as alloy_sol_types::SolType>::Token<'a>;
7236            const SIGNATURE: &'static str = "getAllocatableMagnitude(address,address)";
7237            const SELECTOR: [u8; 4] = [108u8, 251u8, 68u8, 129u8];
7238            #[inline]
7239            fn new<'a>(
7240                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7241            ) -> Self {
7242                tuple.into()
7243            }
7244            #[inline]
7245            fn tokenize(&self) -> Self::Token<'_> {
7246                (
7247                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7248                        &self.operator,
7249                    ),
7250                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7251                        &self.strategy,
7252                    ),
7253                )
7254            }
7255            #[inline]
7256            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7257                (
7258                    <alloy::sol_types::sol_data::Uint<
7259                        64,
7260                    > as alloy_sol_types::SolType>::tokenize(ret),
7261                )
7262            }
7263            #[inline]
7264            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7265                <Self::ReturnTuple<
7266                    '_,
7267                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7268                    .map(|r| {
7269                        let r: getAllocatableMagnitudeReturn = r.into();
7270                        r._0
7271                    })
7272            }
7273            #[inline]
7274            fn abi_decode_returns_validate(
7275                data: &[u8],
7276            ) -> alloy_sol_types::Result<Self::Return> {
7277                <Self::ReturnTuple<
7278                    '_,
7279                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7280                    .map(|r| {
7281                        let r: getAllocatableMagnitudeReturn = r.into();
7282                        r._0
7283                    })
7284            }
7285        }
7286    };
7287    #[derive(serde::Serialize, serde::Deserialize)]
7288    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7289    /**Function with signature `getAllocatedSets(address)` and selector `0x15fe5028`.
7290```solidity
7291function getAllocatedSets(address operator) external view returns (OperatorSet[] memory);
7292```*/
7293    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7294    #[derive(Clone)]
7295    pub struct getAllocatedSetsCall {
7296        #[allow(missing_docs)]
7297        pub operator: alloy::sol_types::private::Address,
7298    }
7299    #[derive(serde::Serialize, serde::Deserialize)]
7300    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7301    ///Container type for the return parameters of the [`getAllocatedSets(address)`](getAllocatedSetsCall) function.
7302    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7303    #[derive(Clone)]
7304    pub struct getAllocatedSetsReturn {
7305        #[allow(missing_docs)]
7306        pub _0: alloy::sol_types::private::Vec<
7307            <OperatorSet as alloy::sol_types::SolType>::RustType,
7308        >,
7309    }
7310    #[allow(
7311        non_camel_case_types,
7312        non_snake_case,
7313        clippy::pub_underscore_fields,
7314        clippy::style
7315    )]
7316    const _: () = {
7317        use alloy::sol_types as alloy_sol_types;
7318        {
7319            #[doc(hidden)]
7320            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
7321            #[doc(hidden)]
7322            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
7323            #[cfg(test)]
7324            #[allow(dead_code, unreachable_patterns)]
7325            fn _type_assertion(
7326                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7327            ) {
7328                match _t {
7329                    alloy_sol_types::private::AssertTypeEq::<
7330                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7331                    >(_) => {}
7332                }
7333            }
7334            #[automatically_derived]
7335            #[doc(hidden)]
7336            impl ::core::convert::From<getAllocatedSetsCall>
7337            for UnderlyingRustTuple<'_> {
7338                fn from(value: getAllocatedSetsCall) -> Self {
7339                    (value.operator,)
7340                }
7341            }
7342            #[automatically_derived]
7343            #[doc(hidden)]
7344            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7345            for getAllocatedSetsCall {
7346                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7347                    Self { operator: tuple.0 }
7348                }
7349            }
7350        }
7351        {
7352            #[doc(hidden)]
7353            type UnderlyingSolTuple<'a> = (
7354                alloy::sol_types::sol_data::Array<OperatorSet>,
7355            );
7356            #[doc(hidden)]
7357            type UnderlyingRustTuple<'a> = (
7358                alloy::sol_types::private::Vec<
7359                    <OperatorSet as alloy::sol_types::SolType>::RustType,
7360                >,
7361            );
7362            #[cfg(test)]
7363            #[allow(dead_code, unreachable_patterns)]
7364            fn _type_assertion(
7365                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7366            ) {
7367                match _t {
7368                    alloy_sol_types::private::AssertTypeEq::<
7369                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7370                    >(_) => {}
7371                }
7372            }
7373            #[automatically_derived]
7374            #[doc(hidden)]
7375            impl ::core::convert::From<getAllocatedSetsReturn>
7376            for UnderlyingRustTuple<'_> {
7377                fn from(value: getAllocatedSetsReturn) -> Self {
7378                    (value._0,)
7379                }
7380            }
7381            #[automatically_derived]
7382            #[doc(hidden)]
7383            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7384            for getAllocatedSetsReturn {
7385                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7386                    Self { _0: tuple.0 }
7387                }
7388            }
7389        }
7390        #[automatically_derived]
7391        impl alloy_sol_types::SolCall for getAllocatedSetsCall {
7392            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
7393            type Token<'a> = <Self::Parameters<
7394                'a,
7395            > as alloy_sol_types::SolType>::Token<'a>;
7396            type Return = alloy::sol_types::private::Vec<
7397                <OperatorSet as alloy::sol_types::SolType>::RustType,
7398            >;
7399            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Array<OperatorSet>,);
7400            type ReturnToken<'a> = <Self::ReturnTuple<
7401                'a,
7402            > as alloy_sol_types::SolType>::Token<'a>;
7403            const SIGNATURE: &'static str = "getAllocatedSets(address)";
7404            const SELECTOR: [u8; 4] = [21u8, 254u8, 80u8, 40u8];
7405            #[inline]
7406            fn new<'a>(
7407                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7408            ) -> Self {
7409                tuple.into()
7410            }
7411            #[inline]
7412            fn tokenize(&self) -> Self::Token<'_> {
7413                (
7414                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7415                        &self.operator,
7416                    ),
7417                )
7418            }
7419            #[inline]
7420            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7421                (
7422                    <alloy::sol_types::sol_data::Array<
7423                        OperatorSet,
7424                    > as alloy_sol_types::SolType>::tokenize(ret),
7425                )
7426            }
7427            #[inline]
7428            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7429                <Self::ReturnTuple<
7430                    '_,
7431                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7432                    .map(|r| {
7433                        let r: getAllocatedSetsReturn = r.into();
7434                        r._0
7435                    })
7436            }
7437            #[inline]
7438            fn abi_decode_returns_validate(
7439                data: &[u8],
7440            ) -> alloy_sol_types::Result<Self::Return> {
7441                <Self::ReturnTuple<
7442                    '_,
7443                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7444                    .map(|r| {
7445                        let r: getAllocatedSetsReturn = r.into();
7446                        r._0
7447                    })
7448            }
7449        }
7450    };
7451    #[derive(serde::Serialize, serde::Deserialize)]
7452    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7453    /**Function with signature `getAllocatedStake((address,uint32),address[],address[])` and selector `0x2b453a9a`.
7454```solidity
7455function getAllocatedStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies) external view returns (uint256[][] memory slashableStake);
7456```*/
7457    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7458    #[derive(Clone)]
7459    pub struct getAllocatedStakeCall {
7460        #[allow(missing_docs)]
7461        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
7462        #[allow(missing_docs)]
7463        pub operators: alloy::sol_types::private::Vec<
7464            alloy::sol_types::private::Address,
7465        >,
7466        #[allow(missing_docs)]
7467        pub strategies: alloy::sol_types::private::Vec<
7468            alloy::sol_types::private::Address,
7469        >,
7470    }
7471    #[derive(serde::Serialize, serde::Deserialize)]
7472    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7473    ///Container type for the return parameters of the [`getAllocatedStake((address,uint32),address[],address[])`](getAllocatedStakeCall) function.
7474    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7475    #[derive(Clone)]
7476    pub struct getAllocatedStakeReturn {
7477        #[allow(missing_docs)]
7478        pub slashableStake: alloy::sol_types::private::Vec<
7479            alloy::sol_types::private::Vec<
7480                alloy::sol_types::private::primitives::aliases::U256,
7481            >,
7482        >,
7483    }
7484    #[allow(
7485        non_camel_case_types,
7486        non_snake_case,
7487        clippy::pub_underscore_fields,
7488        clippy::style
7489    )]
7490    const _: () = {
7491        use alloy::sol_types as alloy_sol_types;
7492        {
7493            #[doc(hidden)]
7494            type UnderlyingSolTuple<'a> = (
7495                OperatorSet,
7496                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7497                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7498            );
7499            #[doc(hidden)]
7500            type UnderlyingRustTuple<'a> = (
7501                <OperatorSet as alloy::sol_types::SolType>::RustType,
7502                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7503                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7504            );
7505            #[cfg(test)]
7506            #[allow(dead_code, unreachable_patterns)]
7507            fn _type_assertion(
7508                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7509            ) {
7510                match _t {
7511                    alloy_sol_types::private::AssertTypeEq::<
7512                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7513                    >(_) => {}
7514                }
7515            }
7516            #[automatically_derived]
7517            #[doc(hidden)]
7518            impl ::core::convert::From<getAllocatedStakeCall>
7519            for UnderlyingRustTuple<'_> {
7520                fn from(value: getAllocatedStakeCall) -> Self {
7521                    (value.operatorSet, value.operators, value.strategies)
7522                }
7523            }
7524            #[automatically_derived]
7525            #[doc(hidden)]
7526            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7527            for getAllocatedStakeCall {
7528                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7529                    Self {
7530                        operatorSet: tuple.0,
7531                        operators: tuple.1,
7532                        strategies: tuple.2,
7533                    }
7534                }
7535            }
7536        }
7537        {
7538            #[doc(hidden)]
7539            type UnderlyingSolTuple<'a> = (
7540                alloy::sol_types::sol_data::Array<
7541                    alloy::sol_types::sol_data::Array<
7542                        alloy::sol_types::sol_data::Uint<256>,
7543                    >,
7544                >,
7545            );
7546            #[doc(hidden)]
7547            type UnderlyingRustTuple<'a> = (
7548                alloy::sol_types::private::Vec<
7549                    alloy::sol_types::private::Vec<
7550                        alloy::sol_types::private::primitives::aliases::U256,
7551                    >,
7552                >,
7553            );
7554            #[cfg(test)]
7555            #[allow(dead_code, unreachable_patterns)]
7556            fn _type_assertion(
7557                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7558            ) {
7559                match _t {
7560                    alloy_sol_types::private::AssertTypeEq::<
7561                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7562                    >(_) => {}
7563                }
7564            }
7565            #[automatically_derived]
7566            #[doc(hidden)]
7567            impl ::core::convert::From<getAllocatedStakeReturn>
7568            for UnderlyingRustTuple<'_> {
7569                fn from(value: getAllocatedStakeReturn) -> Self {
7570                    (value.slashableStake,)
7571                }
7572            }
7573            #[automatically_derived]
7574            #[doc(hidden)]
7575            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7576            for getAllocatedStakeReturn {
7577                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7578                    Self { slashableStake: tuple.0 }
7579                }
7580            }
7581        }
7582        #[automatically_derived]
7583        impl alloy_sol_types::SolCall for getAllocatedStakeCall {
7584            type Parameters<'a> = (
7585                OperatorSet,
7586                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7587                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7588            );
7589            type Token<'a> = <Self::Parameters<
7590                'a,
7591            > as alloy_sol_types::SolType>::Token<'a>;
7592            type Return = alloy::sol_types::private::Vec<
7593                alloy::sol_types::private::Vec<
7594                    alloy::sol_types::private::primitives::aliases::U256,
7595                >,
7596            >;
7597            type ReturnTuple<'a> = (
7598                alloy::sol_types::sol_data::Array<
7599                    alloy::sol_types::sol_data::Array<
7600                        alloy::sol_types::sol_data::Uint<256>,
7601                    >,
7602                >,
7603            );
7604            type ReturnToken<'a> = <Self::ReturnTuple<
7605                'a,
7606            > as alloy_sol_types::SolType>::Token<'a>;
7607            const SIGNATURE: &'static str = "getAllocatedStake((address,uint32),address[],address[])";
7608            const SELECTOR: [u8; 4] = [43u8, 69u8, 58u8, 154u8];
7609            #[inline]
7610            fn new<'a>(
7611                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7612            ) -> Self {
7613                tuple.into()
7614            }
7615            #[inline]
7616            fn tokenize(&self) -> Self::Token<'_> {
7617                (
7618                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
7619                        &self.operatorSet,
7620                    ),
7621                    <alloy::sol_types::sol_data::Array<
7622                        alloy::sol_types::sol_data::Address,
7623                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
7624                    <alloy::sol_types::sol_data::Array<
7625                        alloy::sol_types::sol_data::Address,
7626                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
7627                )
7628            }
7629            #[inline]
7630            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7631                (
7632                    <alloy::sol_types::sol_data::Array<
7633                        alloy::sol_types::sol_data::Array<
7634                            alloy::sol_types::sol_data::Uint<256>,
7635                        >,
7636                    > as alloy_sol_types::SolType>::tokenize(ret),
7637                )
7638            }
7639            #[inline]
7640            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7641                <Self::ReturnTuple<
7642                    '_,
7643                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7644                    .map(|r| {
7645                        let r: getAllocatedStakeReturn = r.into();
7646                        r.slashableStake
7647                    })
7648            }
7649            #[inline]
7650            fn abi_decode_returns_validate(
7651                data: &[u8],
7652            ) -> alloy_sol_types::Result<Self::Return> {
7653                <Self::ReturnTuple<
7654                    '_,
7655                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7656                    .map(|r| {
7657                        let r: getAllocatedStakeReturn = r.into();
7658                        r.slashableStake
7659                    })
7660            }
7661        }
7662    };
7663    #[derive(serde::Serialize, serde::Deserialize)]
7664    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7665    /**Function with signature `getAllocatedStrategies(address,(address,uint32))` and selector `0xc221d8ae`.
7666```solidity
7667function getAllocatedStrategies(address operator, OperatorSet memory operatorSet) external view returns (address[] memory);
7668```*/
7669    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7670    #[derive(Clone)]
7671    pub struct getAllocatedStrategiesCall {
7672        #[allow(missing_docs)]
7673        pub operator: alloy::sol_types::private::Address,
7674        #[allow(missing_docs)]
7675        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
7676    }
7677    #[derive(serde::Serialize, serde::Deserialize)]
7678    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7679    ///Container type for the return parameters of the [`getAllocatedStrategies(address,(address,uint32))`](getAllocatedStrategiesCall) function.
7680    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7681    #[derive(Clone)]
7682    pub struct getAllocatedStrategiesReturn {
7683        #[allow(missing_docs)]
7684        pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7685    }
7686    #[allow(
7687        non_camel_case_types,
7688        non_snake_case,
7689        clippy::pub_underscore_fields,
7690        clippy::style
7691    )]
7692    const _: () = {
7693        use alloy::sol_types as alloy_sol_types;
7694        {
7695            #[doc(hidden)]
7696            type UnderlyingSolTuple<'a> = (
7697                alloy::sol_types::sol_data::Address,
7698                OperatorSet,
7699            );
7700            #[doc(hidden)]
7701            type UnderlyingRustTuple<'a> = (
7702                alloy::sol_types::private::Address,
7703                <OperatorSet as alloy::sol_types::SolType>::RustType,
7704            );
7705            #[cfg(test)]
7706            #[allow(dead_code, unreachable_patterns)]
7707            fn _type_assertion(
7708                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7709            ) {
7710                match _t {
7711                    alloy_sol_types::private::AssertTypeEq::<
7712                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7713                    >(_) => {}
7714                }
7715            }
7716            #[automatically_derived]
7717            #[doc(hidden)]
7718            impl ::core::convert::From<getAllocatedStrategiesCall>
7719            for UnderlyingRustTuple<'_> {
7720                fn from(value: getAllocatedStrategiesCall) -> Self {
7721                    (value.operator, value.operatorSet)
7722                }
7723            }
7724            #[automatically_derived]
7725            #[doc(hidden)]
7726            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7727            for getAllocatedStrategiesCall {
7728                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7729                    Self {
7730                        operator: tuple.0,
7731                        operatorSet: tuple.1,
7732                    }
7733                }
7734            }
7735        }
7736        {
7737            #[doc(hidden)]
7738            type UnderlyingSolTuple<'a> = (
7739                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7740            );
7741            #[doc(hidden)]
7742            type UnderlyingRustTuple<'a> = (
7743                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
7744            );
7745            #[cfg(test)]
7746            #[allow(dead_code, unreachable_patterns)]
7747            fn _type_assertion(
7748                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7749            ) {
7750                match _t {
7751                    alloy_sol_types::private::AssertTypeEq::<
7752                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7753                    >(_) => {}
7754                }
7755            }
7756            #[automatically_derived]
7757            #[doc(hidden)]
7758            impl ::core::convert::From<getAllocatedStrategiesReturn>
7759            for UnderlyingRustTuple<'_> {
7760                fn from(value: getAllocatedStrategiesReturn) -> Self {
7761                    (value._0,)
7762                }
7763            }
7764            #[automatically_derived]
7765            #[doc(hidden)]
7766            impl ::core::convert::From<UnderlyingRustTuple<'_>>
7767            for getAllocatedStrategiesReturn {
7768                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7769                    Self { _0: tuple.0 }
7770                }
7771            }
7772        }
7773        #[automatically_derived]
7774        impl alloy_sol_types::SolCall for getAllocatedStrategiesCall {
7775            type Parameters<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
7776            type Token<'a> = <Self::Parameters<
7777                'a,
7778            > as alloy_sol_types::SolType>::Token<'a>;
7779            type Return = alloy::sol_types::private::Vec<
7780                alloy::sol_types::private::Address,
7781            >;
7782            type ReturnTuple<'a> = (
7783                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
7784            );
7785            type ReturnToken<'a> = <Self::ReturnTuple<
7786                'a,
7787            > as alloy_sol_types::SolType>::Token<'a>;
7788            const SIGNATURE: &'static str = "getAllocatedStrategies(address,(address,uint32))";
7789            const SELECTOR: [u8; 4] = [194u8, 33u8, 216u8, 174u8];
7790            #[inline]
7791            fn new<'a>(
7792                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7793            ) -> Self {
7794                tuple.into()
7795            }
7796            #[inline]
7797            fn tokenize(&self) -> Self::Token<'_> {
7798                (
7799                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7800                        &self.operator,
7801                    ),
7802                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
7803                        &self.operatorSet,
7804                    ),
7805                )
7806            }
7807            #[inline]
7808            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7809                (
7810                    <alloy::sol_types::sol_data::Array<
7811                        alloy::sol_types::sol_data::Address,
7812                    > as alloy_sol_types::SolType>::tokenize(ret),
7813                )
7814            }
7815            #[inline]
7816            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7817                <Self::ReturnTuple<
7818                    '_,
7819                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7820                    .map(|r| {
7821                        let r: getAllocatedStrategiesReturn = r.into();
7822                        r._0
7823                    })
7824            }
7825            #[inline]
7826            fn abi_decode_returns_validate(
7827                data: &[u8],
7828            ) -> alloy_sol_types::Result<Self::Return> {
7829                <Self::ReturnTuple<
7830                    '_,
7831                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
7832                    .map(|r| {
7833                        let r: getAllocatedStrategiesReturn = r.into();
7834                        r._0
7835                    })
7836            }
7837        }
7838    };
7839    #[derive(serde::Serialize, serde::Deserialize)]
7840    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7841    /**Function with signature `getAllocation(address,(address,uint32),address)` and selector `0x10e1b9b8`.
7842```solidity
7843function getAllocation(address operator, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation memory);
7844```*/
7845    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7846    #[derive(Clone)]
7847    pub struct getAllocationCall {
7848        #[allow(missing_docs)]
7849        pub operator: alloy::sol_types::private::Address,
7850        #[allow(missing_docs)]
7851        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
7852        #[allow(missing_docs)]
7853        pub strategy: alloy::sol_types::private::Address,
7854    }
7855    #[derive(serde::Serialize, serde::Deserialize)]
7856    #[derive(Default, Debug, PartialEq, Eq, Hash)]
7857    ///Container type for the return parameters of the [`getAllocation(address,(address,uint32),address)`](getAllocationCall) function.
7858    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
7859    #[derive(Clone)]
7860    pub struct getAllocationReturn {
7861        #[allow(missing_docs)]
7862        pub _0: <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
7863    }
7864    #[allow(
7865        non_camel_case_types,
7866        non_snake_case,
7867        clippy::pub_underscore_fields,
7868        clippy::style
7869    )]
7870    const _: () = {
7871        use alloy::sol_types as alloy_sol_types;
7872        {
7873            #[doc(hidden)]
7874            type UnderlyingSolTuple<'a> = (
7875                alloy::sol_types::sol_data::Address,
7876                OperatorSet,
7877                alloy::sol_types::sol_data::Address,
7878            );
7879            #[doc(hidden)]
7880            type UnderlyingRustTuple<'a> = (
7881                alloy::sol_types::private::Address,
7882                <OperatorSet as alloy::sol_types::SolType>::RustType,
7883                alloy::sol_types::private::Address,
7884            );
7885            #[cfg(test)]
7886            #[allow(dead_code, unreachable_patterns)]
7887            fn _type_assertion(
7888                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7889            ) {
7890                match _t {
7891                    alloy_sol_types::private::AssertTypeEq::<
7892                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7893                    >(_) => {}
7894                }
7895            }
7896            #[automatically_derived]
7897            #[doc(hidden)]
7898            impl ::core::convert::From<getAllocationCall> for UnderlyingRustTuple<'_> {
7899                fn from(value: getAllocationCall) -> Self {
7900                    (value.operator, value.operatorSet, value.strategy)
7901                }
7902            }
7903            #[automatically_derived]
7904            #[doc(hidden)]
7905            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationCall {
7906                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7907                    Self {
7908                        operator: tuple.0,
7909                        operatorSet: tuple.1,
7910                        strategy: tuple.2,
7911                    }
7912                }
7913            }
7914        }
7915        {
7916            #[doc(hidden)]
7917            type UnderlyingSolTuple<'a> = (IAllocationManagerTypes::Allocation,);
7918            #[doc(hidden)]
7919            type UnderlyingRustTuple<'a> = (
7920                <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
7921            );
7922            #[cfg(test)]
7923            #[allow(dead_code, unreachable_patterns)]
7924            fn _type_assertion(
7925                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
7926            ) {
7927                match _t {
7928                    alloy_sol_types::private::AssertTypeEq::<
7929                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
7930                    >(_) => {}
7931                }
7932            }
7933            #[automatically_derived]
7934            #[doc(hidden)]
7935            impl ::core::convert::From<getAllocationReturn> for UnderlyingRustTuple<'_> {
7936                fn from(value: getAllocationReturn) -> Self {
7937                    (value._0,)
7938                }
7939            }
7940            #[automatically_derived]
7941            #[doc(hidden)]
7942            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationReturn {
7943                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
7944                    Self { _0: tuple.0 }
7945                }
7946            }
7947        }
7948        #[automatically_derived]
7949        impl alloy_sol_types::SolCall for getAllocationCall {
7950            type Parameters<'a> = (
7951                alloy::sol_types::sol_data::Address,
7952                OperatorSet,
7953                alloy::sol_types::sol_data::Address,
7954            );
7955            type Token<'a> = <Self::Parameters<
7956                'a,
7957            > as alloy_sol_types::SolType>::Token<'a>;
7958            type Return = <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType;
7959            type ReturnTuple<'a> = (IAllocationManagerTypes::Allocation,);
7960            type ReturnToken<'a> = <Self::ReturnTuple<
7961                'a,
7962            > as alloy_sol_types::SolType>::Token<'a>;
7963            const SIGNATURE: &'static str = "getAllocation(address,(address,uint32),address)";
7964            const SELECTOR: [u8; 4] = [16u8, 225u8, 185u8, 184u8];
7965            #[inline]
7966            fn new<'a>(
7967                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
7968            ) -> Self {
7969                tuple.into()
7970            }
7971            #[inline]
7972            fn tokenize(&self) -> Self::Token<'_> {
7973                (
7974                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7975                        &self.operator,
7976                    ),
7977                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
7978                        &self.operatorSet,
7979                    ),
7980                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
7981                        &self.strategy,
7982                    ),
7983                )
7984            }
7985            #[inline]
7986            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
7987                (
7988                    <IAllocationManagerTypes::Allocation as alloy_sol_types::SolType>::tokenize(
7989                        ret,
7990                    ),
7991                )
7992            }
7993            #[inline]
7994            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
7995                <Self::ReturnTuple<
7996                    '_,
7997                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
7998                    .map(|r| {
7999                        let r: getAllocationReturn = r.into();
8000                        r._0
8001                    })
8002            }
8003            #[inline]
8004            fn abi_decode_returns_validate(
8005                data: &[u8],
8006            ) -> alloy_sol_types::Result<Self::Return> {
8007                <Self::ReturnTuple<
8008                    '_,
8009                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8010                    .map(|r| {
8011                        let r: getAllocationReturn = r.into();
8012                        r._0
8013                    })
8014            }
8015        }
8016    };
8017    #[derive(serde::Serialize, serde::Deserialize)]
8018    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8019    /**Function with signature `getAllocationDelay(address)` and selector `0xb9fbaed1`.
8020```solidity
8021function getAllocationDelay(address operator) external view returns (bool isSet, uint32 delay);
8022```*/
8023    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8024    #[derive(Clone)]
8025    pub struct getAllocationDelayCall {
8026        #[allow(missing_docs)]
8027        pub operator: alloy::sol_types::private::Address,
8028    }
8029    #[derive(serde::Serialize, serde::Deserialize)]
8030    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8031    ///Container type for the return parameters of the [`getAllocationDelay(address)`](getAllocationDelayCall) function.
8032    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8033    #[derive(Clone)]
8034    pub struct getAllocationDelayReturn {
8035        #[allow(missing_docs)]
8036        pub isSet: bool,
8037        #[allow(missing_docs)]
8038        pub delay: u32,
8039    }
8040    #[allow(
8041        non_camel_case_types,
8042        non_snake_case,
8043        clippy::pub_underscore_fields,
8044        clippy::style
8045    )]
8046    const _: () = {
8047        use alloy::sol_types as alloy_sol_types;
8048        {
8049            #[doc(hidden)]
8050            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
8051            #[doc(hidden)]
8052            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
8053            #[cfg(test)]
8054            #[allow(dead_code, unreachable_patterns)]
8055            fn _type_assertion(
8056                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8057            ) {
8058                match _t {
8059                    alloy_sol_types::private::AssertTypeEq::<
8060                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8061                    >(_) => {}
8062                }
8063            }
8064            #[automatically_derived]
8065            #[doc(hidden)]
8066            impl ::core::convert::From<getAllocationDelayCall>
8067            for UnderlyingRustTuple<'_> {
8068                fn from(value: getAllocationDelayCall) -> Self {
8069                    (value.operator,)
8070                }
8071            }
8072            #[automatically_derived]
8073            #[doc(hidden)]
8074            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8075            for getAllocationDelayCall {
8076                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8077                    Self { operator: tuple.0 }
8078                }
8079            }
8080        }
8081        {
8082            #[doc(hidden)]
8083            type UnderlyingSolTuple<'a> = (
8084                alloy::sol_types::sol_data::Bool,
8085                alloy::sol_types::sol_data::Uint<32>,
8086            );
8087            #[doc(hidden)]
8088            type UnderlyingRustTuple<'a> = (bool, u32);
8089            #[cfg(test)]
8090            #[allow(dead_code, unreachable_patterns)]
8091            fn _type_assertion(
8092                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8093            ) {
8094                match _t {
8095                    alloy_sol_types::private::AssertTypeEq::<
8096                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8097                    >(_) => {}
8098                }
8099            }
8100            #[automatically_derived]
8101            #[doc(hidden)]
8102            impl ::core::convert::From<getAllocationDelayReturn>
8103            for UnderlyingRustTuple<'_> {
8104                fn from(value: getAllocationDelayReturn) -> Self {
8105                    (value.isSet, value.delay)
8106                }
8107            }
8108            #[automatically_derived]
8109            #[doc(hidden)]
8110            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8111            for getAllocationDelayReturn {
8112                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8113                    Self {
8114                        isSet: tuple.0,
8115                        delay: tuple.1,
8116                    }
8117                }
8118            }
8119        }
8120        impl getAllocationDelayReturn {
8121            fn _tokenize(
8122                &self,
8123            ) -> <getAllocationDelayCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
8124                (
8125                    <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
8126                        &self.isSet,
8127                    ),
8128                    <alloy::sol_types::sol_data::Uint<
8129                        32,
8130                    > as alloy_sol_types::SolType>::tokenize(&self.delay),
8131                )
8132            }
8133        }
8134        #[automatically_derived]
8135        impl alloy_sol_types::SolCall for getAllocationDelayCall {
8136            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
8137            type Token<'a> = <Self::Parameters<
8138                'a,
8139            > as alloy_sol_types::SolType>::Token<'a>;
8140            type Return = getAllocationDelayReturn;
8141            type ReturnTuple<'a> = (
8142                alloy::sol_types::sol_data::Bool,
8143                alloy::sol_types::sol_data::Uint<32>,
8144            );
8145            type ReturnToken<'a> = <Self::ReturnTuple<
8146                'a,
8147            > as alloy_sol_types::SolType>::Token<'a>;
8148            const SIGNATURE: &'static str = "getAllocationDelay(address)";
8149            const SELECTOR: [u8; 4] = [185u8, 251u8, 174u8, 209u8];
8150            #[inline]
8151            fn new<'a>(
8152                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8153            ) -> Self {
8154                tuple.into()
8155            }
8156            #[inline]
8157            fn tokenize(&self) -> Self::Token<'_> {
8158                (
8159                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8160                        &self.operator,
8161                    ),
8162                )
8163            }
8164            #[inline]
8165            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8166                getAllocationDelayReturn::_tokenize(ret)
8167            }
8168            #[inline]
8169            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8170                <Self::ReturnTuple<
8171                    '_,
8172                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8173                    .map(Into::into)
8174            }
8175            #[inline]
8176            fn abi_decode_returns_validate(
8177                data: &[u8],
8178            ) -> alloy_sol_types::Result<Self::Return> {
8179                <Self::ReturnTuple<
8180                    '_,
8181                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8182                    .map(Into::into)
8183            }
8184        }
8185    };
8186    #[derive(serde::Serialize, serde::Deserialize)]
8187    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8188    /**Function with signature `getAllocations(address[],(address,uint32),address)` and selector `0x8ce64854`.
8189```solidity
8190function getAllocations(address[] memory operators, OperatorSet memory operatorSet, address strategy) external view returns (IAllocationManagerTypes.Allocation[] memory);
8191```*/
8192    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8193    #[derive(Clone)]
8194    pub struct getAllocationsCall {
8195        #[allow(missing_docs)]
8196        pub operators: alloy::sol_types::private::Vec<
8197            alloy::sol_types::private::Address,
8198        >,
8199        #[allow(missing_docs)]
8200        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
8201        #[allow(missing_docs)]
8202        pub strategy: alloy::sol_types::private::Address,
8203    }
8204    #[derive(serde::Serialize, serde::Deserialize)]
8205    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8206    ///Container type for the return parameters of the [`getAllocations(address[],(address,uint32),address)`](getAllocationsCall) function.
8207    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8208    #[derive(Clone)]
8209    pub struct getAllocationsReturn {
8210        #[allow(missing_docs)]
8211        pub _0: alloy::sol_types::private::Vec<
8212            <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
8213        >,
8214    }
8215    #[allow(
8216        non_camel_case_types,
8217        non_snake_case,
8218        clippy::pub_underscore_fields,
8219        clippy::style
8220    )]
8221    const _: () = {
8222        use alloy::sol_types as alloy_sol_types;
8223        {
8224            #[doc(hidden)]
8225            type UnderlyingSolTuple<'a> = (
8226                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
8227                OperatorSet,
8228                alloy::sol_types::sol_data::Address,
8229            );
8230            #[doc(hidden)]
8231            type UnderlyingRustTuple<'a> = (
8232                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8233                <OperatorSet as alloy::sol_types::SolType>::RustType,
8234                alloy::sol_types::private::Address,
8235            );
8236            #[cfg(test)]
8237            #[allow(dead_code, unreachable_patterns)]
8238            fn _type_assertion(
8239                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8240            ) {
8241                match _t {
8242                    alloy_sol_types::private::AssertTypeEq::<
8243                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8244                    >(_) => {}
8245                }
8246            }
8247            #[automatically_derived]
8248            #[doc(hidden)]
8249            impl ::core::convert::From<getAllocationsCall> for UnderlyingRustTuple<'_> {
8250                fn from(value: getAllocationsCall) -> Self {
8251                    (value.operators, value.operatorSet, value.strategy)
8252                }
8253            }
8254            #[automatically_derived]
8255            #[doc(hidden)]
8256            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAllocationsCall {
8257                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8258                    Self {
8259                        operators: tuple.0,
8260                        operatorSet: tuple.1,
8261                        strategy: tuple.2,
8262                    }
8263                }
8264            }
8265        }
8266        {
8267            #[doc(hidden)]
8268            type UnderlyingSolTuple<'a> = (
8269                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,
8270            );
8271            #[doc(hidden)]
8272            type UnderlyingRustTuple<'a> = (
8273                alloy::sol_types::private::Vec<
8274                    <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
8275                >,
8276            );
8277            #[cfg(test)]
8278            #[allow(dead_code, unreachable_patterns)]
8279            fn _type_assertion(
8280                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8281            ) {
8282                match _t {
8283                    alloy_sol_types::private::AssertTypeEq::<
8284                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8285                    >(_) => {}
8286                }
8287            }
8288            #[automatically_derived]
8289            #[doc(hidden)]
8290            impl ::core::convert::From<getAllocationsReturn>
8291            for UnderlyingRustTuple<'_> {
8292                fn from(value: getAllocationsReturn) -> Self {
8293                    (value._0,)
8294                }
8295            }
8296            #[automatically_derived]
8297            #[doc(hidden)]
8298            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8299            for getAllocationsReturn {
8300                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8301                    Self { _0: tuple.0 }
8302                }
8303            }
8304        }
8305        #[automatically_derived]
8306        impl alloy_sol_types::SolCall for getAllocationsCall {
8307            type Parameters<'a> = (
8308                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
8309                OperatorSet,
8310                alloy::sol_types::sol_data::Address,
8311            );
8312            type Token<'a> = <Self::Parameters<
8313                'a,
8314            > as alloy_sol_types::SolType>::Token<'a>;
8315            type Return = alloy::sol_types::private::Vec<
8316                <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
8317            >;
8318            type ReturnTuple<'a> = (
8319                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,
8320            );
8321            type ReturnToken<'a> = <Self::ReturnTuple<
8322                'a,
8323            > as alloy_sol_types::SolType>::Token<'a>;
8324            const SIGNATURE: &'static str = "getAllocations(address[],(address,uint32),address)";
8325            const SELECTOR: [u8; 4] = [140u8, 230u8, 72u8, 84u8];
8326            #[inline]
8327            fn new<'a>(
8328                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8329            ) -> Self {
8330                tuple.into()
8331            }
8332            #[inline]
8333            fn tokenize(&self) -> Self::Token<'_> {
8334                (
8335                    <alloy::sol_types::sol_data::Array<
8336                        alloy::sol_types::sol_data::Address,
8337                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
8338                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
8339                        &self.operatorSet,
8340                    ),
8341                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8342                        &self.strategy,
8343                    ),
8344                )
8345            }
8346            #[inline]
8347            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8348                (
8349                    <alloy::sol_types::sol_data::Array<
8350                        IAllocationManagerTypes::Allocation,
8351                    > as alloy_sol_types::SolType>::tokenize(ret),
8352                )
8353            }
8354            #[inline]
8355            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8356                <Self::ReturnTuple<
8357                    '_,
8358                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8359                    .map(|r| {
8360                        let r: getAllocationsReturn = r.into();
8361                        r._0
8362                    })
8363            }
8364            #[inline]
8365            fn abi_decode_returns_validate(
8366                data: &[u8],
8367            ) -> alloy_sol_types::Result<Self::Return> {
8368                <Self::ReturnTuple<
8369                    '_,
8370                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8371                    .map(|r| {
8372                        let r: getAllocationsReturn = r.into();
8373                        r._0
8374                    })
8375            }
8376        }
8377    };
8378    #[derive(serde::Serialize, serde::Deserialize)]
8379    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8380    /**Function with signature `getEncumberedMagnitude(address,address)` and selector `0xf605ce08`.
8381```solidity
8382function getEncumberedMagnitude(address operator, address strategy) external view returns (uint64);
8383```*/
8384    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8385    #[derive(Clone)]
8386    pub struct getEncumberedMagnitudeCall {
8387        #[allow(missing_docs)]
8388        pub operator: alloy::sol_types::private::Address,
8389        #[allow(missing_docs)]
8390        pub strategy: alloy::sol_types::private::Address,
8391    }
8392    #[derive(serde::Serialize, serde::Deserialize)]
8393    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8394    ///Container type for the return parameters of the [`getEncumberedMagnitude(address,address)`](getEncumberedMagnitudeCall) function.
8395    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8396    #[derive(Clone)]
8397    pub struct getEncumberedMagnitudeReturn {
8398        #[allow(missing_docs)]
8399        pub _0: u64,
8400    }
8401    #[allow(
8402        non_camel_case_types,
8403        non_snake_case,
8404        clippy::pub_underscore_fields,
8405        clippy::style
8406    )]
8407    const _: () = {
8408        use alloy::sol_types as alloy_sol_types;
8409        {
8410            #[doc(hidden)]
8411            type UnderlyingSolTuple<'a> = (
8412                alloy::sol_types::sol_data::Address,
8413                alloy::sol_types::sol_data::Address,
8414            );
8415            #[doc(hidden)]
8416            type UnderlyingRustTuple<'a> = (
8417                alloy::sol_types::private::Address,
8418                alloy::sol_types::private::Address,
8419            );
8420            #[cfg(test)]
8421            #[allow(dead_code, unreachable_patterns)]
8422            fn _type_assertion(
8423                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8424            ) {
8425                match _t {
8426                    alloy_sol_types::private::AssertTypeEq::<
8427                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8428                    >(_) => {}
8429                }
8430            }
8431            #[automatically_derived]
8432            #[doc(hidden)]
8433            impl ::core::convert::From<getEncumberedMagnitudeCall>
8434            for UnderlyingRustTuple<'_> {
8435                fn from(value: getEncumberedMagnitudeCall) -> Self {
8436                    (value.operator, value.strategy)
8437                }
8438            }
8439            #[automatically_derived]
8440            #[doc(hidden)]
8441            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8442            for getEncumberedMagnitudeCall {
8443                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8444                    Self {
8445                        operator: tuple.0,
8446                        strategy: tuple.1,
8447                    }
8448                }
8449            }
8450        }
8451        {
8452            #[doc(hidden)]
8453            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
8454            #[doc(hidden)]
8455            type UnderlyingRustTuple<'a> = (u64,);
8456            #[cfg(test)]
8457            #[allow(dead_code, unreachable_patterns)]
8458            fn _type_assertion(
8459                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8460            ) {
8461                match _t {
8462                    alloy_sol_types::private::AssertTypeEq::<
8463                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8464                    >(_) => {}
8465                }
8466            }
8467            #[automatically_derived]
8468            #[doc(hidden)]
8469            impl ::core::convert::From<getEncumberedMagnitudeReturn>
8470            for UnderlyingRustTuple<'_> {
8471                fn from(value: getEncumberedMagnitudeReturn) -> Self {
8472                    (value._0,)
8473                }
8474            }
8475            #[automatically_derived]
8476            #[doc(hidden)]
8477            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8478            for getEncumberedMagnitudeReturn {
8479                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8480                    Self { _0: tuple.0 }
8481                }
8482            }
8483        }
8484        #[automatically_derived]
8485        impl alloy_sol_types::SolCall for getEncumberedMagnitudeCall {
8486            type Parameters<'a> = (
8487                alloy::sol_types::sol_data::Address,
8488                alloy::sol_types::sol_data::Address,
8489            );
8490            type Token<'a> = <Self::Parameters<
8491                'a,
8492            > as alloy_sol_types::SolType>::Token<'a>;
8493            type Return = u64;
8494            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
8495            type ReturnToken<'a> = <Self::ReturnTuple<
8496                'a,
8497            > as alloy_sol_types::SolType>::Token<'a>;
8498            const SIGNATURE: &'static str = "getEncumberedMagnitude(address,address)";
8499            const SELECTOR: [u8; 4] = [246u8, 5u8, 206u8, 8u8];
8500            #[inline]
8501            fn new<'a>(
8502                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8503            ) -> Self {
8504                tuple.into()
8505            }
8506            #[inline]
8507            fn tokenize(&self) -> Self::Token<'_> {
8508                (
8509                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8510                        &self.operator,
8511                    ),
8512                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8513                        &self.strategy,
8514                    ),
8515                )
8516            }
8517            #[inline]
8518            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8519                (
8520                    <alloy::sol_types::sol_data::Uint<
8521                        64,
8522                    > as alloy_sol_types::SolType>::tokenize(ret),
8523                )
8524            }
8525            #[inline]
8526            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8527                <Self::ReturnTuple<
8528                    '_,
8529                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8530                    .map(|r| {
8531                        let r: getEncumberedMagnitudeReturn = r.into();
8532                        r._0
8533                    })
8534            }
8535            #[inline]
8536            fn abi_decode_returns_validate(
8537                data: &[u8],
8538            ) -> alloy_sol_types::Result<Self::Return> {
8539                <Self::ReturnTuple<
8540                    '_,
8541                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8542                    .map(|r| {
8543                        let r: getEncumberedMagnitudeReturn = r.into();
8544                        r._0
8545                    })
8546            }
8547        }
8548    };
8549    #[derive(serde::Serialize, serde::Deserialize)]
8550    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8551    /**Function with signature `getMaxMagnitude(address,address)` and selector `0xa9333ec8`.
8552```solidity
8553function getMaxMagnitude(address operator, address strategy) external view returns (uint64);
8554```*/
8555    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8556    #[derive(Clone)]
8557    pub struct getMaxMagnitudeCall {
8558        #[allow(missing_docs)]
8559        pub operator: alloy::sol_types::private::Address,
8560        #[allow(missing_docs)]
8561        pub strategy: alloy::sol_types::private::Address,
8562    }
8563    #[derive(serde::Serialize, serde::Deserialize)]
8564    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8565    ///Container type for the return parameters of the [`getMaxMagnitude(address,address)`](getMaxMagnitudeCall) function.
8566    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8567    #[derive(Clone)]
8568    pub struct getMaxMagnitudeReturn {
8569        #[allow(missing_docs)]
8570        pub _0: u64,
8571    }
8572    #[allow(
8573        non_camel_case_types,
8574        non_snake_case,
8575        clippy::pub_underscore_fields,
8576        clippy::style
8577    )]
8578    const _: () = {
8579        use alloy::sol_types as alloy_sol_types;
8580        {
8581            #[doc(hidden)]
8582            type UnderlyingSolTuple<'a> = (
8583                alloy::sol_types::sol_data::Address,
8584                alloy::sol_types::sol_data::Address,
8585            );
8586            #[doc(hidden)]
8587            type UnderlyingRustTuple<'a> = (
8588                alloy::sol_types::private::Address,
8589                alloy::sol_types::private::Address,
8590            );
8591            #[cfg(test)]
8592            #[allow(dead_code, unreachable_patterns)]
8593            fn _type_assertion(
8594                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8595            ) {
8596                match _t {
8597                    alloy_sol_types::private::AssertTypeEq::<
8598                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8599                    >(_) => {}
8600                }
8601            }
8602            #[automatically_derived]
8603            #[doc(hidden)]
8604            impl ::core::convert::From<getMaxMagnitudeCall> for UnderlyingRustTuple<'_> {
8605                fn from(value: getMaxMagnitudeCall) -> Self {
8606                    (value.operator, value.strategy)
8607                }
8608            }
8609            #[automatically_derived]
8610            #[doc(hidden)]
8611            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMaxMagnitudeCall {
8612                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8613                    Self {
8614                        operator: tuple.0,
8615                        strategy: tuple.1,
8616                    }
8617                }
8618            }
8619        }
8620        {
8621            #[doc(hidden)]
8622            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
8623            #[doc(hidden)]
8624            type UnderlyingRustTuple<'a> = (u64,);
8625            #[cfg(test)]
8626            #[allow(dead_code, unreachable_patterns)]
8627            fn _type_assertion(
8628                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8629            ) {
8630                match _t {
8631                    alloy_sol_types::private::AssertTypeEq::<
8632                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8633                    >(_) => {}
8634                }
8635            }
8636            #[automatically_derived]
8637            #[doc(hidden)]
8638            impl ::core::convert::From<getMaxMagnitudeReturn>
8639            for UnderlyingRustTuple<'_> {
8640                fn from(value: getMaxMagnitudeReturn) -> Self {
8641                    (value._0,)
8642                }
8643            }
8644            #[automatically_derived]
8645            #[doc(hidden)]
8646            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8647            for getMaxMagnitudeReturn {
8648                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8649                    Self { _0: tuple.0 }
8650                }
8651            }
8652        }
8653        #[automatically_derived]
8654        impl alloy_sol_types::SolCall for getMaxMagnitudeCall {
8655            type Parameters<'a> = (
8656                alloy::sol_types::sol_data::Address,
8657                alloy::sol_types::sol_data::Address,
8658            );
8659            type Token<'a> = <Self::Parameters<
8660                'a,
8661            > as alloy_sol_types::SolType>::Token<'a>;
8662            type Return = u64;
8663            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
8664            type ReturnToken<'a> = <Self::ReturnTuple<
8665                'a,
8666            > as alloy_sol_types::SolType>::Token<'a>;
8667            const SIGNATURE: &'static str = "getMaxMagnitude(address,address)";
8668            const SELECTOR: [u8; 4] = [169u8, 51u8, 62u8, 200u8];
8669            #[inline]
8670            fn new<'a>(
8671                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8672            ) -> Self {
8673                tuple.into()
8674            }
8675            #[inline]
8676            fn tokenize(&self) -> Self::Token<'_> {
8677                (
8678                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8679                        &self.operator,
8680                    ),
8681                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8682                        &self.strategy,
8683                    ),
8684                )
8685            }
8686            #[inline]
8687            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8688                (
8689                    <alloy::sol_types::sol_data::Uint<
8690                        64,
8691                    > as alloy_sol_types::SolType>::tokenize(ret),
8692                )
8693            }
8694            #[inline]
8695            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8696                <Self::ReturnTuple<
8697                    '_,
8698                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8699                    .map(|r| {
8700                        let r: getMaxMagnitudeReturn = r.into();
8701                        r._0
8702                    })
8703            }
8704            #[inline]
8705            fn abi_decode_returns_validate(
8706                data: &[u8],
8707            ) -> alloy_sol_types::Result<Self::Return> {
8708                <Self::ReturnTuple<
8709                    '_,
8710                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8711                    .map(|r| {
8712                        let r: getMaxMagnitudeReturn = r.into();
8713                        r._0
8714                    })
8715            }
8716        }
8717    };
8718    #[derive(serde::Serialize, serde::Deserialize)]
8719    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8720    /**Function with signature `getMaxMagnitudes(address[],address)` and selector `0x4a10ffe5`.
8721```solidity
8722function getMaxMagnitudes(address[] memory operators, address strategy) external view returns (uint64[] memory);
8723```*/
8724    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8725    #[derive(Clone)]
8726    pub struct getMaxMagnitudes_0Call {
8727        #[allow(missing_docs)]
8728        pub operators: alloy::sol_types::private::Vec<
8729            alloy::sol_types::private::Address,
8730        >,
8731        #[allow(missing_docs)]
8732        pub strategy: alloy::sol_types::private::Address,
8733    }
8734    #[derive(serde::Serialize, serde::Deserialize)]
8735    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8736    ///Container type for the return parameters of the [`getMaxMagnitudes(address[],address)`](getMaxMagnitudes_0Call) function.
8737    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8738    #[derive(Clone)]
8739    pub struct getMaxMagnitudes_0Return {
8740        #[allow(missing_docs)]
8741        pub _0: alloy::sol_types::private::Vec<u64>,
8742    }
8743    #[allow(
8744        non_camel_case_types,
8745        non_snake_case,
8746        clippy::pub_underscore_fields,
8747        clippy::style
8748    )]
8749    const _: () = {
8750        use alloy::sol_types as alloy_sol_types;
8751        {
8752            #[doc(hidden)]
8753            type UnderlyingSolTuple<'a> = (
8754                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
8755                alloy::sol_types::sol_data::Address,
8756            );
8757            #[doc(hidden)]
8758            type UnderlyingRustTuple<'a> = (
8759                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8760                alloy::sol_types::private::Address,
8761            );
8762            #[cfg(test)]
8763            #[allow(dead_code, unreachable_patterns)]
8764            fn _type_assertion(
8765                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8766            ) {
8767                match _t {
8768                    alloy_sol_types::private::AssertTypeEq::<
8769                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8770                    >(_) => {}
8771                }
8772            }
8773            #[automatically_derived]
8774            #[doc(hidden)]
8775            impl ::core::convert::From<getMaxMagnitudes_0Call>
8776            for UnderlyingRustTuple<'_> {
8777                fn from(value: getMaxMagnitudes_0Call) -> Self {
8778                    (value.operators, value.strategy)
8779                }
8780            }
8781            #[automatically_derived]
8782            #[doc(hidden)]
8783            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8784            for getMaxMagnitudes_0Call {
8785                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8786                    Self {
8787                        operators: tuple.0,
8788                        strategy: tuple.1,
8789                    }
8790                }
8791            }
8792        }
8793        {
8794            #[doc(hidden)]
8795            type UnderlyingSolTuple<'a> = (
8796                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
8797            );
8798            #[doc(hidden)]
8799            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u64>,);
8800            #[cfg(test)]
8801            #[allow(dead_code, unreachable_patterns)]
8802            fn _type_assertion(
8803                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8804            ) {
8805                match _t {
8806                    alloy_sol_types::private::AssertTypeEq::<
8807                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8808                    >(_) => {}
8809                }
8810            }
8811            #[automatically_derived]
8812            #[doc(hidden)]
8813            impl ::core::convert::From<getMaxMagnitudes_0Return>
8814            for UnderlyingRustTuple<'_> {
8815                fn from(value: getMaxMagnitudes_0Return) -> Self {
8816                    (value._0,)
8817                }
8818            }
8819            #[automatically_derived]
8820            #[doc(hidden)]
8821            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8822            for getMaxMagnitudes_0Return {
8823                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8824                    Self { _0: tuple.0 }
8825                }
8826            }
8827        }
8828        #[automatically_derived]
8829        impl alloy_sol_types::SolCall for getMaxMagnitudes_0Call {
8830            type Parameters<'a> = (
8831                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
8832                alloy::sol_types::sol_data::Address,
8833            );
8834            type Token<'a> = <Self::Parameters<
8835                'a,
8836            > as alloy_sol_types::SolType>::Token<'a>;
8837            type Return = alloy::sol_types::private::Vec<u64>;
8838            type ReturnTuple<'a> = (
8839                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
8840            );
8841            type ReturnToken<'a> = <Self::ReturnTuple<
8842                'a,
8843            > as alloy_sol_types::SolType>::Token<'a>;
8844            const SIGNATURE: &'static str = "getMaxMagnitudes(address[],address)";
8845            const SELECTOR: [u8; 4] = [74u8, 16u8, 255u8, 229u8];
8846            #[inline]
8847            fn new<'a>(
8848                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
8849            ) -> Self {
8850                tuple.into()
8851            }
8852            #[inline]
8853            fn tokenize(&self) -> Self::Token<'_> {
8854                (
8855                    <alloy::sol_types::sol_data::Array<
8856                        alloy::sol_types::sol_data::Address,
8857                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
8858                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
8859                        &self.strategy,
8860                    ),
8861                )
8862            }
8863            #[inline]
8864            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
8865                (
8866                    <alloy::sol_types::sol_data::Array<
8867                        alloy::sol_types::sol_data::Uint<64>,
8868                    > as alloy_sol_types::SolType>::tokenize(ret),
8869                )
8870            }
8871            #[inline]
8872            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
8873                <Self::ReturnTuple<
8874                    '_,
8875                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
8876                    .map(|r| {
8877                        let r: getMaxMagnitudes_0Return = r.into();
8878                        r._0
8879                    })
8880            }
8881            #[inline]
8882            fn abi_decode_returns_validate(
8883                data: &[u8],
8884            ) -> alloy_sol_types::Result<Self::Return> {
8885                <Self::ReturnTuple<
8886                    '_,
8887                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
8888                    .map(|r| {
8889                        let r: getMaxMagnitudes_0Return = r.into();
8890                        r._0
8891                    })
8892            }
8893        }
8894    };
8895    #[derive(serde::Serialize, serde::Deserialize)]
8896    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8897    /**Function with signature `getMaxMagnitudes(address,address[])` and selector `0x547afb87`.
8898```solidity
8899function getMaxMagnitudes(address operator, address[] memory strategies) external view returns (uint64[] memory);
8900```*/
8901    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8902    #[derive(Clone)]
8903    pub struct getMaxMagnitudes_1Call {
8904        #[allow(missing_docs)]
8905        pub operator: alloy::sol_types::private::Address,
8906        #[allow(missing_docs)]
8907        pub strategies: alloy::sol_types::private::Vec<
8908            alloy::sol_types::private::Address,
8909        >,
8910    }
8911    #[derive(serde::Serialize, serde::Deserialize)]
8912    #[derive(Default, Debug, PartialEq, Eq, Hash)]
8913    ///Container type for the return parameters of the [`getMaxMagnitudes(address,address[])`](getMaxMagnitudes_1Call) function.
8914    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
8915    #[derive(Clone)]
8916    pub struct getMaxMagnitudes_1Return {
8917        #[allow(missing_docs)]
8918        pub _0: alloy::sol_types::private::Vec<u64>,
8919    }
8920    #[allow(
8921        non_camel_case_types,
8922        non_snake_case,
8923        clippy::pub_underscore_fields,
8924        clippy::style
8925    )]
8926    const _: () = {
8927        use alloy::sol_types as alloy_sol_types;
8928        {
8929            #[doc(hidden)]
8930            type UnderlyingSolTuple<'a> = (
8931                alloy::sol_types::sol_data::Address,
8932                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
8933            );
8934            #[doc(hidden)]
8935            type UnderlyingRustTuple<'a> = (
8936                alloy::sol_types::private::Address,
8937                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
8938            );
8939            #[cfg(test)]
8940            #[allow(dead_code, unreachable_patterns)]
8941            fn _type_assertion(
8942                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8943            ) {
8944                match _t {
8945                    alloy_sol_types::private::AssertTypeEq::<
8946                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8947                    >(_) => {}
8948                }
8949            }
8950            #[automatically_derived]
8951            #[doc(hidden)]
8952            impl ::core::convert::From<getMaxMagnitudes_1Call>
8953            for UnderlyingRustTuple<'_> {
8954                fn from(value: getMaxMagnitudes_1Call) -> Self {
8955                    (value.operator, value.strategies)
8956                }
8957            }
8958            #[automatically_derived]
8959            #[doc(hidden)]
8960            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8961            for getMaxMagnitudes_1Call {
8962                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
8963                    Self {
8964                        operator: tuple.0,
8965                        strategies: tuple.1,
8966                    }
8967                }
8968            }
8969        }
8970        {
8971            #[doc(hidden)]
8972            type UnderlyingSolTuple<'a> = (
8973                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
8974            );
8975            #[doc(hidden)]
8976            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u64>,);
8977            #[cfg(test)]
8978            #[allow(dead_code, unreachable_patterns)]
8979            fn _type_assertion(
8980                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
8981            ) {
8982                match _t {
8983                    alloy_sol_types::private::AssertTypeEq::<
8984                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
8985                    >(_) => {}
8986                }
8987            }
8988            #[automatically_derived]
8989            #[doc(hidden)]
8990            impl ::core::convert::From<getMaxMagnitudes_1Return>
8991            for UnderlyingRustTuple<'_> {
8992                fn from(value: getMaxMagnitudes_1Return) -> Self {
8993                    (value._0,)
8994                }
8995            }
8996            #[automatically_derived]
8997            #[doc(hidden)]
8998            impl ::core::convert::From<UnderlyingRustTuple<'_>>
8999            for getMaxMagnitudes_1Return {
9000                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9001                    Self { _0: tuple.0 }
9002                }
9003            }
9004        }
9005        #[automatically_derived]
9006        impl alloy_sol_types::SolCall for getMaxMagnitudes_1Call {
9007            type Parameters<'a> = (
9008                alloy::sol_types::sol_data::Address,
9009                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9010            );
9011            type Token<'a> = <Self::Parameters<
9012                'a,
9013            > as alloy_sol_types::SolType>::Token<'a>;
9014            type Return = alloy::sol_types::private::Vec<u64>;
9015            type ReturnTuple<'a> = (
9016                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
9017            );
9018            type ReturnToken<'a> = <Self::ReturnTuple<
9019                'a,
9020            > as alloy_sol_types::SolType>::Token<'a>;
9021            const SIGNATURE: &'static str = "getMaxMagnitudes(address,address[])";
9022            const SELECTOR: [u8; 4] = [84u8, 122u8, 251u8, 135u8];
9023            #[inline]
9024            fn new<'a>(
9025                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9026            ) -> Self {
9027                tuple.into()
9028            }
9029            #[inline]
9030            fn tokenize(&self) -> Self::Token<'_> {
9031                (
9032                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9033                        &self.operator,
9034                    ),
9035                    <alloy::sol_types::sol_data::Array<
9036                        alloy::sol_types::sol_data::Address,
9037                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
9038                )
9039            }
9040            #[inline]
9041            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9042                (
9043                    <alloy::sol_types::sol_data::Array<
9044                        alloy::sol_types::sol_data::Uint<64>,
9045                    > as alloy_sol_types::SolType>::tokenize(ret),
9046                )
9047            }
9048            #[inline]
9049            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9050                <Self::ReturnTuple<
9051                    '_,
9052                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9053                    .map(|r| {
9054                        let r: getMaxMagnitudes_1Return = r.into();
9055                        r._0
9056                    })
9057            }
9058            #[inline]
9059            fn abi_decode_returns_validate(
9060                data: &[u8],
9061            ) -> alloy_sol_types::Result<Self::Return> {
9062                <Self::ReturnTuple<
9063                    '_,
9064                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9065                    .map(|r| {
9066                        let r: getMaxMagnitudes_1Return = r.into();
9067                        r._0
9068                    })
9069            }
9070        }
9071    };
9072    #[derive(serde::Serialize, serde::Deserialize)]
9073    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9074    /**Function with signature `getMaxMagnitudesAtBlock(address,address[],uint32)` and selector `0x94d7d00c`.
9075```solidity
9076function getMaxMagnitudesAtBlock(address operator, address[] memory strategies, uint32 blockNumber) external view returns (uint64[] memory);
9077```*/
9078    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9079    #[derive(Clone)]
9080    pub struct getMaxMagnitudesAtBlockCall {
9081        #[allow(missing_docs)]
9082        pub operator: alloy::sol_types::private::Address,
9083        #[allow(missing_docs)]
9084        pub strategies: alloy::sol_types::private::Vec<
9085            alloy::sol_types::private::Address,
9086        >,
9087        #[allow(missing_docs)]
9088        pub blockNumber: u32,
9089    }
9090    #[derive(serde::Serialize, serde::Deserialize)]
9091    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9092    ///Container type for the return parameters of the [`getMaxMagnitudesAtBlock(address,address[],uint32)`](getMaxMagnitudesAtBlockCall) function.
9093    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9094    #[derive(Clone)]
9095    pub struct getMaxMagnitudesAtBlockReturn {
9096        #[allow(missing_docs)]
9097        pub _0: alloy::sol_types::private::Vec<u64>,
9098    }
9099    #[allow(
9100        non_camel_case_types,
9101        non_snake_case,
9102        clippy::pub_underscore_fields,
9103        clippy::style
9104    )]
9105    const _: () = {
9106        use alloy::sol_types as alloy_sol_types;
9107        {
9108            #[doc(hidden)]
9109            type UnderlyingSolTuple<'a> = (
9110                alloy::sol_types::sol_data::Address,
9111                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9112                alloy::sol_types::sol_data::Uint<32>,
9113            );
9114            #[doc(hidden)]
9115            type UnderlyingRustTuple<'a> = (
9116                alloy::sol_types::private::Address,
9117                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9118                u32,
9119            );
9120            #[cfg(test)]
9121            #[allow(dead_code, unreachable_patterns)]
9122            fn _type_assertion(
9123                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9124            ) {
9125                match _t {
9126                    alloy_sol_types::private::AssertTypeEq::<
9127                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9128                    >(_) => {}
9129                }
9130            }
9131            #[automatically_derived]
9132            #[doc(hidden)]
9133            impl ::core::convert::From<getMaxMagnitudesAtBlockCall>
9134            for UnderlyingRustTuple<'_> {
9135                fn from(value: getMaxMagnitudesAtBlockCall) -> Self {
9136                    (value.operator, value.strategies, value.blockNumber)
9137                }
9138            }
9139            #[automatically_derived]
9140            #[doc(hidden)]
9141            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9142            for getMaxMagnitudesAtBlockCall {
9143                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9144                    Self {
9145                        operator: tuple.0,
9146                        strategies: tuple.1,
9147                        blockNumber: tuple.2,
9148                    }
9149                }
9150            }
9151        }
9152        {
9153            #[doc(hidden)]
9154            type UnderlyingSolTuple<'a> = (
9155                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
9156            );
9157            #[doc(hidden)]
9158            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Vec<u64>,);
9159            #[cfg(test)]
9160            #[allow(dead_code, unreachable_patterns)]
9161            fn _type_assertion(
9162                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9163            ) {
9164                match _t {
9165                    alloy_sol_types::private::AssertTypeEq::<
9166                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9167                    >(_) => {}
9168                }
9169            }
9170            #[automatically_derived]
9171            #[doc(hidden)]
9172            impl ::core::convert::From<getMaxMagnitudesAtBlockReturn>
9173            for UnderlyingRustTuple<'_> {
9174                fn from(value: getMaxMagnitudesAtBlockReturn) -> Self {
9175                    (value._0,)
9176                }
9177            }
9178            #[automatically_derived]
9179            #[doc(hidden)]
9180            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9181            for getMaxMagnitudesAtBlockReturn {
9182                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9183                    Self { _0: tuple.0 }
9184                }
9185            }
9186        }
9187        #[automatically_derived]
9188        impl alloy_sol_types::SolCall for getMaxMagnitudesAtBlockCall {
9189            type Parameters<'a> = (
9190                alloy::sol_types::sol_data::Address,
9191                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9192                alloy::sol_types::sol_data::Uint<32>,
9193            );
9194            type Token<'a> = <Self::Parameters<
9195                'a,
9196            > as alloy_sol_types::SolType>::Token<'a>;
9197            type Return = alloy::sol_types::private::Vec<u64>;
9198            type ReturnTuple<'a> = (
9199                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Uint<64>>,
9200            );
9201            type ReturnToken<'a> = <Self::ReturnTuple<
9202                'a,
9203            > as alloy_sol_types::SolType>::Token<'a>;
9204            const SIGNATURE: &'static str = "getMaxMagnitudesAtBlock(address,address[],uint32)";
9205            const SELECTOR: [u8; 4] = [148u8, 215u8, 208u8, 12u8];
9206            #[inline]
9207            fn new<'a>(
9208                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9209            ) -> Self {
9210                tuple.into()
9211            }
9212            #[inline]
9213            fn tokenize(&self) -> Self::Token<'_> {
9214                (
9215                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9216                        &self.operator,
9217                    ),
9218                    <alloy::sol_types::sol_data::Array<
9219                        alloy::sol_types::sol_data::Address,
9220                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
9221                    <alloy::sol_types::sol_data::Uint<
9222                        32,
9223                    > as alloy_sol_types::SolType>::tokenize(&self.blockNumber),
9224                )
9225            }
9226            #[inline]
9227            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9228                (
9229                    <alloy::sol_types::sol_data::Array<
9230                        alloy::sol_types::sol_data::Uint<64>,
9231                    > as alloy_sol_types::SolType>::tokenize(ret),
9232                )
9233            }
9234            #[inline]
9235            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9236                <Self::ReturnTuple<
9237                    '_,
9238                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9239                    .map(|r| {
9240                        let r: getMaxMagnitudesAtBlockReturn = r.into();
9241                        r._0
9242                    })
9243            }
9244            #[inline]
9245            fn abi_decode_returns_validate(
9246                data: &[u8],
9247            ) -> alloy_sol_types::Result<Self::Return> {
9248                <Self::ReturnTuple<
9249                    '_,
9250                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9251                    .map(|r| {
9252                        let r: getMaxMagnitudesAtBlockReturn = r.into();
9253                        r._0
9254                    })
9255            }
9256        }
9257    };
9258    #[derive(serde::Serialize, serde::Deserialize)]
9259    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9260    /**Function with signature `getMemberCount((address,uint32))` and selector `0xb2447af7`.
9261```solidity
9262function getMemberCount(OperatorSet memory operatorSet) external view returns (uint256);
9263```*/
9264    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9265    #[derive(Clone)]
9266    pub struct getMemberCountCall {
9267        #[allow(missing_docs)]
9268        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
9269    }
9270    #[derive(serde::Serialize, serde::Deserialize)]
9271    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9272    ///Container type for the return parameters of the [`getMemberCount((address,uint32))`](getMemberCountCall) function.
9273    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9274    #[derive(Clone)]
9275    pub struct getMemberCountReturn {
9276        #[allow(missing_docs)]
9277        pub _0: alloy::sol_types::private::primitives::aliases::U256,
9278    }
9279    #[allow(
9280        non_camel_case_types,
9281        non_snake_case,
9282        clippy::pub_underscore_fields,
9283        clippy::style
9284    )]
9285    const _: () = {
9286        use alloy::sol_types as alloy_sol_types;
9287        {
9288            #[doc(hidden)]
9289            type UnderlyingSolTuple<'a> = (OperatorSet,);
9290            #[doc(hidden)]
9291            type UnderlyingRustTuple<'a> = (
9292                <OperatorSet as alloy::sol_types::SolType>::RustType,
9293            );
9294            #[cfg(test)]
9295            #[allow(dead_code, unreachable_patterns)]
9296            fn _type_assertion(
9297                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9298            ) {
9299                match _t {
9300                    alloy_sol_types::private::AssertTypeEq::<
9301                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9302                    >(_) => {}
9303                }
9304            }
9305            #[automatically_derived]
9306            #[doc(hidden)]
9307            impl ::core::convert::From<getMemberCountCall> for UnderlyingRustTuple<'_> {
9308                fn from(value: getMemberCountCall) -> Self {
9309                    (value.operatorSet,)
9310                }
9311            }
9312            #[automatically_derived]
9313            #[doc(hidden)]
9314            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMemberCountCall {
9315                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9316                    Self { operatorSet: tuple.0 }
9317                }
9318            }
9319        }
9320        {
9321            #[doc(hidden)]
9322            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9323            #[doc(hidden)]
9324            type UnderlyingRustTuple<'a> = (
9325                alloy::sol_types::private::primitives::aliases::U256,
9326            );
9327            #[cfg(test)]
9328            #[allow(dead_code, unreachable_patterns)]
9329            fn _type_assertion(
9330                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9331            ) {
9332                match _t {
9333                    alloy_sol_types::private::AssertTypeEq::<
9334                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9335                    >(_) => {}
9336                }
9337            }
9338            #[automatically_derived]
9339            #[doc(hidden)]
9340            impl ::core::convert::From<getMemberCountReturn>
9341            for UnderlyingRustTuple<'_> {
9342                fn from(value: getMemberCountReturn) -> Self {
9343                    (value._0,)
9344                }
9345            }
9346            #[automatically_derived]
9347            #[doc(hidden)]
9348            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9349            for getMemberCountReturn {
9350                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9351                    Self { _0: tuple.0 }
9352                }
9353            }
9354        }
9355        #[automatically_derived]
9356        impl alloy_sol_types::SolCall for getMemberCountCall {
9357            type Parameters<'a> = (OperatorSet,);
9358            type Token<'a> = <Self::Parameters<
9359                'a,
9360            > as alloy_sol_types::SolType>::Token<'a>;
9361            type Return = alloy::sol_types::private::primitives::aliases::U256;
9362            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9363            type ReturnToken<'a> = <Self::ReturnTuple<
9364                'a,
9365            > as alloy_sol_types::SolType>::Token<'a>;
9366            const SIGNATURE: &'static str = "getMemberCount((address,uint32))";
9367            const SELECTOR: [u8; 4] = [178u8, 68u8, 122u8, 247u8];
9368            #[inline]
9369            fn new<'a>(
9370                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9371            ) -> Self {
9372                tuple.into()
9373            }
9374            #[inline]
9375            fn tokenize(&self) -> Self::Token<'_> {
9376                (<OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),)
9377            }
9378            #[inline]
9379            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9380                (
9381                    <alloy::sol_types::sol_data::Uint<
9382                        256,
9383                    > as alloy_sol_types::SolType>::tokenize(ret),
9384                )
9385            }
9386            #[inline]
9387            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9388                <Self::ReturnTuple<
9389                    '_,
9390                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9391                    .map(|r| {
9392                        let r: getMemberCountReturn = r.into();
9393                        r._0
9394                    })
9395            }
9396            #[inline]
9397            fn abi_decode_returns_validate(
9398                data: &[u8],
9399            ) -> alloy_sol_types::Result<Self::Return> {
9400                <Self::ReturnTuple<
9401                    '_,
9402                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9403                    .map(|r| {
9404                        let r: getMemberCountReturn = r.into();
9405                        r._0
9406                    })
9407            }
9408        }
9409    };
9410    #[derive(serde::Serialize, serde::Deserialize)]
9411    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9412    /**Function with signature `getMembers((address,uint32))` and selector `0x6e875dba`.
9413```solidity
9414function getMembers(OperatorSet memory operatorSet) external view returns (address[] memory operators);
9415```*/
9416    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9417    #[derive(Clone)]
9418    pub struct getMembersCall {
9419        #[allow(missing_docs)]
9420        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
9421    }
9422    #[derive(serde::Serialize, serde::Deserialize)]
9423    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9424    ///Container type for the return parameters of the [`getMembers((address,uint32))`](getMembersCall) function.
9425    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9426    #[derive(Clone)]
9427    pub struct getMembersReturn {
9428        #[allow(missing_docs)]
9429        pub operators: alloy::sol_types::private::Vec<
9430            alloy::sol_types::private::Address,
9431        >,
9432    }
9433    #[allow(
9434        non_camel_case_types,
9435        non_snake_case,
9436        clippy::pub_underscore_fields,
9437        clippy::style
9438    )]
9439    const _: () = {
9440        use alloy::sol_types as alloy_sol_types;
9441        {
9442            #[doc(hidden)]
9443            type UnderlyingSolTuple<'a> = (OperatorSet,);
9444            #[doc(hidden)]
9445            type UnderlyingRustTuple<'a> = (
9446                <OperatorSet as alloy::sol_types::SolType>::RustType,
9447            );
9448            #[cfg(test)]
9449            #[allow(dead_code, unreachable_patterns)]
9450            fn _type_assertion(
9451                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9452            ) {
9453                match _t {
9454                    alloy_sol_types::private::AssertTypeEq::<
9455                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9456                    >(_) => {}
9457                }
9458            }
9459            #[automatically_derived]
9460            #[doc(hidden)]
9461            impl ::core::convert::From<getMembersCall> for UnderlyingRustTuple<'_> {
9462                fn from(value: getMembersCall) -> Self {
9463                    (value.operatorSet,)
9464                }
9465            }
9466            #[automatically_derived]
9467            #[doc(hidden)]
9468            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMembersCall {
9469                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9470                    Self { operatorSet: tuple.0 }
9471                }
9472            }
9473        }
9474        {
9475            #[doc(hidden)]
9476            type UnderlyingSolTuple<'a> = (
9477                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9478            );
9479            #[doc(hidden)]
9480            type UnderlyingRustTuple<'a> = (
9481                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9482            );
9483            #[cfg(test)]
9484            #[allow(dead_code, unreachable_patterns)]
9485            fn _type_assertion(
9486                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9487            ) {
9488                match _t {
9489                    alloy_sol_types::private::AssertTypeEq::<
9490                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9491                    >(_) => {}
9492                }
9493            }
9494            #[automatically_derived]
9495            #[doc(hidden)]
9496            impl ::core::convert::From<getMembersReturn> for UnderlyingRustTuple<'_> {
9497                fn from(value: getMembersReturn) -> Self {
9498                    (value.operators,)
9499                }
9500            }
9501            #[automatically_derived]
9502            #[doc(hidden)]
9503            impl ::core::convert::From<UnderlyingRustTuple<'_>> for getMembersReturn {
9504                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9505                    Self { operators: tuple.0 }
9506                }
9507            }
9508        }
9509        #[automatically_derived]
9510        impl alloy_sol_types::SolCall for getMembersCall {
9511            type Parameters<'a> = (OperatorSet,);
9512            type Token<'a> = <Self::Parameters<
9513                'a,
9514            > as alloy_sol_types::SolType>::Token<'a>;
9515            type Return = alloy::sol_types::private::Vec<
9516                alloy::sol_types::private::Address,
9517            >;
9518            type ReturnTuple<'a> = (
9519                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9520            );
9521            type ReturnToken<'a> = <Self::ReturnTuple<
9522                'a,
9523            > as alloy_sol_types::SolType>::Token<'a>;
9524            const SIGNATURE: &'static str = "getMembers((address,uint32))";
9525            const SELECTOR: [u8; 4] = [110u8, 135u8, 93u8, 186u8];
9526            #[inline]
9527            fn new<'a>(
9528                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9529            ) -> Self {
9530                tuple.into()
9531            }
9532            #[inline]
9533            fn tokenize(&self) -> Self::Token<'_> {
9534                (<OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),)
9535            }
9536            #[inline]
9537            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9538                (
9539                    <alloy::sol_types::sol_data::Array<
9540                        alloy::sol_types::sol_data::Address,
9541                    > as alloy_sol_types::SolType>::tokenize(ret),
9542                )
9543            }
9544            #[inline]
9545            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9546                <Self::ReturnTuple<
9547                    '_,
9548                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9549                    .map(|r| {
9550                        let r: getMembersReturn = r.into();
9551                        r.operators
9552                    })
9553            }
9554            #[inline]
9555            fn abi_decode_returns_validate(
9556                data: &[u8],
9557            ) -> alloy_sol_types::Result<Self::Return> {
9558                <Self::ReturnTuple<
9559                    '_,
9560                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9561                    .map(|r| {
9562                        let r: getMembersReturn = r.into();
9563                        r.operators
9564                    })
9565            }
9566        }
9567    };
9568    #[derive(serde::Serialize, serde::Deserialize)]
9569    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9570    /**Function with signature `getMinimumSlashableStake((address,uint32),address[],address[],uint32)` and selector `0x2bab2c4a`.
9571```solidity
9572function getMinimumSlashableStake(OperatorSet memory operatorSet, address[] memory operators, address[] memory strategies, uint32 futureBlock) external view returns (uint256[][] memory slashableStake);
9573```*/
9574    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9575    #[derive(Clone)]
9576    pub struct getMinimumSlashableStakeCall {
9577        #[allow(missing_docs)]
9578        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
9579        #[allow(missing_docs)]
9580        pub operators: alloy::sol_types::private::Vec<
9581            alloy::sol_types::private::Address,
9582        >,
9583        #[allow(missing_docs)]
9584        pub strategies: alloy::sol_types::private::Vec<
9585            alloy::sol_types::private::Address,
9586        >,
9587        #[allow(missing_docs)]
9588        pub futureBlock: u32,
9589    }
9590    #[derive(serde::Serialize, serde::Deserialize)]
9591    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9592    ///Container type for the return parameters of the [`getMinimumSlashableStake((address,uint32),address[],address[],uint32)`](getMinimumSlashableStakeCall) function.
9593    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9594    #[derive(Clone)]
9595    pub struct getMinimumSlashableStakeReturn {
9596        #[allow(missing_docs)]
9597        pub slashableStake: alloy::sol_types::private::Vec<
9598            alloy::sol_types::private::Vec<
9599                alloy::sol_types::private::primitives::aliases::U256,
9600            >,
9601        >,
9602    }
9603    #[allow(
9604        non_camel_case_types,
9605        non_snake_case,
9606        clippy::pub_underscore_fields,
9607        clippy::style
9608    )]
9609    const _: () = {
9610        use alloy::sol_types as alloy_sol_types;
9611        {
9612            #[doc(hidden)]
9613            type UnderlyingSolTuple<'a> = (
9614                OperatorSet,
9615                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9616                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9617                alloy::sol_types::sol_data::Uint<32>,
9618            );
9619            #[doc(hidden)]
9620            type UnderlyingRustTuple<'a> = (
9621                <OperatorSet as alloy::sol_types::SolType>::RustType,
9622                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9623                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
9624                u32,
9625            );
9626            #[cfg(test)]
9627            #[allow(dead_code, unreachable_patterns)]
9628            fn _type_assertion(
9629                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9630            ) {
9631                match _t {
9632                    alloy_sol_types::private::AssertTypeEq::<
9633                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9634                    >(_) => {}
9635                }
9636            }
9637            #[automatically_derived]
9638            #[doc(hidden)]
9639            impl ::core::convert::From<getMinimumSlashableStakeCall>
9640            for UnderlyingRustTuple<'_> {
9641                fn from(value: getMinimumSlashableStakeCall) -> Self {
9642                    (
9643                        value.operatorSet,
9644                        value.operators,
9645                        value.strategies,
9646                        value.futureBlock,
9647                    )
9648                }
9649            }
9650            #[automatically_derived]
9651            #[doc(hidden)]
9652            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9653            for getMinimumSlashableStakeCall {
9654                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9655                    Self {
9656                        operatorSet: tuple.0,
9657                        operators: tuple.1,
9658                        strategies: tuple.2,
9659                        futureBlock: tuple.3,
9660                    }
9661                }
9662            }
9663        }
9664        {
9665            #[doc(hidden)]
9666            type UnderlyingSolTuple<'a> = (
9667                alloy::sol_types::sol_data::Array<
9668                    alloy::sol_types::sol_data::Array<
9669                        alloy::sol_types::sol_data::Uint<256>,
9670                    >,
9671                >,
9672            );
9673            #[doc(hidden)]
9674            type UnderlyingRustTuple<'a> = (
9675                alloy::sol_types::private::Vec<
9676                    alloy::sol_types::private::Vec<
9677                        alloy::sol_types::private::primitives::aliases::U256,
9678                    >,
9679                >,
9680            );
9681            #[cfg(test)]
9682            #[allow(dead_code, unreachable_patterns)]
9683            fn _type_assertion(
9684                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9685            ) {
9686                match _t {
9687                    alloy_sol_types::private::AssertTypeEq::<
9688                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9689                    >(_) => {}
9690                }
9691            }
9692            #[automatically_derived]
9693            #[doc(hidden)]
9694            impl ::core::convert::From<getMinimumSlashableStakeReturn>
9695            for UnderlyingRustTuple<'_> {
9696                fn from(value: getMinimumSlashableStakeReturn) -> Self {
9697                    (value.slashableStake,)
9698                }
9699            }
9700            #[automatically_derived]
9701            #[doc(hidden)]
9702            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9703            for getMinimumSlashableStakeReturn {
9704                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9705                    Self { slashableStake: tuple.0 }
9706                }
9707            }
9708        }
9709        #[automatically_derived]
9710        impl alloy_sol_types::SolCall for getMinimumSlashableStakeCall {
9711            type Parameters<'a> = (
9712                OperatorSet,
9713                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9714                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
9715                alloy::sol_types::sol_data::Uint<32>,
9716            );
9717            type Token<'a> = <Self::Parameters<
9718                'a,
9719            > as alloy_sol_types::SolType>::Token<'a>;
9720            type Return = alloy::sol_types::private::Vec<
9721                alloy::sol_types::private::Vec<
9722                    alloy::sol_types::private::primitives::aliases::U256,
9723                >,
9724            >;
9725            type ReturnTuple<'a> = (
9726                alloy::sol_types::sol_data::Array<
9727                    alloy::sol_types::sol_data::Array<
9728                        alloy::sol_types::sol_data::Uint<256>,
9729                    >,
9730                >,
9731            );
9732            type ReturnToken<'a> = <Self::ReturnTuple<
9733                'a,
9734            > as alloy_sol_types::SolType>::Token<'a>;
9735            const SIGNATURE: &'static str = "getMinimumSlashableStake((address,uint32),address[],address[],uint32)";
9736            const SELECTOR: [u8; 4] = [43u8, 171u8, 44u8, 74u8];
9737            #[inline]
9738            fn new<'a>(
9739                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9740            ) -> Self {
9741                tuple.into()
9742            }
9743            #[inline]
9744            fn tokenize(&self) -> Self::Token<'_> {
9745                (
9746                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
9747                        &self.operatorSet,
9748                    ),
9749                    <alloy::sol_types::sol_data::Array<
9750                        alloy::sol_types::sol_data::Address,
9751                    > as alloy_sol_types::SolType>::tokenize(&self.operators),
9752                    <alloy::sol_types::sol_data::Array<
9753                        alloy::sol_types::sol_data::Address,
9754                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
9755                    <alloy::sol_types::sol_data::Uint<
9756                        32,
9757                    > as alloy_sol_types::SolType>::tokenize(&self.futureBlock),
9758                )
9759            }
9760            #[inline]
9761            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9762                (
9763                    <alloy::sol_types::sol_data::Array<
9764                        alloy::sol_types::sol_data::Array<
9765                            alloy::sol_types::sol_data::Uint<256>,
9766                        >,
9767                    > as alloy_sol_types::SolType>::tokenize(ret),
9768                )
9769            }
9770            #[inline]
9771            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9772                <Self::ReturnTuple<
9773                    '_,
9774                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9775                    .map(|r| {
9776                        let r: getMinimumSlashableStakeReturn = r.into();
9777                        r.slashableStake
9778                    })
9779            }
9780            #[inline]
9781            fn abi_decode_returns_validate(
9782                data: &[u8],
9783            ) -> alloy_sol_types::Result<Self::Return> {
9784                <Self::ReturnTuple<
9785                    '_,
9786                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9787                    .map(|r| {
9788                        let r: getMinimumSlashableStakeReturn = r.into();
9789                        r.slashableStake
9790                    })
9791            }
9792        }
9793    };
9794    #[derive(serde::Serialize, serde::Deserialize)]
9795    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9796    /**Function with signature `getOperatorSetCount(address)` and selector `0xba1a84e5`.
9797```solidity
9798function getOperatorSetCount(address avs) external view returns (uint256);
9799```*/
9800    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9801    #[derive(Clone)]
9802    pub struct getOperatorSetCountCall {
9803        #[allow(missing_docs)]
9804        pub avs: alloy::sol_types::private::Address,
9805    }
9806    #[derive(serde::Serialize, serde::Deserialize)]
9807    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9808    ///Container type for the return parameters of the [`getOperatorSetCount(address)`](getOperatorSetCountCall) function.
9809    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9810    #[derive(Clone)]
9811    pub struct getOperatorSetCountReturn {
9812        #[allow(missing_docs)]
9813        pub _0: alloy::sol_types::private::primitives::aliases::U256,
9814    }
9815    #[allow(
9816        non_camel_case_types,
9817        non_snake_case,
9818        clippy::pub_underscore_fields,
9819        clippy::style
9820    )]
9821    const _: () = {
9822        use alloy::sol_types as alloy_sol_types;
9823        {
9824            #[doc(hidden)]
9825            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9826            #[doc(hidden)]
9827            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9828            #[cfg(test)]
9829            #[allow(dead_code, unreachable_patterns)]
9830            fn _type_assertion(
9831                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9832            ) {
9833                match _t {
9834                    alloy_sol_types::private::AssertTypeEq::<
9835                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9836                    >(_) => {}
9837                }
9838            }
9839            #[automatically_derived]
9840            #[doc(hidden)]
9841            impl ::core::convert::From<getOperatorSetCountCall>
9842            for UnderlyingRustTuple<'_> {
9843                fn from(value: getOperatorSetCountCall) -> Self {
9844                    (value.avs,)
9845                }
9846            }
9847            #[automatically_derived]
9848            #[doc(hidden)]
9849            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9850            for getOperatorSetCountCall {
9851                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9852                    Self { avs: tuple.0 }
9853                }
9854            }
9855        }
9856        {
9857            #[doc(hidden)]
9858            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9859            #[doc(hidden)]
9860            type UnderlyingRustTuple<'a> = (
9861                alloy::sol_types::private::primitives::aliases::U256,
9862            );
9863            #[cfg(test)]
9864            #[allow(dead_code, unreachable_patterns)]
9865            fn _type_assertion(
9866                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9867            ) {
9868                match _t {
9869                    alloy_sol_types::private::AssertTypeEq::<
9870                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9871                    >(_) => {}
9872                }
9873            }
9874            #[automatically_derived]
9875            #[doc(hidden)]
9876            impl ::core::convert::From<getOperatorSetCountReturn>
9877            for UnderlyingRustTuple<'_> {
9878                fn from(value: getOperatorSetCountReturn) -> Self {
9879                    (value._0,)
9880                }
9881            }
9882            #[automatically_derived]
9883            #[doc(hidden)]
9884            impl ::core::convert::From<UnderlyingRustTuple<'_>>
9885            for getOperatorSetCountReturn {
9886                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
9887                    Self { _0: tuple.0 }
9888                }
9889            }
9890        }
9891        #[automatically_derived]
9892        impl alloy_sol_types::SolCall for getOperatorSetCountCall {
9893            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
9894            type Token<'a> = <Self::Parameters<
9895                'a,
9896            > as alloy_sol_types::SolType>::Token<'a>;
9897            type Return = alloy::sol_types::private::primitives::aliases::U256;
9898            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
9899            type ReturnToken<'a> = <Self::ReturnTuple<
9900                'a,
9901            > as alloy_sol_types::SolType>::Token<'a>;
9902            const SIGNATURE: &'static str = "getOperatorSetCount(address)";
9903            const SELECTOR: [u8; 4] = [186u8, 26u8, 132u8, 229u8];
9904            #[inline]
9905            fn new<'a>(
9906                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
9907            ) -> Self {
9908                tuple.into()
9909            }
9910            #[inline]
9911            fn tokenize(&self) -> Self::Token<'_> {
9912                (
9913                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
9914                        &self.avs,
9915                    ),
9916                )
9917            }
9918            #[inline]
9919            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
9920                (
9921                    <alloy::sol_types::sol_data::Uint<
9922                        256,
9923                    > as alloy_sol_types::SolType>::tokenize(ret),
9924                )
9925            }
9926            #[inline]
9927            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
9928                <Self::ReturnTuple<
9929                    '_,
9930                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
9931                    .map(|r| {
9932                        let r: getOperatorSetCountReturn = r.into();
9933                        r._0
9934                    })
9935            }
9936            #[inline]
9937            fn abi_decode_returns_validate(
9938                data: &[u8],
9939            ) -> alloy_sol_types::Result<Self::Return> {
9940                <Self::ReturnTuple<
9941                    '_,
9942                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
9943                    .map(|r| {
9944                        let r: getOperatorSetCountReturn = r.into();
9945                        r._0
9946                    })
9947            }
9948        }
9949    };
9950    #[derive(serde::Serialize, serde::Deserialize)]
9951    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9952    /**Function with signature `getRegisteredSets(address)` and selector `0x79ae50cd`.
9953```solidity
9954function getRegisteredSets(address operator) external view returns (OperatorSet[] memory operatorSets);
9955```*/
9956    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9957    #[derive(Clone)]
9958    pub struct getRegisteredSetsCall {
9959        #[allow(missing_docs)]
9960        pub operator: alloy::sol_types::private::Address,
9961    }
9962    #[derive(serde::Serialize, serde::Deserialize)]
9963    #[derive(Default, Debug, PartialEq, Eq, Hash)]
9964    ///Container type for the return parameters of the [`getRegisteredSets(address)`](getRegisteredSetsCall) function.
9965    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
9966    #[derive(Clone)]
9967    pub struct getRegisteredSetsReturn {
9968        #[allow(missing_docs)]
9969        pub operatorSets: alloy::sol_types::private::Vec<
9970            <OperatorSet as alloy::sol_types::SolType>::RustType,
9971        >,
9972    }
9973    #[allow(
9974        non_camel_case_types,
9975        non_snake_case,
9976        clippy::pub_underscore_fields,
9977        clippy::style
9978    )]
9979    const _: () = {
9980        use alloy::sol_types as alloy_sol_types;
9981        {
9982            #[doc(hidden)]
9983            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
9984            #[doc(hidden)]
9985            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
9986            #[cfg(test)]
9987            #[allow(dead_code, unreachable_patterns)]
9988            fn _type_assertion(
9989                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
9990            ) {
9991                match _t {
9992                    alloy_sol_types::private::AssertTypeEq::<
9993                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
9994                    >(_) => {}
9995                }
9996            }
9997            #[automatically_derived]
9998            #[doc(hidden)]
9999            impl ::core::convert::From<getRegisteredSetsCall>
10000            for UnderlyingRustTuple<'_> {
10001                fn from(value: getRegisteredSetsCall) -> Self {
10002                    (value.operator,)
10003                }
10004            }
10005            #[automatically_derived]
10006            #[doc(hidden)]
10007            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10008            for getRegisteredSetsCall {
10009                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10010                    Self { operator: tuple.0 }
10011                }
10012            }
10013        }
10014        {
10015            #[doc(hidden)]
10016            type UnderlyingSolTuple<'a> = (
10017                alloy::sol_types::sol_data::Array<OperatorSet>,
10018            );
10019            #[doc(hidden)]
10020            type UnderlyingRustTuple<'a> = (
10021                alloy::sol_types::private::Vec<
10022                    <OperatorSet as alloy::sol_types::SolType>::RustType,
10023                >,
10024            );
10025            #[cfg(test)]
10026            #[allow(dead_code, unreachable_patterns)]
10027            fn _type_assertion(
10028                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10029            ) {
10030                match _t {
10031                    alloy_sol_types::private::AssertTypeEq::<
10032                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10033                    >(_) => {}
10034                }
10035            }
10036            #[automatically_derived]
10037            #[doc(hidden)]
10038            impl ::core::convert::From<getRegisteredSetsReturn>
10039            for UnderlyingRustTuple<'_> {
10040                fn from(value: getRegisteredSetsReturn) -> Self {
10041                    (value.operatorSets,)
10042                }
10043            }
10044            #[automatically_derived]
10045            #[doc(hidden)]
10046            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10047            for getRegisteredSetsReturn {
10048                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10049                    Self { operatorSets: tuple.0 }
10050                }
10051            }
10052        }
10053        #[automatically_derived]
10054        impl alloy_sol_types::SolCall for getRegisteredSetsCall {
10055            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
10056            type Token<'a> = <Self::Parameters<
10057                'a,
10058            > as alloy_sol_types::SolType>::Token<'a>;
10059            type Return = alloy::sol_types::private::Vec<
10060                <OperatorSet as alloy::sol_types::SolType>::RustType,
10061            >;
10062            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Array<OperatorSet>,);
10063            type ReturnToken<'a> = <Self::ReturnTuple<
10064                'a,
10065            > as alloy_sol_types::SolType>::Token<'a>;
10066            const SIGNATURE: &'static str = "getRegisteredSets(address)";
10067            const SELECTOR: [u8; 4] = [121u8, 174u8, 80u8, 205u8];
10068            #[inline]
10069            fn new<'a>(
10070                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10071            ) -> Self {
10072                tuple.into()
10073            }
10074            #[inline]
10075            fn tokenize(&self) -> Self::Token<'_> {
10076                (
10077                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10078                        &self.operator,
10079                    ),
10080                )
10081            }
10082            #[inline]
10083            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10084                (
10085                    <alloy::sol_types::sol_data::Array<
10086                        OperatorSet,
10087                    > as alloy_sol_types::SolType>::tokenize(ret),
10088                )
10089            }
10090            #[inline]
10091            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10092                <Self::ReturnTuple<
10093                    '_,
10094                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
10095                    .map(|r| {
10096                        let r: getRegisteredSetsReturn = r.into();
10097                        r.operatorSets
10098                    })
10099            }
10100            #[inline]
10101            fn abi_decode_returns_validate(
10102                data: &[u8],
10103            ) -> alloy_sol_types::Result<Self::Return> {
10104                <Self::ReturnTuple<
10105                    '_,
10106                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
10107                    .map(|r| {
10108                        let r: getRegisteredSetsReturn = r.into();
10109                        r.operatorSets
10110                    })
10111            }
10112        }
10113    };
10114    #[derive(serde::Serialize, serde::Deserialize)]
10115    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10116    /**Function with signature `getStrategiesInOperatorSet((address,uint32))` and selector `0x4177a87c`.
10117```solidity
10118function getStrategiesInOperatorSet(OperatorSet memory operatorSet) external view returns (address[] memory strategies);
10119```*/
10120    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10121    #[derive(Clone)]
10122    pub struct getStrategiesInOperatorSetCall {
10123        #[allow(missing_docs)]
10124        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
10125    }
10126    #[derive(serde::Serialize, serde::Deserialize)]
10127    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10128    ///Container type for the return parameters of the [`getStrategiesInOperatorSet((address,uint32))`](getStrategiesInOperatorSetCall) function.
10129    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10130    #[derive(Clone)]
10131    pub struct getStrategiesInOperatorSetReturn {
10132        #[allow(missing_docs)]
10133        pub strategies: alloy::sol_types::private::Vec<
10134            alloy::sol_types::private::Address,
10135        >,
10136    }
10137    #[allow(
10138        non_camel_case_types,
10139        non_snake_case,
10140        clippy::pub_underscore_fields,
10141        clippy::style
10142    )]
10143    const _: () = {
10144        use alloy::sol_types as alloy_sol_types;
10145        {
10146            #[doc(hidden)]
10147            type UnderlyingSolTuple<'a> = (OperatorSet,);
10148            #[doc(hidden)]
10149            type UnderlyingRustTuple<'a> = (
10150                <OperatorSet as alloy::sol_types::SolType>::RustType,
10151            );
10152            #[cfg(test)]
10153            #[allow(dead_code, unreachable_patterns)]
10154            fn _type_assertion(
10155                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10156            ) {
10157                match _t {
10158                    alloy_sol_types::private::AssertTypeEq::<
10159                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10160                    >(_) => {}
10161                }
10162            }
10163            #[automatically_derived]
10164            #[doc(hidden)]
10165            impl ::core::convert::From<getStrategiesInOperatorSetCall>
10166            for UnderlyingRustTuple<'_> {
10167                fn from(value: getStrategiesInOperatorSetCall) -> Self {
10168                    (value.operatorSet,)
10169                }
10170            }
10171            #[automatically_derived]
10172            #[doc(hidden)]
10173            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10174            for getStrategiesInOperatorSetCall {
10175                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10176                    Self { operatorSet: tuple.0 }
10177                }
10178            }
10179        }
10180        {
10181            #[doc(hidden)]
10182            type UnderlyingSolTuple<'a> = (
10183                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10184            );
10185            #[doc(hidden)]
10186            type UnderlyingRustTuple<'a> = (
10187                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
10188            );
10189            #[cfg(test)]
10190            #[allow(dead_code, unreachable_patterns)]
10191            fn _type_assertion(
10192                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10193            ) {
10194                match _t {
10195                    alloy_sol_types::private::AssertTypeEq::<
10196                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10197                    >(_) => {}
10198                }
10199            }
10200            #[automatically_derived]
10201            #[doc(hidden)]
10202            impl ::core::convert::From<getStrategiesInOperatorSetReturn>
10203            for UnderlyingRustTuple<'_> {
10204                fn from(value: getStrategiesInOperatorSetReturn) -> Self {
10205                    (value.strategies,)
10206                }
10207            }
10208            #[automatically_derived]
10209            #[doc(hidden)]
10210            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10211            for getStrategiesInOperatorSetReturn {
10212                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10213                    Self { strategies: tuple.0 }
10214                }
10215            }
10216        }
10217        #[automatically_derived]
10218        impl alloy_sol_types::SolCall for getStrategiesInOperatorSetCall {
10219            type Parameters<'a> = (OperatorSet,);
10220            type Token<'a> = <Self::Parameters<
10221                'a,
10222            > as alloy_sol_types::SolType>::Token<'a>;
10223            type Return = alloy::sol_types::private::Vec<
10224                alloy::sol_types::private::Address,
10225            >;
10226            type ReturnTuple<'a> = (
10227                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
10228            );
10229            type ReturnToken<'a> = <Self::ReturnTuple<
10230                'a,
10231            > as alloy_sol_types::SolType>::Token<'a>;
10232            const SIGNATURE: &'static str = "getStrategiesInOperatorSet((address,uint32))";
10233            const SELECTOR: [u8; 4] = [65u8, 119u8, 168u8, 124u8];
10234            #[inline]
10235            fn new<'a>(
10236                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10237            ) -> Self {
10238                tuple.into()
10239            }
10240            #[inline]
10241            fn tokenize(&self) -> Self::Token<'_> {
10242                (<OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),)
10243            }
10244            #[inline]
10245            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10246                (
10247                    <alloy::sol_types::sol_data::Array<
10248                        alloy::sol_types::sol_data::Address,
10249                    > as alloy_sol_types::SolType>::tokenize(ret),
10250                )
10251            }
10252            #[inline]
10253            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10254                <Self::ReturnTuple<
10255                    '_,
10256                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
10257                    .map(|r| {
10258                        let r: getStrategiesInOperatorSetReturn = r.into();
10259                        r.strategies
10260                    })
10261            }
10262            #[inline]
10263            fn abi_decode_returns_validate(
10264                data: &[u8],
10265            ) -> alloy_sol_types::Result<Self::Return> {
10266                <Self::ReturnTuple<
10267                    '_,
10268                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
10269                    .map(|r| {
10270                        let r: getStrategiesInOperatorSetReturn = r.into();
10271                        r.strategies
10272                    })
10273            }
10274        }
10275    };
10276    #[derive(serde::Serialize, serde::Deserialize)]
10277    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10278    /**Function with signature `getStrategyAllocations(address,address)` and selector `0x40120dab`.
10279```solidity
10280function getStrategyAllocations(address operator, address strategy) external view returns (OperatorSet[] memory, IAllocationManagerTypes.Allocation[] memory);
10281```*/
10282    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10283    #[derive(Clone)]
10284    pub struct getStrategyAllocationsCall {
10285        #[allow(missing_docs)]
10286        pub operator: alloy::sol_types::private::Address,
10287        #[allow(missing_docs)]
10288        pub strategy: alloy::sol_types::private::Address,
10289    }
10290    #[derive(serde::Serialize, serde::Deserialize)]
10291    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10292    ///Container type for the return parameters of the [`getStrategyAllocations(address,address)`](getStrategyAllocationsCall) function.
10293    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10294    #[derive(Clone)]
10295    pub struct getStrategyAllocationsReturn {
10296        #[allow(missing_docs)]
10297        pub _0: alloy::sol_types::private::Vec<
10298            <OperatorSet as alloy::sol_types::SolType>::RustType,
10299        >,
10300        #[allow(missing_docs)]
10301        pub _1: alloy::sol_types::private::Vec<
10302            <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
10303        >,
10304    }
10305    #[allow(
10306        non_camel_case_types,
10307        non_snake_case,
10308        clippy::pub_underscore_fields,
10309        clippy::style
10310    )]
10311    const _: () = {
10312        use alloy::sol_types as alloy_sol_types;
10313        {
10314            #[doc(hidden)]
10315            type UnderlyingSolTuple<'a> = (
10316                alloy::sol_types::sol_data::Address,
10317                alloy::sol_types::sol_data::Address,
10318            );
10319            #[doc(hidden)]
10320            type UnderlyingRustTuple<'a> = (
10321                alloy::sol_types::private::Address,
10322                alloy::sol_types::private::Address,
10323            );
10324            #[cfg(test)]
10325            #[allow(dead_code, unreachable_patterns)]
10326            fn _type_assertion(
10327                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10328            ) {
10329                match _t {
10330                    alloy_sol_types::private::AssertTypeEq::<
10331                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10332                    >(_) => {}
10333                }
10334            }
10335            #[automatically_derived]
10336            #[doc(hidden)]
10337            impl ::core::convert::From<getStrategyAllocationsCall>
10338            for UnderlyingRustTuple<'_> {
10339                fn from(value: getStrategyAllocationsCall) -> Self {
10340                    (value.operator, value.strategy)
10341                }
10342            }
10343            #[automatically_derived]
10344            #[doc(hidden)]
10345            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10346            for getStrategyAllocationsCall {
10347                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10348                    Self {
10349                        operator: tuple.0,
10350                        strategy: tuple.1,
10351                    }
10352                }
10353            }
10354        }
10355        {
10356            #[doc(hidden)]
10357            type UnderlyingSolTuple<'a> = (
10358                alloy::sol_types::sol_data::Array<OperatorSet>,
10359                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,
10360            );
10361            #[doc(hidden)]
10362            type UnderlyingRustTuple<'a> = (
10363                alloy::sol_types::private::Vec<
10364                    <OperatorSet as alloy::sol_types::SolType>::RustType,
10365                >,
10366                alloy::sol_types::private::Vec<
10367                    <IAllocationManagerTypes::Allocation as alloy::sol_types::SolType>::RustType,
10368                >,
10369            );
10370            #[cfg(test)]
10371            #[allow(dead_code, unreachable_patterns)]
10372            fn _type_assertion(
10373                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10374            ) {
10375                match _t {
10376                    alloy_sol_types::private::AssertTypeEq::<
10377                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10378                    >(_) => {}
10379                }
10380            }
10381            #[automatically_derived]
10382            #[doc(hidden)]
10383            impl ::core::convert::From<getStrategyAllocationsReturn>
10384            for UnderlyingRustTuple<'_> {
10385                fn from(value: getStrategyAllocationsReturn) -> Self {
10386                    (value._0, value._1)
10387                }
10388            }
10389            #[automatically_derived]
10390            #[doc(hidden)]
10391            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10392            for getStrategyAllocationsReturn {
10393                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10394                    Self { _0: tuple.0, _1: tuple.1 }
10395                }
10396            }
10397        }
10398        impl getStrategyAllocationsReturn {
10399            fn _tokenize(
10400                &self,
10401            ) -> <getStrategyAllocationsCall as alloy_sol_types::SolCall>::ReturnToken<
10402                '_,
10403            > {
10404                (
10405                    <alloy::sol_types::sol_data::Array<
10406                        OperatorSet,
10407                    > as alloy_sol_types::SolType>::tokenize(&self._0),
10408                    <alloy::sol_types::sol_data::Array<
10409                        IAllocationManagerTypes::Allocation,
10410                    > as alloy_sol_types::SolType>::tokenize(&self._1),
10411                )
10412            }
10413        }
10414        #[automatically_derived]
10415        impl alloy_sol_types::SolCall for getStrategyAllocationsCall {
10416            type Parameters<'a> = (
10417                alloy::sol_types::sol_data::Address,
10418                alloy::sol_types::sol_data::Address,
10419            );
10420            type Token<'a> = <Self::Parameters<
10421                'a,
10422            > as alloy_sol_types::SolType>::Token<'a>;
10423            type Return = getStrategyAllocationsReturn;
10424            type ReturnTuple<'a> = (
10425                alloy::sol_types::sol_data::Array<OperatorSet>,
10426                alloy::sol_types::sol_data::Array<IAllocationManagerTypes::Allocation>,
10427            );
10428            type ReturnToken<'a> = <Self::ReturnTuple<
10429                'a,
10430            > as alloy_sol_types::SolType>::Token<'a>;
10431            const SIGNATURE: &'static str = "getStrategyAllocations(address,address)";
10432            const SELECTOR: [u8; 4] = [64u8, 18u8, 13u8, 171u8];
10433            #[inline]
10434            fn new<'a>(
10435                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10436            ) -> Self {
10437                tuple.into()
10438            }
10439            #[inline]
10440            fn tokenize(&self) -> Self::Token<'_> {
10441                (
10442                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10443                        &self.operator,
10444                    ),
10445                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10446                        &self.strategy,
10447                    ),
10448                )
10449            }
10450            #[inline]
10451            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10452                getStrategyAllocationsReturn::_tokenize(ret)
10453            }
10454            #[inline]
10455            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10456                <Self::ReturnTuple<
10457                    '_,
10458                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
10459                    .map(Into::into)
10460            }
10461            #[inline]
10462            fn abi_decode_returns_validate(
10463                data: &[u8],
10464            ) -> alloy_sol_types::Result<Self::Return> {
10465                <Self::ReturnTuple<
10466                    '_,
10467                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
10468                    .map(Into::into)
10469            }
10470        }
10471    };
10472    #[derive(serde::Serialize, serde::Deserialize)]
10473    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10474    /**Function with signature `initialize(address,uint256)` and selector `0xcd6dc687`.
10475```solidity
10476function initialize(address initialOwner, uint256 initialPausedStatus) external;
10477```*/
10478    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10479    #[derive(Clone)]
10480    pub struct initializeCall {
10481        #[allow(missing_docs)]
10482        pub initialOwner: alloy::sol_types::private::Address,
10483        #[allow(missing_docs)]
10484        pub initialPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
10485    }
10486    ///Container type for the return parameters of the [`initialize(address,uint256)`](initializeCall) function.
10487    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10488    #[derive(Clone)]
10489    pub struct initializeReturn {}
10490    #[allow(
10491        non_camel_case_types,
10492        non_snake_case,
10493        clippy::pub_underscore_fields,
10494        clippy::style
10495    )]
10496    const _: () = {
10497        use alloy::sol_types as alloy_sol_types;
10498        {
10499            #[doc(hidden)]
10500            type UnderlyingSolTuple<'a> = (
10501                alloy::sol_types::sol_data::Address,
10502                alloy::sol_types::sol_data::Uint<256>,
10503            );
10504            #[doc(hidden)]
10505            type UnderlyingRustTuple<'a> = (
10506                alloy::sol_types::private::Address,
10507                alloy::sol_types::private::primitives::aliases::U256,
10508            );
10509            #[cfg(test)]
10510            #[allow(dead_code, unreachable_patterns)]
10511            fn _type_assertion(
10512                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10513            ) {
10514                match _t {
10515                    alloy_sol_types::private::AssertTypeEq::<
10516                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10517                    >(_) => {}
10518                }
10519            }
10520            #[automatically_derived]
10521            #[doc(hidden)]
10522            impl ::core::convert::From<initializeCall> for UnderlyingRustTuple<'_> {
10523                fn from(value: initializeCall) -> Self {
10524                    (value.initialOwner, value.initialPausedStatus)
10525                }
10526            }
10527            #[automatically_derived]
10528            #[doc(hidden)]
10529            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeCall {
10530                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10531                    Self {
10532                        initialOwner: tuple.0,
10533                        initialPausedStatus: tuple.1,
10534                    }
10535                }
10536            }
10537        }
10538        {
10539            #[doc(hidden)]
10540            type UnderlyingSolTuple<'a> = ();
10541            #[doc(hidden)]
10542            type UnderlyingRustTuple<'a> = ();
10543            #[cfg(test)]
10544            #[allow(dead_code, unreachable_patterns)]
10545            fn _type_assertion(
10546                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10547            ) {
10548                match _t {
10549                    alloy_sol_types::private::AssertTypeEq::<
10550                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10551                    >(_) => {}
10552                }
10553            }
10554            #[automatically_derived]
10555            #[doc(hidden)]
10556            impl ::core::convert::From<initializeReturn> for UnderlyingRustTuple<'_> {
10557                fn from(value: initializeReturn) -> Self {
10558                    ()
10559                }
10560            }
10561            #[automatically_derived]
10562            #[doc(hidden)]
10563            impl ::core::convert::From<UnderlyingRustTuple<'_>> for initializeReturn {
10564                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10565                    Self {}
10566                }
10567            }
10568        }
10569        impl initializeReturn {
10570            fn _tokenize(
10571                &self,
10572            ) -> <initializeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
10573                ()
10574            }
10575        }
10576        #[automatically_derived]
10577        impl alloy_sol_types::SolCall for initializeCall {
10578            type Parameters<'a> = (
10579                alloy::sol_types::sol_data::Address,
10580                alloy::sol_types::sol_data::Uint<256>,
10581            );
10582            type Token<'a> = <Self::Parameters<
10583                'a,
10584            > as alloy_sol_types::SolType>::Token<'a>;
10585            type Return = initializeReturn;
10586            type ReturnTuple<'a> = ();
10587            type ReturnToken<'a> = <Self::ReturnTuple<
10588                'a,
10589            > as alloy_sol_types::SolType>::Token<'a>;
10590            const SIGNATURE: &'static str = "initialize(address,uint256)";
10591            const SELECTOR: [u8; 4] = [205u8, 109u8, 198u8, 135u8];
10592            #[inline]
10593            fn new<'a>(
10594                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10595            ) -> Self {
10596                tuple.into()
10597            }
10598            #[inline]
10599            fn tokenize(&self) -> Self::Token<'_> {
10600                (
10601                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10602                        &self.initialOwner,
10603                    ),
10604                    <alloy::sol_types::sol_data::Uint<
10605                        256,
10606                    > as alloy_sol_types::SolType>::tokenize(&self.initialPausedStatus),
10607                )
10608            }
10609            #[inline]
10610            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10611                initializeReturn::_tokenize(ret)
10612            }
10613            #[inline]
10614            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10615                <Self::ReturnTuple<
10616                    '_,
10617                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
10618                    .map(Into::into)
10619            }
10620            #[inline]
10621            fn abi_decode_returns_validate(
10622                data: &[u8],
10623            ) -> alloy_sol_types::Result<Self::Return> {
10624                <Self::ReturnTuple<
10625                    '_,
10626                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
10627                    .map(Into::into)
10628            }
10629        }
10630    };
10631    #[derive(serde::Serialize, serde::Deserialize)]
10632    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10633    /**Function with signature `isMemberOfOperatorSet(address,(address,uint32))` and selector `0x670d3ba2`.
10634```solidity
10635function isMemberOfOperatorSet(address operator, OperatorSet memory operatorSet) external view returns (bool);
10636```*/
10637    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10638    #[derive(Clone)]
10639    pub struct isMemberOfOperatorSetCall {
10640        #[allow(missing_docs)]
10641        pub operator: alloy::sol_types::private::Address,
10642        #[allow(missing_docs)]
10643        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
10644    }
10645    #[derive(serde::Serialize, serde::Deserialize)]
10646    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10647    ///Container type for the return parameters of the [`isMemberOfOperatorSet(address,(address,uint32))`](isMemberOfOperatorSetCall) function.
10648    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10649    #[derive(Clone)]
10650    pub struct isMemberOfOperatorSetReturn {
10651        #[allow(missing_docs)]
10652        pub _0: bool,
10653    }
10654    #[allow(
10655        non_camel_case_types,
10656        non_snake_case,
10657        clippy::pub_underscore_fields,
10658        clippy::style
10659    )]
10660    const _: () = {
10661        use alloy::sol_types as alloy_sol_types;
10662        {
10663            #[doc(hidden)]
10664            type UnderlyingSolTuple<'a> = (
10665                alloy::sol_types::sol_data::Address,
10666                OperatorSet,
10667            );
10668            #[doc(hidden)]
10669            type UnderlyingRustTuple<'a> = (
10670                alloy::sol_types::private::Address,
10671                <OperatorSet as alloy::sol_types::SolType>::RustType,
10672            );
10673            #[cfg(test)]
10674            #[allow(dead_code, unreachable_patterns)]
10675            fn _type_assertion(
10676                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10677            ) {
10678                match _t {
10679                    alloy_sol_types::private::AssertTypeEq::<
10680                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10681                    >(_) => {}
10682                }
10683            }
10684            #[automatically_derived]
10685            #[doc(hidden)]
10686            impl ::core::convert::From<isMemberOfOperatorSetCall>
10687            for UnderlyingRustTuple<'_> {
10688                fn from(value: isMemberOfOperatorSetCall) -> Self {
10689                    (value.operator, value.operatorSet)
10690                }
10691            }
10692            #[automatically_derived]
10693            #[doc(hidden)]
10694            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10695            for isMemberOfOperatorSetCall {
10696                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10697                    Self {
10698                        operator: tuple.0,
10699                        operatorSet: tuple.1,
10700                    }
10701                }
10702            }
10703        }
10704        {
10705            #[doc(hidden)]
10706            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
10707            #[doc(hidden)]
10708            type UnderlyingRustTuple<'a> = (bool,);
10709            #[cfg(test)]
10710            #[allow(dead_code, unreachable_patterns)]
10711            fn _type_assertion(
10712                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10713            ) {
10714                match _t {
10715                    alloy_sol_types::private::AssertTypeEq::<
10716                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10717                    >(_) => {}
10718                }
10719            }
10720            #[automatically_derived]
10721            #[doc(hidden)]
10722            impl ::core::convert::From<isMemberOfOperatorSetReturn>
10723            for UnderlyingRustTuple<'_> {
10724                fn from(value: isMemberOfOperatorSetReturn) -> Self {
10725                    (value._0,)
10726                }
10727            }
10728            #[automatically_derived]
10729            #[doc(hidden)]
10730            impl ::core::convert::From<UnderlyingRustTuple<'_>>
10731            for isMemberOfOperatorSetReturn {
10732                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10733                    Self { _0: tuple.0 }
10734                }
10735            }
10736        }
10737        #[automatically_derived]
10738        impl alloy_sol_types::SolCall for isMemberOfOperatorSetCall {
10739            type Parameters<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
10740            type Token<'a> = <Self::Parameters<
10741                'a,
10742            > as alloy_sol_types::SolType>::Token<'a>;
10743            type Return = bool;
10744            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
10745            type ReturnToken<'a> = <Self::ReturnTuple<
10746                'a,
10747            > as alloy_sol_types::SolType>::Token<'a>;
10748            const SIGNATURE: &'static str = "isMemberOfOperatorSet(address,(address,uint32))";
10749            const SELECTOR: [u8; 4] = [103u8, 13u8, 59u8, 162u8];
10750            #[inline]
10751            fn new<'a>(
10752                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10753            ) -> Self {
10754                tuple.into()
10755            }
10756            #[inline]
10757            fn tokenize(&self) -> Self::Token<'_> {
10758                (
10759                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
10760                        &self.operator,
10761                    ),
10762                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
10763                        &self.operatorSet,
10764                    ),
10765                )
10766            }
10767            #[inline]
10768            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10769                (
10770                    <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
10771                        ret,
10772                    ),
10773                )
10774            }
10775            #[inline]
10776            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10777                <Self::ReturnTuple<
10778                    '_,
10779                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
10780                    .map(|r| {
10781                        let r: isMemberOfOperatorSetReturn = r.into();
10782                        r._0
10783                    })
10784            }
10785            #[inline]
10786            fn abi_decode_returns_validate(
10787                data: &[u8],
10788            ) -> alloy_sol_types::Result<Self::Return> {
10789                <Self::ReturnTuple<
10790                    '_,
10791                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
10792                    .map(|r| {
10793                        let r: isMemberOfOperatorSetReturn = r.into();
10794                        r._0
10795                    })
10796            }
10797        }
10798    };
10799    #[derive(serde::Serialize, serde::Deserialize)]
10800    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10801    /**Function with signature `isOperatorSet((address,uint32))` and selector `0x260dc758`.
10802```solidity
10803function isOperatorSet(OperatorSet memory operatorSet) external view returns (bool);
10804```*/
10805    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10806    #[derive(Clone)]
10807    pub struct isOperatorSetCall {
10808        #[allow(missing_docs)]
10809        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
10810    }
10811    #[derive(serde::Serialize, serde::Deserialize)]
10812    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10813    ///Container type for the return parameters of the [`isOperatorSet((address,uint32))`](isOperatorSetCall) function.
10814    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10815    #[derive(Clone)]
10816    pub struct isOperatorSetReturn {
10817        #[allow(missing_docs)]
10818        pub _0: bool,
10819    }
10820    #[allow(
10821        non_camel_case_types,
10822        non_snake_case,
10823        clippy::pub_underscore_fields,
10824        clippy::style
10825    )]
10826    const _: () = {
10827        use alloy::sol_types as alloy_sol_types;
10828        {
10829            #[doc(hidden)]
10830            type UnderlyingSolTuple<'a> = (OperatorSet,);
10831            #[doc(hidden)]
10832            type UnderlyingRustTuple<'a> = (
10833                <OperatorSet as alloy::sol_types::SolType>::RustType,
10834            );
10835            #[cfg(test)]
10836            #[allow(dead_code, unreachable_patterns)]
10837            fn _type_assertion(
10838                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10839            ) {
10840                match _t {
10841                    alloy_sol_types::private::AssertTypeEq::<
10842                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10843                    >(_) => {}
10844                }
10845            }
10846            #[automatically_derived]
10847            #[doc(hidden)]
10848            impl ::core::convert::From<isOperatorSetCall> for UnderlyingRustTuple<'_> {
10849                fn from(value: isOperatorSetCall) -> Self {
10850                    (value.operatorSet,)
10851                }
10852            }
10853            #[automatically_derived]
10854            #[doc(hidden)]
10855            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperatorSetCall {
10856                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10857                    Self { operatorSet: tuple.0 }
10858                }
10859            }
10860        }
10861        {
10862            #[doc(hidden)]
10863            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
10864            #[doc(hidden)]
10865            type UnderlyingRustTuple<'a> = (bool,);
10866            #[cfg(test)]
10867            #[allow(dead_code, unreachable_patterns)]
10868            fn _type_assertion(
10869                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10870            ) {
10871                match _t {
10872                    alloy_sol_types::private::AssertTypeEq::<
10873                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10874                    >(_) => {}
10875                }
10876            }
10877            #[automatically_derived]
10878            #[doc(hidden)]
10879            impl ::core::convert::From<isOperatorSetReturn> for UnderlyingRustTuple<'_> {
10880                fn from(value: isOperatorSetReturn) -> Self {
10881                    (value._0,)
10882                }
10883            }
10884            #[automatically_derived]
10885            #[doc(hidden)]
10886            impl ::core::convert::From<UnderlyingRustTuple<'_>> for isOperatorSetReturn {
10887                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
10888                    Self { _0: tuple.0 }
10889                }
10890            }
10891        }
10892        #[automatically_derived]
10893        impl alloy_sol_types::SolCall for isOperatorSetCall {
10894            type Parameters<'a> = (OperatorSet,);
10895            type Token<'a> = <Self::Parameters<
10896                'a,
10897            > as alloy_sol_types::SolType>::Token<'a>;
10898            type Return = bool;
10899            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
10900            type ReturnToken<'a> = <Self::ReturnTuple<
10901                'a,
10902            > as alloy_sol_types::SolType>::Token<'a>;
10903            const SIGNATURE: &'static str = "isOperatorSet((address,uint32))";
10904            const SELECTOR: [u8; 4] = [38u8, 13u8, 199u8, 88u8];
10905            #[inline]
10906            fn new<'a>(
10907                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
10908            ) -> Self {
10909                tuple.into()
10910            }
10911            #[inline]
10912            fn tokenize(&self) -> Self::Token<'_> {
10913                (<OperatorSet as alloy_sol_types::SolType>::tokenize(&self.operatorSet),)
10914            }
10915            #[inline]
10916            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
10917                (
10918                    <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
10919                        ret,
10920                    ),
10921                )
10922            }
10923            #[inline]
10924            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
10925                <Self::ReturnTuple<
10926                    '_,
10927                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
10928                    .map(|r| {
10929                        let r: isOperatorSetReturn = r.into();
10930                        r._0
10931                    })
10932            }
10933            #[inline]
10934            fn abi_decode_returns_validate(
10935                data: &[u8],
10936            ) -> alloy_sol_types::Result<Self::Return> {
10937                <Self::ReturnTuple<
10938                    '_,
10939                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
10940                    .map(|r| {
10941                        let r: isOperatorSetReturn = r.into();
10942                        r._0
10943                    })
10944            }
10945        }
10946    };
10947    #[derive(serde::Serialize, serde::Deserialize)]
10948    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10949    /**Function with signature `isOperatorSlashable(address,(address,uint32))` and selector `0x1352c3e6`.
10950```solidity
10951function isOperatorSlashable(address operator, OperatorSet memory operatorSet) external view returns (bool);
10952```*/
10953    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10954    #[derive(Clone)]
10955    pub struct isOperatorSlashableCall {
10956        #[allow(missing_docs)]
10957        pub operator: alloy::sol_types::private::Address,
10958        #[allow(missing_docs)]
10959        pub operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
10960    }
10961    #[derive(serde::Serialize, serde::Deserialize)]
10962    #[derive(Default, Debug, PartialEq, Eq, Hash)]
10963    ///Container type for the return parameters of the [`isOperatorSlashable(address,(address,uint32))`](isOperatorSlashableCall) function.
10964    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
10965    #[derive(Clone)]
10966    pub struct isOperatorSlashableReturn {
10967        #[allow(missing_docs)]
10968        pub _0: bool,
10969    }
10970    #[allow(
10971        non_camel_case_types,
10972        non_snake_case,
10973        clippy::pub_underscore_fields,
10974        clippy::style
10975    )]
10976    const _: () = {
10977        use alloy::sol_types as alloy_sol_types;
10978        {
10979            #[doc(hidden)]
10980            type UnderlyingSolTuple<'a> = (
10981                alloy::sol_types::sol_data::Address,
10982                OperatorSet,
10983            );
10984            #[doc(hidden)]
10985            type UnderlyingRustTuple<'a> = (
10986                alloy::sol_types::private::Address,
10987                <OperatorSet as alloy::sol_types::SolType>::RustType,
10988            );
10989            #[cfg(test)]
10990            #[allow(dead_code, unreachable_patterns)]
10991            fn _type_assertion(
10992                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
10993            ) {
10994                match _t {
10995                    alloy_sol_types::private::AssertTypeEq::<
10996                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
10997                    >(_) => {}
10998                }
10999            }
11000            #[automatically_derived]
11001            #[doc(hidden)]
11002            impl ::core::convert::From<isOperatorSlashableCall>
11003            for UnderlyingRustTuple<'_> {
11004                fn from(value: isOperatorSlashableCall) -> Self {
11005                    (value.operator, value.operatorSet)
11006                }
11007            }
11008            #[automatically_derived]
11009            #[doc(hidden)]
11010            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11011            for isOperatorSlashableCall {
11012                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11013                    Self {
11014                        operator: tuple.0,
11015                        operatorSet: tuple.1,
11016                    }
11017                }
11018            }
11019        }
11020        {
11021            #[doc(hidden)]
11022            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
11023            #[doc(hidden)]
11024            type UnderlyingRustTuple<'a> = (bool,);
11025            #[cfg(test)]
11026            #[allow(dead_code, unreachable_patterns)]
11027            fn _type_assertion(
11028                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11029            ) {
11030                match _t {
11031                    alloy_sol_types::private::AssertTypeEq::<
11032                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11033                    >(_) => {}
11034                }
11035            }
11036            #[automatically_derived]
11037            #[doc(hidden)]
11038            impl ::core::convert::From<isOperatorSlashableReturn>
11039            for UnderlyingRustTuple<'_> {
11040                fn from(value: isOperatorSlashableReturn) -> Self {
11041                    (value._0,)
11042                }
11043            }
11044            #[automatically_derived]
11045            #[doc(hidden)]
11046            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11047            for isOperatorSlashableReturn {
11048                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11049                    Self { _0: tuple.0 }
11050                }
11051            }
11052        }
11053        #[automatically_derived]
11054        impl alloy_sol_types::SolCall for isOperatorSlashableCall {
11055            type Parameters<'a> = (alloy::sol_types::sol_data::Address, OperatorSet);
11056            type Token<'a> = <Self::Parameters<
11057                'a,
11058            > as alloy_sol_types::SolType>::Token<'a>;
11059            type Return = bool;
11060            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
11061            type ReturnToken<'a> = <Self::ReturnTuple<
11062                'a,
11063            > as alloy_sol_types::SolType>::Token<'a>;
11064            const SIGNATURE: &'static str = "isOperatorSlashable(address,(address,uint32))";
11065            const SELECTOR: [u8; 4] = [19u8, 82u8, 195u8, 230u8];
11066            #[inline]
11067            fn new<'a>(
11068                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11069            ) -> Self {
11070                tuple.into()
11071            }
11072            #[inline]
11073            fn tokenize(&self) -> Self::Token<'_> {
11074                (
11075                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11076                        &self.operator,
11077                    ),
11078                    <OperatorSet as alloy_sol_types::SolType>::tokenize(
11079                        &self.operatorSet,
11080                    ),
11081                )
11082            }
11083            #[inline]
11084            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11085                (
11086                    <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
11087                        ret,
11088                    ),
11089                )
11090            }
11091            #[inline]
11092            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11093                <Self::ReturnTuple<
11094                    '_,
11095                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
11096                    .map(|r| {
11097                        let r: isOperatorSlashableReturn = r.into();
11098                        r._0
11099                    })
11100            }
11101            #[inline]
11102            fn abi_decode_returns_validate(
11103                data: &[u8],
11104            ) -> alloy_sol_types::Result<Self::Return> {
11105                <Self::ReturnTuple<
11106                    '_,
11107                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
11108                    .map(|r| {
11109                        let r: isOperatorSlashableReturn = r.into();
11110                        r._0
11111                    })
11112            }
11113        }
11114    };
11115    #[derive(serde::Serialize, serde::Deserialize)]
11116    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11117    /**Function with signature `modifyAllocations(address,((address,uint32),address[],uint64[])[])` and selector `0x952899ee`.
11118```solidity
11119function modifyAllocations(address operator, IAllocationManagerTypes.AllocateParams[] memory params) external;
11120```*/
11121    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11122    #[derive(Clone)]
11123    pub struct modifyAllocationsCall {
11124        #[allow(missing_docs)]
11125        pub operator: alloy::sol_types::private::Address,
11126        #[allow(missing_docs)]
11127        pub params: alloy::sol_types::private::Vec<
11128            <IAllocationManagerTypes::AllocateParams as alloy::sol_types::SolType>::RustType,
11129        >,
11130    }
11131    ///Container type for the return parameters of the [`modifyAllocations(address,((address,uint32),address[],uint64[])[])`](modifyAllocationsCall) function.
11132    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11133    #[derive(Clone)]
11134    pub struct modifyAllocationsReturn {}
11135    #[allow(
11136        non_camel_case_types,
11137        non_snake_case,
11138        clippy::pub_underscore_fields,
11139        clippy::style
11140    )]
11141    const _: () = {
11142        use alloy::sol_types as alloy_sol_types;
11143        {
11144            #[doc(hidden)]
11145            type UnderlyingSolTuple<'a> = (
11146                alloy::sol_types::sol_data::Address,
11147                alloy::sol_types::sol_data::Array<
11148                    IAllocationManagerTypes::AllocateParams,
11149                >,
11150            );
11151            #[doc(hidden)]
11152            type UnderlyingRustTuple<'a> = (
11153                alloy::sol_types::private::Address,
11154                alloy::sol_types::private::Vec<
11155                    <IAllocationManagerTypes::AllocateParams as alloy::sol_types::SolType>::RustType,
11156                >,
11157            );
11158            #[cfg(test)]
11159            #[allow(dead_code, unreachable_patterns)]
11160            fn _type_assertion(
11161                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11162            ) {
11163                match _t {
11164                    alloy_sol_types::private::AssertTypeEq::<
11165                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11166                    >(_) => {}
11167                }
11168            }
11169            #[automatically_derived]
11170            #[doc(hidden)]
11171            impl ::core::convert::From<modifyAllocationsCall>
11172            for UnderlyingRustTuple<'_> {
11173                fn from(value: modifyAllocationsCall) -> Self {
11174                    (value.operator, value.params)
11175                }
11176            }
11177            #[automatically_derived]
11178            #[doc(hidden)]
11179            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11180            for modifyAllocationsCall {
11181                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11182                    Self {
11183                        operator: tuple.0,
11184                        params: tuple.1,
11185                    }
11186                }
11187            }
11188        }
11189        {
11190            #[doc(hidden)]
11191            type UnderlyingSolTuple<'a> = ();
11192            #[doc(hidden)]
11193            type UnderlyingRustTuple<'a> = ();
11194            #[cfg(test)]
11195            #[allow(dead_code, unreachable_patterns)]
11196            fn _type_assertion(
11197                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11198            ) {
11199                match _t {
11200                    alloy_sol_types::private::AssertTypeEq::<
11201                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11202                    >(_) => {}
11203                }
11204            }
11205            #[automatically_derived]
11206            #[doc(hidden)]
11207            impl ::core::convert::From<modifyAllocationsReturn>
11208            for UnderlyingRustTuple<'_> {
11209                fn from(value: modifyAllocationsReturn) -> Self {
11210                    ()
11211                }
11212            }
11213            #[automatically_derived]
11214            #[doc(hidden)]
11215            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11216            for modifyAllocationsReturn {
11217                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11218                    Self {}
11219                }
11220            }
11221        }
11222        impl modifyAllocationsReturn {
11223            fn _tokenize(
11224                &self,
11225            ) -> <modifyAllocationsCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
11226                ()
11227            }
11228        }
11229        #[automatically_derived]
11230        impl alloy_sol_types::SolCall for modifyAllocationsCall {
11231            type Parameters<'a> = (
11232                alloy::sol_types::sol_data::Address,
11233                alloy::sol_types::sol_data::Array<
11234                    IAllocationManagerTypes::AllocateParams,
11235                >,
11236            );
11237            type Token<'a> = <Self::Parameters<
11238                'a,
11239            > as alloy_sol_types::SolType>::Token<'a>;
11240            type Return = modifyAllocationsReturn;
11241            type ReturnTuple<'a> = ();
11242            type ReturnToken<'a> = <Self::ReturnTuple<
11243                'a,
11244            > as alloy_sol_types::SolType>::Token<'a>;
11245            const SIGNATURE: &'static str = "modifyAllocations(address,((address,uint32),address[],uint64[])[])";
11246            const SELECTOR: [u8; 4] = [149u8, 40u8, 153u8, 238u8];
11247            #[inline]
11248            fn new<'a>(
11249                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11250            ) -> Self {
11251                tuple.into()
11252            }
11253            #[inline]
11254            fn tokenize(&self) -> Self::Token<'_> {
11255                (
11256                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11257                        &self.operator,
11258                    ),
11259                    <alloy::sol_types::sol_data::Array<
11260                        IAllocationManagerTypes::AllocateParams,
11261                    > as alloy_sol_types::SolType>::tokenize(&self.params),
11262                )
11263            }
11264            #[inline]
11265            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11266                modifyAllocationsReturn::_tokenize(ret)
11267            }
11268            #[inline]
11269            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11270                <Self::ReturnTuple<
11271                    '_,
11272                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
11273                    .map(Into::into)
11274            }
11275            #[inline]
11276            fn abi_decode_returns_validate(
11277                data: &[u8],
11278            ) -> alloy_sol_types::Result<Self::Return> {
11279                <Self::ReturnTuple<
11280                    '_,
11281                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
11282                    .map(Into::into)
11283            }
11284        }
11285    };
11286    #[derive(serde::Serialize, serde::Deserialize)]
11287    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11288    /**Function with signature `registerForOperatorSets(address,(address,uint32[],bytes))` and selector `0xadc2e3d9`.
11289```solidity
11290function registerForOperatorSets(address operator, IAllocationManagerTypes.RegisterParams memory params) external;
11291```*/
11292    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11293    #[derive(Clone)]
11294    pub struct registerForOperatorSetsCall {
11295        #[allow(missing_docs)]
11296        pub operator: alloy::sol_types::private::Address,
11297        #[allow(missing_docs)]
11298        pub params: <IAllocationManagerTypes::RegisterParams as alloy::sol_types::SolType>::RustType,
11299    }
11300    ///Container type for the return parameters of the [`registerForOperatorSets(address,(address,uint32[],bytes))`](registerForOperatorSetsCall) function.
11301    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11302    #[derive(Clone)]
11303    pub struct registerForOperatorSetsReturn {}
11304    #[allow(
11305        non_camel_case_types,
11306        non_snake_case,
11307        clippy::pub_underscore_fields,
11308        clippy::style
11309    )]
11310    const _: () = {
11311        use alloy::sol_types as alloy_sol_types;
11312        {
11313            #[doc(hidden)]
11314            type UnderlyingSolTuple<'a> = (
11315                alloy::sol_types::sol_data::Address,
11316                IAllocationManagerTypes::RegisterParams,
11317            );
11318            #[doc(hidden)]
11319            type UnderlyingRustTuple<'a> = (
11320                alloy::sol_types::private::Address,
11321                <IAllocationManagerTypes::RegisterParams as alloy::sol_types::SolType>::RustType,
11322            );
11323            #[cfg(test)]
11324            #[allow(dead_code, unreachable_patterns)]
11325            fn _type_assertion(
11326                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11327            ) {
11328                match _t {
11329                    alloy_sol_types::private::AssertTypeEq::<
11330                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11331                    >(_) => {}
11332                }
11333            }
11334            #[automatically_derived]
11335            #[doc(hidden)]
11336            impl ::core::convert::From<registerForOperatorSetsCall>
11337            for UnderlyingRustTuple<'_> {
11338                fn from(value: registerForOperatorSetsCall) -> Self {
11339                    (value.operator, value.params)
11340                }
11341            }
11342            #[automatically_derived]
11343            #[doc(hidden)]
11344            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11345            for registerForOperatorSetsCall {
11346                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11347                    Self {
11348                        operator: tuple.0,
11349                        params: tuple.1,
11350                    }
11351                }
11352            }
11353        }
11354        {
11355            #[doc(hidden)]
11356            type UnderlyingSolTuple<'a> = ();
11357            #[doc(hidden)]
11358            type UnderlyingRustTuple<'a> = ();
11359            #[cfg(test)]
11360            #[allow(dead_code, unreachable_patterns)]
11361            fn _type_assertion(
11362                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11363            ) {
11364                match _t {
11365                    alloy_sol_types::private::AssertTypeEq::<
11366                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11367                    >(_) => {}
11368                }
11369            }
11370            #[automatically_derived]
11371            #[doc(hidden)]
11372            impl ::core::convert::From<registerForOperatorSetsReturn>
11373            for UnderlyingRustTuple<'_> {
11374                fn from(value: registerForOperatorSetsReturn) -> Self {
11375                    ()
11376                }
11377            }
11378            #[automatically_derived]
11379            #[doc(hidden)]
11380            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11381            for registerForOperatorSetsReturn {
11382                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11383                    Self {}
11384                }
11385            }
11386        }
11387        impl registerForOperatorSetsReturn {
11388            fn _tokenize(
11389                &self,
11390            ) -> <registerForOperatorSetsCall as alloy_sol_types::SolCall>::ReturnToken<
11391                '_,
11392            > {
11393                ()
11394            }
11395        }
11396        #[automatically_derived]
11397        impl alloy_sol_types::SolCall for registerForOperatorSetsCall {
11398            type Parameters<'a> = (
11399                alloy::sol_types::sol_data::Address,
11400                IAllocationManagerTypes::RegisterParams,
11401            );
11402            type Token<'a> = <Self::Parameters<
11403                'a,
11404            > as alloy_sol_types::SolType>::Token<'a>;
11405            type Return = registerForOperatorSetsReturn;
11406            type ReturnTuple<'a> = ();
11407            type ReturnToken<'a> = <Self::ReturnTuple<
11408                'a,
11409            > as alloy_sol_types::SolType>::Token<'a>;
11410            const SIGNATURE: &'static str = "registerForOperatorSets(address,(address,uint32[],bytes))";
11411            const SELECTOR: [u8; 4] = [173u8, 194u8, 227u8, 217u8];
11412            #[inline]
11413            fn new<'a>(
11414                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11415            ) -> Self {
11416                tuple.into()
11417            }
11418            #[inline]
11419            fn tokenize(&self) -> Self::Token<'_> {
11420                (
11421                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11422                        &self.operator,
11423                    ),
11424                    <IAllocationManagerTypes::RegisterParams as alloy_sol_types::SolType>::tokenize(
11425                        &self.params,
11426                    ),
11427                )
11428            }
11429            #[inline]
11430            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11431                registerForOperatorSetsReturn::_tokenize(ret)
11432            }
11433            #[inline]
11434            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11435                <Self::ReturnTuple<
11436                    '_,
11437                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
11438                    .map(Into::into)
11439            }
11440            #[inline]
11441            fn abi_decode_returns_validate(
11442                data: &[u8],
11443            ) -> alloy_sol_types::Result<Self::Return> {
11444                <Self::ReturnTuple<
11445                    '_,
11446                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
11447                    .map(Into::into)
11448            }
11449        }
11450    };
11451    #[derive(serde::Serialize, serde::Deserialize)]
11452    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11453    /**Function with signature `removeStrategiesFromOperatorSet(address,uint32,address[])` and selector `0xb66bd989`.
11454```solidity
11455function removeStrategiesFromOperatorSet(address avs, uint32 operatorSetId, address[] memory strategies) external;
11456```*/
11457    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11458    #[derive(Clone)]
11459    pub struct removeStrategiesFromOperatorSetCall {
11460        #[allow(missing_docs)]
11461        pub avs: alloy::sol_types::private::Address,
11462        #[allow(missing_docs)]
11463        pub operatorSetId: u32,
11464        #[allow(missing_docs)]
11465        pub strategies: alloy::sol_types::private::Vec<
11466            alloy::sol_types::private::Address,
11467        >,
11468    }
11469    ///Container type for the return parameters of the [`removeStrategiesFromOperatorSet(address,uint32,address[])`](removeStrategiesFromOperatorSetCall) function.
11470    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11471    #[derive(Clone)]
11472    pub struct removeStrategiesFromOperatorSetReturn {}
11473    #[allow(
11474        non_camel_case_types,
11475        non_snake_case,
11476        clippy::pub_underscore_fields,
11477        clippy::style
11478    )]
11479    const _: () = {
11480        use alloy::sol_types as alloy_sol_types;
11481        {
11482            #[doc(hidden)]
11483            type UnderlyingSolTuple<'a> = (
11484                alloy::sol_types::sol_data::Address,
11485                alloy::sol_types::sol_data::Uint<32>,
11486                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
11487            );
11488            #[doc(hidden)]
11489            type UnderlyingRustTuple<'a> = (
11490                alloy::sol_types::private::Address,
11491                u32,
11492                alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
11493            );
11494            #[cfg(test)]
11495            #[allow(dead_code, unreachable_patterns)]
11496            fn _type_assertion(
11497                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11498            ) {
11499                match _t {
11500                    alloy_sol_types::private::AssertTypeEq::<
11501                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11502                    >(_) => {}
11503                }
11504            }
11505            #[automatically_derived]
11506            #[doc(hidden)]
11507            impl ::core::convert::From<removeStrategiesFromOperatorSetCall>
11508            for UnderlyingRustTuple<'_> {
11509                fn from(value: removeStrategiesFromOperatorSetCall) -> Self {
11510                    (value.avs, value.operatorSetId, value.strategies)
11511                }
11512            }
11513            #[automatically_derived]
11514            #[doc(hidden)]
11515            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11516            for removeStrategiesFromOperatorSetCall {
11517                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11518                    Self {
11519                        avs: tuple.0,
11520                        operatorSetId: tuple.1,
11521                        strategies: tuple.2,
11522                    }
11523                }
11524            }
11525        }
11526        {
11527            #[doc(hidden)]
11528            type UnderlyingSolTuple<'a> = ();
11529            #[doc(hidden)]
11530            type UnderlyingRustTuple<'a> = ();
11531            #[cfg(test)]
11532            #[allow(dead_code, unreachable_patterns)]
11533            fn _type_assertion(
11534                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11535            ) {
11536                match _t {
11537                    alloy_sol_types::private::AssertTypeEq::<
11538                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11539                    >(_) => {}
11540                }
11541            }
11542            #[automatically_derived]
11543            #[doc(hidden)]
11544            impl ::core::convert::From<removeStrategiesFromOperatorSetReturn>
11545            for UnderlyingRustTuple<'_> {
11546                fn from(value: removeStrategiesFromOperatorSetReturn) -> Self {
11547                    ()
11548                }
11549            }
11550            #[automatically_derived]
11551            #[doc(hidden)]
11552            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11553            for removeStrategiesFromOperatorSetReturn {
11554                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11555                    Self {}
11556                }
11557            }
11558        }
11559        impl removeStrategiesFromOperatorSetReturn {
11560            fn _tokenize(
11561                &self,
11562            ) -> <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::ReturnToken<
11563                '_,
11564            > {
11565                ()
11566            }
11567        }
11568        #[automatically_derived]
11569        impl alloy_sol_types::SolCall for removeStrategiesFromOperatorSetCall {
11570            type Parameters<'a> = (
11571                alloy::sol_types::sol_data::Address,
11572                alloy::sol_types::sol_data::Uint<32>,
11573                alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
11574            );
11575            type Token<'a> = <Self::Parameters<
11576                'a,
11577            > as alloy_sol_types::SolType>::Token<'a>;
11578            type Return = removeStrategiesFromOperatorSetReturn;
11579            type ReturnTuple<'a> = ();
11580            type ReturnToken<'a> = <Self::ReturnTuple<
11581                'a,
11582            > as alloy_sol_types::SolType>::Token<'a>;
11583            const SIGNATURE: &'static str = "removeStrategiesFromOperatorSet(address,uint32,address[])";
11584            const SELECTOR: [u8; 4] = [182u8, 107u8, 217u8, 137u8];
11585            #[inline]
11586            fn new<'a>(
11587                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11588            ) -> Self {
11589                tuple.into()
11590            }
11591            #[inline]
11592            fn tokenize(&self) -> Self::Token<'_> {
11593                (
11594                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11595                        &self.avs,
11596                    ),
11597                    <alloy::sol_types::sol_data::Uint<
11598                        32,
11599                    > as alloy_sol_types::SolType>::tokenize(&self.operatorSetId),
11600                    <alloy::sol_types::sol_data::Array<
11601                        alloy::sol_types::sol_data::Address,
11602                    > as alloy_sol_types::SolType>::tokenize(&self.strategies),
11603                )
11604            }
11605            #[inline]
11606            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11607                removeStrategiesFromOperatorSetReturn::_tokenize(ret)
11608            }
11609            #[inline]
11610            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11611                <Self::ReturnTuple<
11612                    '_,
11613                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
11614                    .map(Into::into)
11615            }
11616            #[inline]
11617            fn abi_decode_returns_validate(
11618                data: &[u8],
11619            ) -> alloy_sol_types::Result<Self::Return> {
11620                <Self::ReturnTuple<
11621                    '_,
11622                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
11623                    .map(Into::into)
11624            }
11625        }
11626    };
11627    #[derive(serde::Serialize, serde::Deserialize)]
11628    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11629    /**Function with signature `setAVSRegistrar(address,address)` and selector `0xd3d96ff4`.
11630```solidity
11631function setAVSRegistrar(address avs, address registrar) external;
11632```*/
11633    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11634    #[derive(Clone)]
11635    pub struct setAVSRegistrarCall {
11636        #[allow(missing_docs)]
11637        pub avs: alloy::sol_types::private::Address,
11638        #[allow(missing_docs)]
11639        pub registrar: alloy::sol_types::private::Address,
11640    }
11641    ///Container type for the return parameters of the [`setAVSRegistrar(address,address)`](setAVSRegistrarCall) function.
11642    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11643    #[derive(Clone)]
11644    pub struct setAVSRegistrarReturn {}
11645    #[allow(
11646        non_camel_case_types,
11647        non_snake_case,
11648        clippy::pub_underscore_fields,
11649        clippy::style
11650    )]
11651    const _: () = {
11652        use alloy::sol_types as alloy_sol_types;
11653        {
11654            #[doc(hidden)]
11655            type UnderlyingSolTuple<'a> = (
11656                alloy::sol_types::sol_data::Address,
11657                alloy::sol_types::sol_data::Address,
11658            );
11659            #[doc(hidden)]
11660            type UnderlyingRustTuple<'a> = (
11661                alloy::sol_types::private::Address,
11662                alloy::sol_types::private::Address,
11663            );
11664            #[cfg(test)]
11665            #[allow(dead_code, unreachable_patterns)]
11666            fn _type_assertion(
11667                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11668            ) {
11669                match _t {
11670                    alloy_sol_types::private::AssertTypeEq::<
11671                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11672                    >(_) => {}
11673                }
11674            }
11675            #[automatically_derived]
11676            #[doc(hidden)]
11677            impl ::core::convert::From<setAVSRegistrarCall> for UnderlyingRustTuple<'_> {
11678                fn from(value: setAVSRegistrarCall) -> Self {
11679                    (value.avs, value.registrar)
11680                }
11681            }
11682            #[automatically_derived]
11683            #[doc(hidden)]
11684            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAVSRegistrarCall {
11685                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11686                    Self {
11687                        avs: tuple.0,
11688                        registrar: tuple.1,
11689                    }
11690                }
11691            }
11692        }
11693        {
11694            #[doc(hidden)]
11695            type UnderlyingSolTuple<'a> = ();
11696            #[doc(hidden)]
11697            type UnderlyingRustTuple<'a> = ();
11698            #[cfg(test)]
11699            #[allow(dead_code, unreachable_patterns)]
11700            fn _type_assertion(
11701                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11702            ) {
11703                match _t {
11704                    alloy_sol_types::private::AssertTypeEq::<
11705                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11706                    >(_) => {}
11707                }
11708            }
11709            #[automatically_derived]
11710            #[doc(hidden)]
11711            impl ::core::convert::From<setAVSRegistrarReturn>
11712            for UnderlyingRustTuple<'_> {
11713                fn from(value: setAVSRegistrarReturn) -> Self {
11714                    ()
11715                }
11716            }
11717            #[automatically_derived]
11718            #[doc(hidden)]
11719            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11720            for setAVSRegistrarReturn {
11721                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11722                    Self {}
11723                }
11724            }
11725        }
11726        impl setAVSRegistrarReturn {
11727            fn _tokenize(
11728                &self,
11729            ) -> <setAVSRegistrarCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
11730                ()
11731            }
11732        }
11733        #[automatically_derived]
11734        impl alloy_sol_types::SolCall for setAVSRegistrarCall {
11735            type Parameters<'a> = (
11736                alloy::sol_types::sol_data::Address,
11737                alloy::sol_types::sol_data::Address,
11738            );
11739            type Token<'a> = <Self::Parameters<
11740                'a,
11741            > as alloy_sol_types::SolType>::Token<'a>;
11742            type Return = setAVSRegistrarReturn;
11743            type ReturnTuple<'a> = ();
11744            type ReturnToken<'a> = <Self::ReturnTuple<
11745                'a,
11746            > as alloy_sol_types::SolType>::Token<'a>;
11747            const SIGNATURE: &'static str = "setAVSRegistrar(address,address)";
11748            const SELECTOR: [u8; 4] = [211u8, 217u8, 111u8, 244u8];
11749            #[inline]
11750            fn new<'a>(
11751                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11752            ) -> Self {
11753                tuple.into()
11754            }
11755            #[inline]
11756            fn tokenize(&self) -> Self::Token<'_> {
11757                (
11758                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11759                        &self.avs,
11760                    ),
11761                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11762                        &self.registrar,
11763                    ),
11764                )
11765            }
11766            #[inline]
11767            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11768                setAVSRegistrarReturn::_tokenize(ret)
11769            }
11770            #[inline]
11771            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11772                <Self::ReturnTuple<
11773                    '_,
11774                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
11775                    .map(Into::into)
11776            }
11777            #[inline]
11778            fn abi_decode_returns_validate(
11779                data: &[u8],
11780            ) -> alloy_sol_types::Result<Self::Return> {
11781                <Self::ReturnTuple<
11782                    '_,
11783                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
11784                    .map(Into::into)
11785            }
11786        }
11787    };
11788    #[derive(serde::Serialize, serde::Deserialize)]
11789    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11790    /**Function with signature `setAllocationDelay(address,uint32)` and selector `0x56c483e6`.
11791```solidity
11792function setAllocationDelay(address operator, uint32 delay) external;
11793```*/
11794    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11795    #[derive(Clone)]
11796    pub struct setAllocationDelayCall {
11797        #[allow(missing_docs)]
11798        pub operator: alloy::sol_types::private::Address,
11799        #[allow(missing_docs)]
11800        pub delay: u32,
11801    }
11802    ///Container type for the return parameters of the [`setAllocationDelay(address,uint32)`](setAllocationDelayCall) function.
11803    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11804    #[derive(Clone)]
11805    pub struct setAllocationDelayReturn {}
11806    #[allow(
11807        non_camel_case_types,
11808        non_snake_case,
11809        clippy::pub_underscore_fields,
11810        clippy::style
11811    )]
11812    const _: () = {
11813        use alloy::sol_types as alloy_sol_types;
11814        {
11815            #[doc(hidden)]
11816            type UnderlyingSolTuple<'a> = (
11817                alloy::sol_types::sol_data::Address,
11818                alloy::sol_types::sol_data::Uint<32>,
11819            );
11820            #[doc(hidden)]
11821            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address, u32);
11822            #[cfg(test)]
11823            #[allow(dead_code, unreachable_patterns)]
11824            fn _type_assertion(
11825                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11826            ) {
11827                match _t {
11828                    alloy_sol_types::private::AssertTypeEq::<
11829                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11830                    >(_) => {}
11831                }
11832            }
11833            #[automatically_derived]
11834            #[doc(hidden)]
11835            impl ::core::convert::From<setAllocationDelayCall>
11836            for UnderlyingRustTuple<'_> {
11837                fn from(value: setAllocationDelayCall) -> Self {
11838                    (value.operator, value.delay)
11839                }
11840            }
11841            #[automatically_derived]
11842            #[doc(hidden)]
11843            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11844            for setAllocationDelayCall {
11845                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11846                    Self {
11847                        operator: tuple.0,
11848                        delay: tuple.1,
11849                    }
11850                }
11851            }
11852        }
11853        {
11854            #[doc(hidden)]
11855            type UnderlyingSolTuple<'a> = ();
11856            #[doc(hidden)]
11857            type UnderlyingRustTuple<'a> = ();
11858            #[cfg(test)]
11859            #[allow(dead_code, unreachable_patterns)]
11860            fn _type_assertion(
11861                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11862            ) {
11863                match _t {
11864                    alloy_sol_types::private::AssertTypeEq::<
11865                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11866                    >(_) => {}
11867                }
11868            }
11869            #[automatically_derived]
11870            #[doc(hidden)]
11871            impl ::core::convert::From<setAllocationDelayReturn>
11872            for UnderlyingRustTuple<'_> {
11873                fn from(value: setAllocationDelayReturn) -> Self {
11874                    ()
11875                }
11876            }
11877            #[automatically_derived]
11878            #[doc(hidden)]
11879            impl ::core::convert::From<UnderlyingRustTuple<'_>>
11880            for setAllocationDelayReturn {
11881                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
11882                    Self {}
11883                }
11884            }
11885        }
11886        impl setAllocationDelayReturn {
11887            fn _tokenize(
11888                &self,
11889            ) -> <setAllocationDelayCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
11890                ()
11891            }
11892        }
11893        #[automatically_derived]
11894        impl alloy_sol_types::SolCall for setAllocationDelayCall {
11895            type Parameters<'a> = (
11896                alloy::sol_types::sol_data::Address,
11897                alloy::sol_types::sol_data::Uint<32>,
11898            );
11899            type Token<'a> = <Self::Parameters<
11900                'a,
11901            > as alloy_sol_types::SolType>::Token<'a>;
11902            type Return = setAllocationDelayReturn;
11903            type ReturnTuple<'a> = ();
11904            type ReturnToken<'a> = <Self::ReturnTuple<
11905                'a,
11906            > as alloy_sol_types::SolType>::Token<'a>;
11907            const SIGNATURE: &'static str = "setAllocationDelay(address,uint32)";
11908            const SELECTOR: [u8; 4] = [86u8, 196u8, 131u8, 230u8];
11909            #[inline]
11910            fn new<'a>(
11911                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
11912            ) -> Self {
11913                tuple.into()
11914            }
11915            #[inline]
11916            fn tokenize(&self) -> Self::Token<'_> {
11917                (
11918                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
11919                        &self.operator,
11920                    ),
11921                    <alloy::sol_types::sol_data::Uint<
11922                        32,
11923                    > as alloy_sol_types::SolType>::tokenize(&self.delay),
11924                )
11925            }
11926            #[inline]
11927            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
11928                setAllocationDelayReturn::_tokenize(ret)
11929            }
11930            #[inline]
11931            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
11932                <Self::ReturnTuple<
11933                    '_,
11934                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
11935                    .map(Into::into)
11936            }
11937            #[inline]
11938            fn abi_decode_returns_validate(
11939                data: &[u8],
11940            ) -> alloy_sol_types::Result<Self::Return> {
11941                <Self::ReturnTuple<
11942                    '_,
11943                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
11944                    .map(Into::into)
11945            }
11946        }
11947    };
11948    #[derive(serde::Serialize, serde::Deserialize)]
11949    #[derive(Default, Debug, PartialEq, Eq, Hash)]
11950    /**Function with signature `slashOperator(address,(address,uint32,address[],uint256[],string))` and selector `0x36352057`.
11951```solidity
11952function slashOperator(address avs, IAllocationManagerTypes.SlashingParams memory params) external;
11953```*/
11954    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11955    #[derive(Clone)]
11956    pub struct slashOperatorCall {
11957        #[allow(missing_docs)]
11958        pub avs: alloy::sol_types::private::Address,
11959        #[allow(missing_docs)]
11960        pub params: <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
11961    }
11962    ///Container type for the return parameters of the [`slashOperator(address,(address,uint32,address[],uint256[],string))`](slashOperatorCall) function.
11963    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
11964    #[derive(Clone)]
11965    pub struct slashOperatorReturn {}
11966    #[allow(
11967        non_camel_case_types,
11968        non_snake_case,
11969        clippy::pub_underscore_fields,
11970        clippy::style
11971    )]
11972    const _: () = {
11973        use alloy::sol_types as alloy_sol_types;
11974        {
11975            #[doc(hidden)]
11976            type UnderlyingSolTuple<'a> = (
11977                alloy::sol_types::sol_data::Address,
11978                IAllocationManagerTypes::SlashingParams,
11979            );
11980            #[doc(hidden)]
11981            type UnderlyingRustTuple<'a> = (
11982                alloy::sol_types::private::Address,
11983                <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
11984            );
11985            #[cfg(test)]
11986            #[allow(dead_code, unreachable_patterns)]
11987            fn _type_assertion(
11988                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
11989            ) {
11990                match _t {
11991                    alloy_sol_types::private::AssertTypeEq::<
11992                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
11993                    >(_) => {}
11994                }
11995            }
11996            #[automatically_derived]
11997            #[doc(hidden)]
11998            impl ::core::convert::From<slashOperatorCall> for UnderlyingRustTuple<'_> {
11999                fn from(value: slashOperatorCall) -> Self {
12000                    (value.avs, value.params)
12001                }
12002            }
12003            #[automatically_derived]
12004            #[doc(hidden)]
12005            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slashOperatorCall {
12006                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12007                    Self {
12008                        avs: tuple.0,
12009                        params: tuple.1,
12010                    }
12011                }
12012            }
12013        }
12014        {
12015            #[doc(hidden)]
12016            type UnderlyingSolTuple<'a> = ();
12017            #[doc(hidden)]
12018            type UnderlyingRustTuple<'a> = ();
12019            #[cfg(test)]
12020            #[allow(dead_code, unreachable_patterns)]
12021            fn _type_assertion(
12022                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12023            ) {
12024                match _t {
12025                    alloy_sol_types::private::AssertTypeEq::<
12026                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12027                    >(_) => {}
12028                }
12029            }
12030            #[automatically_derived]
12031            #[doc(hidden)]
12032            impl ::core::convert::From<slashOperatorReturn> for UnderlyingRustTuple<'_> {
12033                fn from(value: slashOperatorReturn) -> Self {
12034                    ()
12035                }
12036            }
12037            #[automatically_derived]
12038            #[doc(hidden)]
12039            impl ::core::convert::From<UnderlyingRustTuple<'_>> for slashOperatorReturn {
12040                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12041                    Self {}
12042                }
12043            }
12044        }
12045        impl slashOperatorReturn {
12046            fn _tokenize(
12047                &self,
12048            ) -> <slashOperatorCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
12049                ()
12050            }
12051        }
12052        #[automatically_derived]
12053        impl alloy_sol_types::SolCall for slashOperatorCall {
12054            type Parameters<'a> = (
12055                alloy::sol_types::sol_data::Address,
12056                IAllocationManagerTypes::SlashingParams,
12057            );
12058            type Token<'a> = <Self::Parameters<
12059                'a,
12060            > as alloy_sol_types::SolType>::Token<'a>;
12061            type Return = slashOperatorReturn;
12062            type ReturnTuple<'a> = ();
12063            type ReturnToken<'a> = <Self::ReturnTuple<
12064                'a,
12065            > as alloy_sol_types::SolType>::Token<'a>;
12066            const SIGNATURE: &'static str = "slashOperator(address,(address,uint32,address[],uint256[],string))";
12067            const SELECTOR: [u8; 4] = [54u8, 53u8, 32u8, 87u8];
12068            #[inline]
12069            fn new<'a>(
12070                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12071            ) -> Self {
12072                tuple.into()
12073            }
12074            #[inline]
12075            fn tokenize(&self) -> Self::Token<'_> {
12076                (
12077                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
12078                        &self.avs,
12079                    ),
12080                    <IAllocationManagerTypes::SlashingParams as alloy_sol_types::SolType>::tokenize(
12081                        &self.params,
12082                    ),
12083                )
12084            }
12085            #[inline]
12086            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12087                slashOperatorReturn::_tokenize(ret)
12088            }
12089            #[inline]
12090            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12091                <Self::ReturnTuple<
12092                    '_,
12093                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
12094                    .map(Into::into)
12095            }
12096            #[inline]
12097            fn abi_decode_returns_validate(
12098                data: &[u8],
12099            ) -> alloy_sol_types::Result<Self::Return> {
12100                <Self::ReturnTuple<
12101                    '_,
12102                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
12103                    .map(Into::into)
12104            }
12105        }
12106    };
12107    #[derive(serde::Serialize, serde::Deserialize)]
12108    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12109    /**Function with signature `updateAVSMetadataURI(address,string)` and selector `0xa9821821`.
12110```solidity
12111function updateAVSMetadataURI(address avs, string memory metadataURI) external;
12112```*/
12113    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12114    #[derive(Clone)]
12115    pub struct updateAVSMetadataURICall {
12116        #[allow(missing_docs)]
12117        pub avs: alloy::sol_types::private::Address,
12118        #[allow(missing_docs)]
12119        pub metadataURI: alloy::sol_types::private::String,
12120    }
12121    ///Container type for the return parameters of the [`updateAVSMetadataURI(address,string)`](updateAVSMetadataURICall) function.
12122    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12123    #[derive(Clone)]
12124    pub struct updateAVSMetadataURIReturn {}
12125    #[allow(
12126        non_camel_case_types,
12127        non_snake_case,
12128        clippy::pub_underscore_fields,
12129        clippy::style
12130    )]
12131    const _: () = {
12132        use alloy::sol_types as alloy_sol_types;
12133        {
12134            #[doc(hidden)]
12135            type UnderlyingSolTuple<'a> = (
12136                alloy::sol_types::sol_data::Address,
12137                alloy::sol_types::sol_data::String,
12138            );
12139            #[doc(hidden)]
12140            type UnderlyingRustTuple<'a> = (
12141                alloy::sol_types::private::Address,
12142                alloy::sol_types::private::String,
12143            );
12144            #[cfg(test)]
12145            #[allow(dead_code, unreachable_patterns)]
12146            fn _type_assertion(
12147                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12148            ) {
12149                match _t {
12150                    alloy_sol_types::private::AssertTypeEq::<
12151                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12152                    >(_) => {}
12153                }
12154            }
12155            #[automatically_derived]
12156            #[doc(hidden)]
12157            impl ::core::convert::From<updateAVSMetadataURICall>
12158            for UnderlyingRustTuple<'_> {
12159                fn from(value: updateAVSMetadataURICall) -> Self {
12160                    (value.avs, value.metadataURI)
12161                }
12162            }
12163            #[automatically_derived]
12164            #[doc(hidden)]
12165            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12166            for updateAVSMetadataURICall {
12167                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12168                    Self {
12169                        avs: tuple.0,
12170                        metadataURI: tuple.1,
12171                    }
12172                }
12173            }
12174        }
12175        {
12176            #[doc(hidden)]
12177            type UnderlyingSolTuple<'a> = ();
12178            #[doc(hidden)]
12179            type UnderlyingRustTuple<'a> = ();
12180            #[cfg(test)]
12181            #[allow(dead_code, unreachable_patterns)]
12182            fn _type_assertion(
12183                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12184            ) {
12185                match _t {
12186                    alloy_sol_types::private::AssertTypeEq::<
12187                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12188                    >(_) => {}
12189                }
12190            }
12191            #[automatically_derived]
12192            #[doc(hidden)]
12193            impl ::core::convert::From<updateAVSMetadataURIReturn>
12194            for UnderlyingRustTuple<'_> {
12195                fn from(value: updateAVSMetadataURIReturn) -> Self {
12196                    ()
12197                }
12198            }
12199            #[automatically_derived]
12200            #[doc(hidden)]
12201            impl ::core::convert::From<UnderlyingRustTuple<'_>>
12202            for updateAVSMetadataURIReturn {
12203                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12204                    Self {}
12205                }
12206            }
12207        }
12208        impl updateAVSMetadataURIReturn {
12209            fn _tokenize(
12210                &self,
12211            ) -> <updateAVSMetadataURICall as alloy_sol_types::SolCall>::ReturnToken<
12212                '_,
12213            > {
12214                ()
12215            }
12216        }
12217        #[automatically_derived]
12218        impl alloy_sol_types::SolCall for updateAVSMetadataURICall {
12219            type Parameters<'a> = (
12220                alloy::sol_types::sol_data::Address,
12221                alloy::sol_types::sol_data::String,
12222            );
12223            type Token<'a> = <Self::Parameters<
12224                'a,
12225            > as alloy_sol_types::SolType>::Token<'a>;
12226            type Return = updateAVSMetadataURIReturn;
12227            type ReturnTuple<'a> = ();
12228            type ReturnToken<'a> = <Self::ReturnTuple<
12229                'a,
12230            > as alloy_sol_types::SolType>::Token<'a>;
12231            const SIGNATURE: &'static str = "updateAVSMetadataURI(address,string)";
12232            const SELECTOR: [u8; 4] = [169u8, 130u8, 24u8, 33u8];
12233            #[inline]
12234            fn new<'a>(
12235                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12236            ) -> Self {
12237                tuple.into()
12238            }
12239            #[inline]
12240            fn tokenize(&self) -> Self::Token<'_> {
12241                (
12242                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
12243                        &self.avs,
12244                    ),
12245                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
12246                        &self.metadataURI,
12247                    ),
12248                )
12249            }
12250            #[inline]
12251            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12252                updateAVSMetadataURIReturn::_tokenize(ret)
12253            }
12254            #[inline]
12255            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12256                <Self::ReturnTuple<
12257                    '_,
12258                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
12259                    .map(Into::into)
12260            }
12261            #[inline]
12262            fn abi_decode_returns_validate(
12263                data: &[u8],
12264            ) -> alloy_sol_types::Result<Self::Return> {
12265                <Self::ReturnTuple<
12266                    '_,
12267                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
12268                    .map(Into::into)
12269            }
12270        }
12271    };
12272    #[derive(serde::Serialize, serde::Deserialize)]
12273    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12274    /**Function with signature `version()` and selector `0x54fd4d50`.
12275```solidity
12276function version() external view returns (string memory);
12277```*/
12278    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12279    #[derive(Clone)]
12280    pub struct versionCall;
12281    #[derive(serde::Serialize, serde::Deserialize)]
12282    #[derive(Default, Debug, PartialEq, Eq, Hash)]
12283    ///Container type for the return parameters of the [`version()`](versionCall) function.
12284    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
12285    #[derive(Clone)]
12286    pub struct versionReturn {
12287        #[allow(missing_docs)]
12288        pub _0: alloy::sol_types::private::String,
12289    }
12290    #[allow(
12291        non_camel_case_types,
12292        non_snake_case,
12293        clippy::pub_underscore_fields,
12294        clippy::style
12295    )]
12296    const _: () = {
12297        use alloy::sol_types as alloy_sol_types;
12298        {
12299            #[doc(hidden)]
12300            type UnderlyingSolTuple<'a> = ();
12301            #[doc(hidden)]
12302            type UnderlyingRustTuple<'a> = ();
12303            #[cfg(test)]
12304            #[allow(dead_code, unreachable_patterns)]
12305            fn _type_assertion(
12306                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12307            ) {
12308                match _t {
12309                    alloy_sol_types::private::AssertTypeEq::<
12310                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12311                    >(_) => {}
12312                }
12313            }
12314            #[automatically_derived]
12315            #[doc(hidden)]
12316            impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
12317                fn from(value: versionCall) -> Self {
12318                    ()
12319                }
12320            }
12321            #[automatically_derived]
12322            #[doc(hidden)]
12323            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
12324                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12325                    Self
12326                }
12327            }
12328        }
12329        {
12330            #[doc(hidden)]
12331            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
12332            #[doc(hidden)]
12333            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
12334            #[cfg(test)]
12335            #[allow(dead_code, unreachable_patterns)]
12336            fn _type_assertion(
12337                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
12338            ) {
12339                match _t {
12340                    alloy_sol_types::private::AssertTypeEq::<
12341                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
12342                    >(_) => {}
12343                }
12344            }
12345            #[automatically_derived]
12346            #[doc(hidden)]
12347            impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
12348                fn from(value: versionReturn) -> Self {
12349                    (value._0,)
12350                }
12351            }
12352            #[automatically_derived]
12353            #[doc(hidden)]
12354            impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
12355                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
12356                    Self { _0: tuple.0 }
12357                }
12358            }
12359        }
12360        #[automatically_derived]
12361        impl alloy_sol_types::SolCall for versionCall {
12362            type Parameters<'a> = ();
12363            type Token<'a> = <Self::Parameters<
12364                'a,
12365            > as alloy_sol_types::SolType>::Token<'a>;
12366            type Return = alloy::sol_types::private::String;
12367            type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
12368            type ReturnToken<'a> = <Self::ReturnTuple<
12369                'a,
12370            > as alloy_sol_types::SolType>::Token<'a>;
12371            const SIGNATURE: &'static str = "version()";
12372            const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
12373            #[inline]
12374            fn new<'a>(
12375                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
12376            ) -> Self {
12377                tuple.into()
12378            }
12379            #[inline]
12380            fn tokenize(&self) -> Self::Token<'_> {
12381                ()
12382            }
12383            #[inline]
12384            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
12385                (
12386                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
12387                        ret,
12388                    ),
12389                )
12390            }
12391            #[inline]
12392            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
12393                <Self::ReturnTuple<
12394                    '_,
12395                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
12396                    .map(|r| {
12397                        let r: versionReturn = r.into();
12398                        r._0
12399                    })
12400            }
12401            #[inline]
12402            fn abi_decode_returns_validate(
12403                data: &[u8],
12404            ) -> alloy_sol_types::Result<Self::Return> {
12405                <Self::ReturnTuple<
12406                    '_,
12407                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
12408                    .map(|r| {
12409                        let r: versionReturn = r.into();
12410                        r._0
12411                    })
12412            }
12413        }
12414    };
12415    ///Container for all the [`IAllocationManager`](self) function calls.
12416    #[derive(serde::Serialize, serde::Deserialize)]
12417    #[derive()]
12418    pub enum IAllocationManagerCalls {
12419        #[allow(missing_docs)]
12420        addStrategiesToOperatorSet(addStrategiesToOperatorSetCall),
12421        #[allow(missing_docs)]
12422        clearDeallocationQueue(clearDeallocationQueueCall),
12423        #[allow(missing_docs)]
12424        createOperatorSets(createOperatorSetsCall),
12425        #[allow(missing_docs)]
12426        deregisterFromOperatorSets(deregisterFromOperatorSetsCall),
12427        #[allow(missing_docs)]
12428        getAVSRegistrar(getAVSRegistrarCall),
12429        #[allow(missing_docs)]
12430        getAllocatableMagnitude(getAllocatableMagnitudeCall),
12431        #[allow(missing_docs)]
12432        getAllocatedSets(getAllocatedSetsCall),
12433        #[allow(missing_docs)]
12434        getAllocatedStake(getAllocatedStakeCall),
12435        #[allow(missing_docs)]
12436        getAllocatedStrategies(getAllocatedStrategiesCall),
12437        #[allow(missing_docs)]
12438        getAllocation(getAllocationCall),
12439        #[allow(missing_docs)]
12440        getAllocationDelay(getAllocationDelayCall),
12441        #[allow(missing_docs)]
12442        getAllocations(getAllocationsCall),
12443        #[allow(missing_docs)]
12444        getEncumberedMagnitude(getEncumberedMagnitudeCall),
12445        #[allow(missing_docs)]
12446        getMaxMagnitude(getMaxMagnitudeCall),
12447        #[allow(missing_docs)]
12448        getMaxMagnitudes_0(getMaxMagnitudes_0Call),
12449        #[allow(missing_docs)]
12450        getMaxMagnitudes_1(getMaxMagnitudes_1Call),
12451        #[allow(missing_docs)]
12452        getMaxMagnitudesAtBlock(getMaxMagnitudesAtBlockCall),
12453        #[allow(missing_docs)]
12454        getMemberCount(getMemberCountCall),
12455        #[allow(missing_docs)]
12456        getMembers(getMembersCall),
12457        #[allow(missing_docs)]
12458        getMinimumSlashableStake(getMinimumSlashableStakeCall),
12459        #[allow(missing_docs)]
12460        getOperatorSetCount(getOperatorSetCountCall),
12461        #[allow(missing_docs)]
12462        getRegisteredSets(getRegisteredSetsCall),
12463        #[allow(missing_docs)]
12464        getStrategiesInOperatorSet(getStrategiesInOperatorSetCall),
12465        #[allow(missing_docs)]
12466        getStrategyAllocations(getStrategyAllocationsCall),
12467        #[allow(missing_docs)]
12468        initialize(initializeCall),
12469        #[allow(missing_docs)]
12470        isMemberOfOperatorSet(isMemberOfOperatorSetCall),
12471        #[allow(missing_docs)]
12472        isOperatorSet(isOperatorSetCall),
12473        #[allow(missing_docs)]
12474        isOperatorSlashable(isOperatorSlashableCall),
12475        #[allow(missing_docs)]
12476        modifyAllocations(modifyAllocationsCall),
12477        #[allow(missing_docs)]
12478        registerForOperatorSets(registerForOperatorSetsCall),
12479        #[allow(missing_docs)]
12480        removeStrategiesFromOperatorSet(removeStrategiesFromOperatorSetCall),
12481        #[allow(missing_docs)]
12482        setAVSRegistrar(setAVSRegistrarCall),
12483        #[allow(missing_docs)]
12484        setAllocationDelay(setAllocationDelayCall),
12485        #[allow(missing_docs)]
12486        slashOperator(slashOperatorCall),
12487        #[allow(missing_docs)]
12488        updateAVSMetadataURI(updateAVSMetadataURICall),
12489        #[allow(missing_docs)]
12490        version(versionCall),
12491    }
12492    #[automatically_derived]
12493    impl IAllocationManagerCalls {
12494        /// All the selectors of this enum.
12495        ///
12496        /// Note that the selectors might not be in the same order as the variants.
12497        /// No guarantees are made about the order of the selectors.
12498        ///
12499        /// Prefer using `SolInterface` methods instead.
12500        pub const SELECTORS: &'static [[u8; 4usize]] = &[
12501            [16u8, 225u8, 185u8, 184u8],
12502            [19u8, 82u8, 195u8, 230u8],
12503            [21u8, 254u8, 80u8, 40u8],
12504            [38u8, 13u8, 199u8, 88u8],
12505            [38u8, 31u8, 132u8, 224u8],
12506            [43u8, 69u8, 58u8, 154u8],
12507            [43u8, 171u8, 44u8, 74u8],
12508            [48u8, 76u8, 16u8, 205u8],
12509            [54u8, 53u8, 32u8, 87u8],
12510            [64u8, 18u8, 13u8, 171u8],
12511            [65u8, 119u8, 168u8, 124u8],
12512            [74u8, 16u8, 255u8, 229u8],
12513            [75u8, 80u8, 70u8, 239u8],
12514            [80u8, 254u8, 234u8, 32u8],
12515            [84u8, 122u8, 251u8, 135u8],
12516            [84u8, 253u8, 77u8, 80u8],
12517            [86u8, 196u8, 131u8, 230u8],
12518            [103u8, 13u8, 59u8, 162u8],
12519            [108u8, 251u8, 68u8, 129u8],
12520            [110u8, 52u8, 146u8, 181u8],
12521            [110u8, 135u8, 93u8, 186u8],
12522            [121u8, 174u8, 80u8, 205u8],
12523            [140u8, 230u8, 72u8, 84u8],
12524            [148u8, 215u8, 208u8, 12u8],
12525            [149u8, 40u8, 153u8, 238u8],
12526            [169u8, 51u8, 62u8, 200u8],
12527            [169u8, 130u8, 24u8, 33u8],
12528            [173u8, 194u8, 227u8, 217u8],
12529            [178u8, 68u8, 122u8, 247u8],
12530            [182u8, 107u8, 217u8, 137u8],
12531            [185u8, 251u8, 174u8, 209u8],
12532            [186u8, 26u8, 132u8, 229u8],
12533            [194u8, 33u8, 216u8, 174u8],
12534            [205u8, 109u8, 198u8, 135u8],
12535            [211u8, 217u8, 111u8, 244u8],
12536            [246u8, 5u8, 206u8, 8u8],
12537        ];
12538    }
12539    #[automatically_derived]
12540    impl alloy_sol_types::SolInterface for IAllocationManagerCalls {
12541        const NAME: &'static str = "IAllocationManagerCalls";
12542        const MIN_DATA_LENGTH: usize = 0usize;
12543        const COUNT: usize = 36usize;
12544        #[inline]
12545        fn selector(&self) -> [u8; 4] {
12546            match self {
12547                Self::addStrategiesToOperatorSet(_) => {
12548                    <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
12549                }
12550                Self::clearDeallocationQueue(_) => {
12551                    <clearDeallocationQueueCall as alloy_sol_types::SolCall>::SELECTOR
12552                }
12553                Self::createOperatorSets(_) => {
12554                    <createOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
12555                }
12556                Self::deregisterFromOperatorSets(_) => {
12557                    <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
12558                }
12559                Self::getAVSRegistrar(_) => {
12560                    <getAVSRegistrarCall as alloy_sol_types::SolCall>::SELECTOR
12561                }
12562                Self::getAllocatableMagnitude(_) => {
12563                    <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::SELECTOR
12564                }
12565                Self::getAllocatedSets(_) => {
12566                    <getAllocatedSetsCall as alloy_sol_types::SolCall>::SELECTOR
12567                }
12568                Self::getAllocatedStake(_) => {
12569                    <getAllocatedStakeCall as alloy_sol_types::SolCall>::SELECTOR
12570                }
12571                Self::getAllocatedStrategies(_) => {
12572                    <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::SELECTOR
12573                }
12574                Self::getAllocation(_) => {
12575                    <getAllocationCall as alloy_sol_types::SolCall>::SELECTOR
12576                }
12577                Self::getAllocationDelay(_) => {
12578                    <getAllocationDelayCall as alloy_sol_types::SolCall>::SELECTOR
12579                }
12580                Self::getAllocations(_) => {
12581                    <getAllocationsCall as alloy_sol_types::SolCall>::SELECTOR
12582                }
12583                Self::getEncumberedMagnitude(_) => {
12584                    <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::SELECTOR
12585                }
12586                Self::getMaxMagnitude(_) => {
12587                    <getMaxMagnitudeCall as alloy_sol_types::SolCall>::SELECTOR
12588                }
12589                Self::getMaxMagnitudes_0(_) => {
12590                    <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::SELECTOR
12591                }
12592                Self::getMaxMagnitudes_1(_) => {
12593                    <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::SELECTOR
12594                }
12595                Self::getMaxMagnitudesAtBlock(_) => {
12596                    <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::SELECTOR
12597                }
12598                Self::getMemberCount(_) => {
12599                    <getMemberCountCall as alloy_sol_types::SolCall>::SELECTOR
12600                }
12601                Self::getMembers(_) => {
12602                    <getMembersCall as alloy_sol_types::SolCall>::SELECTOR
12603                }
12604                Self::getMinimumSlashableStake(_) => {
12605                    <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::SELECTOR
12606                }
12607                Self::getOperatorSetCount(_) => {
12608                    <getOperatorSetCountCall as alloy_sol_types::SolCall>::SELECTOR
12609                }
12610                Self::getRegisteredSets(_) => {
12611                    <getRegisteredSetsCall as alloy_sol_types::SolCall>::SELECTOR
12612                }
12613                Self::getStrategiesInOperatorSet(_) => {
12614                    <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
12615                }
12616                Self::getStrategyAllocations(_) => {
12617                    <getStrategyAllocationsCall as alloy_sol_types::SolCall>::SELECTOR
12618                }
12619                Self::initialize(_) => {
12620                    <initializeCall as alloy_sol_types::SolCall>::SELECTOR
12621                }
12622                Self::isMemberOfOperatorSet(_) => {
12623                    <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
12624                }
12625                Self::isOperatorSet(_) => {
12626                    <isOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
12627                }
12628                Self::isOperatorSlashable(_) => {
12629                    <isOperatorSlashableCall as alloy_sol_types::SolCall>::SELECTOR
12630                }
12631                Self::modifyAllocations(_) => {
12632                    <modifyAllocationsCall as alloy_sol_types::SolCall>::SELECTOR
12633                }
12634                Self::registerForOperatorSets(_) => {
12635                    <registerForOperatorSetsCall as alloy_sol_types::SolCall>::SELECTOR
12636                }
12637                Self::removeStrategiesFromOperatorSet(_) => {
12638                    <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::SELECTOR
12639                }
12640                Self::setAVSRegistrar(_) => {
12641                    <setAVSRegistrarCall as alloy_sol_types::SolCall>::SELECTOR
12642                }
12643                Self::setAllocationDelay(_) => {
12644                    <setAllocationDelayCall as alloy_sol_types::SolCall>::SELECTOR
12645                }
12646                Self::slashOperator(_) => {
12647                    <slashOperatorCall as alloy_sol_types::SolCall>::SELECTOR
12648                }
12649                Self::updateAVSMetadataURI(_) => {
12650                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::SELECTOR
12651                }
12652                Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
12653            }
12654        }
12655        #[inline]
12656        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
12657            Self::SELECTORS.get(i).copied()
12658        }
12659        #[inline]
12660        fn valid_selector(selector: [u8; 4]) -> bool {
12661            Self::SELECTORS.binary_search(&selector).is_ok()
12662        }
12663        #[inline]
12664        #[allow(non_snake_case)]
12665        fn abi_decode_raw(
12666            selector: [u8; 4],
12667            data: &[u8],
12668        ) -> alloy_sol_types::Result<Self> {
12669            static DECODE_SHIMS: &[fn(
12670                &[u8],
12671            ) -> alloy_sol_types::Result<IAllocationManagerCalls>] = &[
12672                {
12673                    fn getAllocation(
12674                        data: &[u8],
12675                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12676                        <getAllocationCall as alloy_sol_types::SolCall>::abi_decode_raw(
12677                                data,
12678                            )
12679                            .map(IAllocationManagerCalls::getAllocation)
12680                    }
12681                    getAllocation
12682                },
12683                {
12684                    fn isOperatorSlashable(
12685                        data: &[u8],
12686                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12687                        <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_decode_raw(
12688                                data,
12689                            )
12690                            .map(IAllocationManagerCalls::isOperatorSlashable)
12691                    }
12692                    isOperatorSlashable
12693                },
12694                {
12695                    fn getAllocatedSets(
12696                        data: &[u8],
12697                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12698                        <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12699                                data,
12700                            )
12701                            .map(IAllocationManagerCalls::getAllocatedSets)
12702                    }
12703                    getAllocatedSets
12704                },
12705                {
12706                    fn isOperatorSet(
12707                        data: &[u8],
12708                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12709                        <isOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
12710                                data,
12711                            )
12712                            .map(IAllocationManagerCalls::isOperatorSet)
12713                    }
12714                    isOperatorSet
12715                },
12716                {
12717                    fn createOperatorSets(
12718                        data: &[u8],
12719                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12720                        <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12721                                data,
12722                            )
12723                            .map(IAllocationManagerCalls::createOperatorSets)
12724                    }
12725                    createOperatorSets
12726                },
12727                {
12728                    fn getAllocatedStake(
12729                        data: &[u8],
12730                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12731                        <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_decode_raw(
12732                                data,
12733                            )
12734                            .map(IAllocationManagerCalls::getAllocatedStake)
12735                    }
12736                    getAllocatedStake
12737                },
12738                {
12739                    fn getMinimumSlashableStake(
12740                        data: &[u8],
12741                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12742                        <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_decode_raw(
12743                                data,
12744                            )
12745                            .map(IAllocationManagerCalls::getMinimumSlashableStake)
12746                    }
12747                    getMinimumSlashableStake
12748                },
12749                {
12750                    fn getAVSRegistrar(
12751                        data: &[u8],
12752                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12753                        <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw(
12754                                data,
12755                            )
12756                            .map(IAllocationManagerCalls::getAVSRegistrar)
12757                    }
12758                    getAVSRegistrar
12759                },
12760                {
12761                    fn slashOperator(
12762                        data: &[u8],
12763                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12764                        <slashOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
12765                                data,
12766                            )
12767                            .map(IAllocationManagerCalls::slashOperator)
12768                    }
12769                    slashOperator
12770                },
12771                {
12772                    fn getStrategyAllocations(
12773                        data: &[u8],
12774                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12775                        <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12776                                data,
12777                            )
12778                            .map(IAllocationManagerCalls::getStrategyAllocations)
12779                    }
12780                    getStrategyAllocations
12781                },
12782                {
12783                    fn getStrategiesInOperatorSet(
12784                        data: &[u8],
12785                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12786                        <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
12787                                data,
12788                            )
12789                            .map(IAllocationManagerCalls::getStrategiesInOperatorSet)
12790                    }
12791                    getStrategiesInOperatorSet
12792                },
12793                {
12794                    fn getMaxMagnitudes_0(
12795                        data: &[u8],
12796                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12797                        <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_decode_raw(
12798                                data,
12799                            )
12800                            .map(IAllocationManagerCalls::getMaxMagnitudes_0)
12801                    }
12802                    getMaxMagnitudes_0
12803                },
12804                {
12805                    fn clearDeallocationQueue(
12806                        data: &[u8],
12807                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12808                        <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_decode_raw(
12809                                data,
12810                            )
12811                            .map(IAllocationManagerCalls::clearDeallocationQueue)
12812                    }
12813                    clearDeallocationQueue
12814                },
12815                {
12816                    fn addStrategiesToOperatorSet(
12817                        data: &[u8],
12818                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12819                        <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
12820                                data,
12821                            )
12822                            .map(IAllocationManagerCalls::addStrategiesToOperatorSet)
12823                    }
12824                    addStrategiesToOperatorSet
12825                },
12826                {
12827                    fn getMaxMagnitudes_1(
12828                        data: &[u8],
12829                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12830                        <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_decode_raw(
12831                                data,
12832                            )
12833                            .map(IAllocationManagerCalls::getMaxMagnitudes_1)
12834                    }
12835                    getMaxMagnitudes_1
12836                },
12837                {
12838                    fn version(
12839                        data: &[u8],
12840                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12841                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
12842                            .map(IAllocationManagerCalls::version)
12843                    }
12844                    version
12845                },
12846                {
12847                    fn setAllocationDelay(
12848                        data: &[u8],
12849                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12850                        <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
12851                                data,
12852                            )
12853                            .map(IAllocationManagerCalls::setAllocationDelay)
12854                    }
12855                    setAllocationDelay
12856                },
12857                {
12858                    fn isMemberOfOperatorSet(
12859                        data: &[u8],
12860                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12861                        <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
12862                                data,
12863                            )
12864                            .map(IAllocationManagerCalls::isMemberOfOperatorSet)
12865                    }
12866                    isMemberOfOperatorSet
12867                },
12868                {
12869                    fn getAllocatableMagnitude(
12870                        data: &[u8],
12871                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12872                        <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw(
12873                                data,
12874                            )
12875                            .map(IAllocationManagerCalls::getAllocatableMagnitude)
12876                    }
12877                    getAllocatableMagnitude
12878                },
12879                {
12880                    fn deregisterFromOperatorSets(
12881                        data: &[u8],
12882                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12883                        <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12884                                data,
12885                            )
12886                            .map(IAllocationManagerCalls::deregisterFromOperatorSets)
12887                    }
12888                    deregisterFromOperatorSets
12889                },
12890                {
12891                    fn getMembers(
12892                        data: &[u8],
12893                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12894                        <getMembersCall as alloy_sol_types::SolCall>::abi_decode_raw(
12895                                data,
12896                            )
12897                            .map(IAllocationManagerCalls::getMembers)
12898                    }
12899                    getMembers
12900                },
12901                {
12902                    fn getRegisteredSets(
12903                        data: &[u8],
12904                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12905                        <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12906                                data,
12907                            )
12908                            .map(IAllocationManagerCalls::getRegisteredSets)
12909                    }
12910                    getRegisteredSets
12911                },
12912                {
12913                    fn getAllocations(
12914                        data: &[u8],
12915                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12916                        <getAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12917                                data,
12918                            )
12919                            .map(IAllocationManagerCalls::getAllocations)
12920                    }
12921                    getAllocations
12922                },
12923                {
12924                    fn getMaxMagnitudesAtBlock(
12925                        data: &[u8],
12926                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12927                        <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
12928                                data,
12929                            )
12930                            .map(IAllocationManagerCalls::getMaxMagnitudesAtBlock)
12931                    }
12932                    getMaxMagnitudesAtBlock
12933                },
12934                {
12935                    fn modifyAllocations(
12936                        data: &[u8],
12937                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12938                        <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12939                                data,
12940                            )
12941                            .map(IAllocationManagerCalls::modifyAllocations)
12942                    }
12943                    modifyAllocations
12944                },
12945                {
12946                    fn getMaxMagnitude(
12947                        data: &[u8],
12948                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12949                        <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw(
12950                                data,
12951                            )
12952                            .map(IAllocationManagerCalls::getMaxMagnitude)
12953                    }
12954                    getMaxMagnitude
12955                },
12956                {
12957                    fn updateAVSMetadataURI(
12958                        data: &[u8],
12959                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12960                        <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw(
12961                                data,
12962                            )
12963                            .map(IAllocationManagerCalls::updateAVSMetadataURI)
12964                    }
12965                    updateAVSMetadataURI
12966                },
12967                {
12968                    fn registerForOperatorSets(
12969                        data: &[u8],
12970                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12971                        <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw(
12972                                data,
12973                            )
12974                            .map(IAllocationManagerCalls::registerForOperatorSets)
12975                    }
12976                    registerForOperatorSets
12977                },
12978                {
12979                    fn getMemberCount(
12980                        data: &[u8],
12981                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12982                        <getMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
12983                                data,
12984                            )
12985                            .map(IAllocationManagerCalls::getMemberCount)
12986                    }
12987                    getMemberCount
12988                },
12989                {
12990                    fn removeStrategiesFromOperatorSet(
12991                        data: &[u8],
12992                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
12993                        <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw(
12994                                data,
12995                            )
12996                            .map(
12997                                IAllocationManagerCalls::removeStrategiesFromOperatorSet,
12998                            )
12999                    }
13000                    removeStrategiesFromOperatorSet
13001                },
13002                {
13003                    fn getAllocationDelay(
13004                        data: &[u8],
13005                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13006                        <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw(
13007                                data,
13008                            )
13009                            .map(IAllocationManagerCalls::getAllocationDelay)
13010                    }
13011                    getAllocationDelay
13012                },
13013                {
13014                    fn getOperatorSetCount(
13015                        data: &[u8],
13016                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13017                        <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_decode_raw(
13018                                data,
13019                            )
13020                            .map(IAllocationManagerCalls::getOperatorSetCount)
13021                    }
13022                    getOperatorSetCount
13023                },
13024                {
13025                    fn getAllocatedStrategies(
13026                        data: &[u8],
13027                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13028                        <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw(
13029                                data,
13030                            )
13031                            .map(IAllocationManagerCalls::getAllocatedStrategies)
13032                    }
13033                    getAllocatedStrategies
13034                },
13035                {
13036                    fn initialize(
13037                        data: &[u8],
13038                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13039                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw(
13040                                data,
13041                            )
13042                            .map(IAllocationManagerCalls::initialize)
13043                    }
13044                    initialize
13045                },
13046                {
13047                    fn setAVSRegistrar(
13048                        data: &[u8],
13049                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13050                        <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw(
13051                                data,
13052                            )
13053                            .map(IAllocationManagerCalls::setAVSRegistrar)
13054                    }
13055                    setAVSRegistrar
13056                },
13057                {
13058                    fn getEncumberedMagnitude(
13059                        data: &[u8],
13060                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13061                        <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw(
13062                                data,
13063                            )
13064                            .map(IAllocationManagerCalls::getEncumberedMagnitude)
13065                    }
13066                    getEncumberedMagnitude
13067                },
13068            ];
13069            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
13070                return Err(
13071                    alloy_sol_types::Error::unknown_selector(
13072                        <Self as alloy_sol_types::SolInterface>::NAME,
13073                        selector,
13074                    ),
13075                );
13076            };
13077            DECODE_SHIMS[idx](data)
13078        }
13079        #[inline]
13080        #[allow(non_snake_case)]
13081        fn abi_decode_raw_validate(
13082            selector: [u8; 4],
13083            data: &[u8],
13084        ) -> alloy_sol_types::Result<Self> {
13085            static DECODE_VALIDATE_SHIMS: &[fn(
13086                &[u8],
13087            ) -> alloy_sol_types::Result<IAllocationManagerCalls>] = &[
13088                {
13089                    fn getAllocation(
13090                        data: &[u8],
13091                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13092                        <getAllocationCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13093                                data,
13094                            )
13095                            .map(IAllocationManagerCalls::getAllocation)
13096                    }
13097                    getAllocation
13098                },
13099                {
13100                    fn isOperatorSlashable(
13101                        data: &[u8],
13102                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13103                        <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13104                                data,
13105                            )
13106                            .map(IAllocationManagerCalls::isOperatorSlashable)
13107                    }
13108                    isOperatorSlashable
13109                },
13110                {
13111                    fn getAllocatedSets(
13112                        data: &[u8],
13113                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13114                        <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13115                                data,
13116                            )
13117                            .map(IAllocationManagerCalls::getAllocatedSets)
13118                    }
13119                    getAllocatedSets
13120                },
13121                {
13122                    fn isOperatorSet(
13123                        data: &[u8],
13124                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13125                        <isOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13126                                data,
13127                            )
13128                            .map(IAllocationManagerCalls::isOperatorSet)
13129                    }
13130                    isOperatorSet
13131                },
13132                {
13133                    fn createOperatorSets(
13134                        data: &[u8],
13135                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13136                        <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13137                                data,
13138                            )
13139                            .map(IAllocationManagerCalls::createOperatorSets)
13140                    }
13141                    createOperatorSets
13142                },
13143                {
13144                    fn getAllocatedStake(
13145                        data: &[u8],
13146                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13147                        <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13148                                data,
13149                            )
13150                            .map(IAllocationManagerCalls::getAllocatedStake)
13151                    }
13152                    getAllocatedStake
13153                },
13154                {
13155                    fn getMinimumSlashableStake(
13156                        data: &[u8],
13157                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13158                        <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13159                                data,
13160                            )
13161                            .map(IAllocationManagerCalls::getMinimumSlashableStake)
13162                    }
13163                    getMinimumSlashableStake
13164                },
13165                {
13166                    fn getAVSRegistrar(
13167                        data: &[u8],
13168                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13169                        <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13170                                data,
13171                            )
13172                            .map(IAllocationManagerCalls::getAVSRegistrar)
13173                    }
13174                    getAVSRegistrar
13175                },
13176                {
13177                    fn slashOperator(
13178                        data: &[u8],
13179                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13180                        <slashOperatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13181                                data,
13182                            )
13183                            .map(IAllocationManagerCalls::slashOperator)
13184                    }
13185                    slashOperator
13186                },
13187                {
13188                    fn getStrategyAllocations(
13189                        data: &[u8],
13190                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13191                        <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13192                                data,
13193                            )
13194                            .map(IAllocationManagerCalls::getStrategyAllocations)
13195                    }
13196                    getStrategyAllocations
13197                },
13198                {
13199                    fn getStrategiesInOperatorSet(
13200                        data: &[u8],
13201                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13202                        <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13203                                data,
13204                            )
13205                            .map(IAllocationManagerCalls::getStrategiesInOperatorSet)
13206                    }
13207                    getStrategiesInOperatorSet
13208                },
13209                {
13210                    fn getMaxMagnitudes_0(
13211                        data: &[u8],
13212                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13213                        <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13214                                data,
13215                            )
13216                            .map(IAllocationManagerCalls::getMaxMagnitudes_0)
13217                    }
13218                    getMaxMagnitudes_0
13219                },
13220                {
13221                    fn clearDeallocationQueue(
13222                        data: &[u8],
13223                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13224                        <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13225                                data,
13226                            )
13227                            .map(IAllocationManagerCalls::clearDeallocationQueue)
13228                    }
13229                    clearDeallocationQueue
13230                },
13231                {
13232                    fn addStrategiesToOperatorSet(
13233                        data: &[u8],
13234                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13235                        <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13236                                data,
13237                            )
13238                            .map(IAllocationManagerCalls::addStrategiesToOperatorSet)
13239                    }
13240                    addStrategiesToOperatorSet
13241                },
13242                {
13243                    fn getMaxMagnitudes_1(
13244                        data: &[u8],
13245                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13246                        <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13247                                data,
13248                            )
13249                            .map(IAllocationManagerCalls::getMaxMagnitudes_1)
13250                    }
13251                    getMaxMagnitudes_1
13252                },
13253                {
13254                    fn version(
13255                        data: &[u8],
13256                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13257                        <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13258                                data,
13259                            )
13260                            .map(IAllocationManagerCalls::version)
13261                    }
13262                    version
13263                },
13264                {
13265                    fn setAllocationDelay(
13266                        data: &[u8],
13267                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13268                        <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13269                                data,
13270                            )
13271                            .map(IAllocationManagerCalls::setAllocationDelay)
13272                    }
13273                    setAllocationDelay
13274                },
13275                {
13276                    fn isMemberOfOperatorSet(
13277                        data: &[u8],
13278                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13279                        <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13280                                data,
13281                            )
13282                            .map(IAllocationManagerCalls::isMemberOfOperatorSet)
13283                    }
13284                    isMemberOfOperatorSet
13285                },
13286                {
13287                    fn getAllocatableMagnitude(
13288                        data: &[u8],
13289                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13290                        <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13291                                data,
13292                            )
13293                            .map(IAllocationManagerCalls::getAllocatableMagnitude)
13294                    }
13295                    getAllocatableMagnitude
13296                },
13297                {
13298                    fn deregisterFromOperatorSets(
13299                        data: &[u8],
13300                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13301                        <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13302                                data,
13303                            )
13304                            .map(IAllocationManagerCalls::deregisterFromOperatorSets)
13305                    }
13306                    deregisterFromOperatorSets
13307                },
13308                {
13309                    fn getMembers(
13310                        data: &[u8],
13311                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13312                        <getMembersCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13313                                data,
13314                            )
13315                            .map(IAllocationManagerCalls::getMembers)
13316                    }
13317                    getMembers
13318                },
13319                {
13320                    fn getRegisteredSets(
13321                        data: &[u8],
13322                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13323                        <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13324                                data,
13325                            )
13326                            .map(IAllocationManagerCalls::getRegisteredSets)
13327                    }
13328                    getRegisteredSets
13329                },
13330                {
13331                    fn getAllocations(
13332                        data: &[u8],
13333                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13334                        <getAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13335                                data,
13336                            )
13337                            .map(IAllocationManagerCalls::getAllocations)
13338                    }
13339                    getAllocations
13340                },
13341                {
13342                    fn getMaxMagnitudesAtBlock(
13343                        data: &[u8],
13344                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13345                        <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13346                                data,
13347                            )
13348                            .map(IAllocationManagerCalls::getMaxMagnitudesAtBlock)
13349                    }
13350                    getMaxMagnitudesAtBlock
13351                },
13352                {
13353                    fn modifyAllocations(
13354                        data: &[u8],
13355                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13356                        <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13357                                data,
13358                            )
13359                            .map(IAllocationManagerCalls::modifyAllocations)
13360                    }
13361                    modifyAllocations
13362                },
13363                {
13364                    fn getMaxMagnitude(
13365                        data: &[u8],
13366                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13367                        <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13368                                data,
13369                            )
13370                            .map(IAllocationManagerCalls::getMaxMagnitude)
13371                    }
13372                    getMaxMagnitude
13373                },
13374                {
13375                    fn updateAVSMetadataURI(
13376                        data: &[u8],
13377                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13378                        <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13379                                data,
13380                            )
13381                            .map(IAllocationManagerCalls::updateAVSMetadataURI)
13382                    }
13383                    updateAVSMetadataURI
13384                },
13385                {
13386                    fn registerForOperatorSets(
13387                        data: &[u8],
13388                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13389                        <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13390                                data,
13391                            )
13392                            .map(IAllocationManagerCalls::registerForOperatorSets)
13393                    }
13394                    registerForOperatorSets
13395                },
13396                {
13397                    fn getMemberCount(
13398                        data: &[u8],
13399                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13400                        <getMemberCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13401                                data,
13402                            )
13403                            .map(IAllocationManagerCalls::getMemberCount)
13404                    }
13405                    getMemberCount
13406                },
13407                {
13408                    fn removeStrategiesFromOperatorSet(
13409                        data: &[u8],
13410                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13411                        <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13412                                data,
13413                            )
13414                            .map(
13415                                IAllocationManagerCalls::removeStrategiesFromOperatorSet,
13416                            )
13417                    }
13418                    removeStrategiesFromOperatorSet
13419                },
13420                {
13421                    fn getAllocationDelay(
13422                        data: &[u8],
13423                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13424                        <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13425                                data,
13426                            )
13427                            .map(IAllocationManagerCalls::getAllocationDelay)
13428                    }
13429                    getAllocationDelay
13430                },
13431                {
13432                    fn getOperatorSetCount(
13433                        data: &[u8],
13434                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13435                        <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13436                                data,
13437                            )
13438                            .map(IAllocationManagerCalls::getOperatorSetCount)
13439                    }
13440                    getOperatorSetCount
13441                },
13442                {
13443                    fn getAllocatedStrategies(
13444                        data: &[u8],
13445                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13446                        <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13447                                data,
13448                            )
13449                            .map(IAllocationManagerCalls::getAllocatedStrategies)
13450                    }
13451                    getAllocatedStrategies
13452                },
13453                {
13454                    fn initialize(
13455                        data: &[u8],
13456                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13457                        <initializeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13458                                data,
13459                            )
13460                            .map(IAllocationManagerCalls::initialize)
13461                    }
13462                    initialize
13463                },
13464                {
13465                    fn setAVSRegistrar(
13466                        data: &[u8],
13467                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13468                        <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13469                                data,
13470                            )
13471                            .map(IAllocationManagerCalls::setAVSRegistrar)
13472                    }
13473                    setAVSRegistrar
13474                },
13475                {
13476                    fn getEncumberedMagnitude(
13477                        data: &[u8],
13478                    ) -> alloy_sol_types::Result<IAllocationManagerCalls> {
13479                        <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
13480                                data,
13481                            )
13482                            .map(IAllocationManagerCalls::getEncumberedMagnitude)
13483                    }
13484                    getEncumberedMagnitude
13485                },
13486            ];
13487            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
13488                return Err(
13489                    alloy_sol_types::Error::unknown_selector(
13490                        <Self as alloy_sol_types::SolInterface>::NAME,
13491                        selector,
13492                    ),
13493                );
13494            };
13495            DECODE_VALIDATE_SHIMS[idx](data)
13496        }
13497        #[inline]
13498        fn abi_encoded_size(&self) -> usize {
13499            match self {
13500                Self::addStrategiesToOperatorSet(inner) => {
13501                    <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
13502                        inner,
13503                    )
13504                }
13505                Self::clearDeallocationQueue(inner) => {
13506                    <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_encoded_size(
13507                        inner,
13508                    )
13509                }
13510                Self::createOperatorSets(inner) => {
13511                    <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13512                        inner,
13513                    )
13514                }
13515                Self::deregisterFromOperatorSets(inner) => {
13516                    <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13517                        inner,
13518                    )
13519                }
13520                Self::getAVSRegistrar(inner) => {
13521                    <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encoded_size(
13522                        inner,
13523                    )
13524                }
13525                Self::getAllocatableMagnitude(inner) => {
13526                    <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_encoded_size(
13527                        inner,
13528                    )
13529                }
13530                Self::getAllocatedSets(inner) => {
13531                    <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13532                        inner,
13533                    )
13534                }
13535                Self::getAllocatedStake(inner) => {
13536                    <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_encoded_size(
13537                        inner,
13538                    )
13539                }
13540                Self::getAllocatedStrategies(inner) => {
13541                    <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_encoded_size(
13542                        inner,
13543                    )
13544                }
13545                Self::getAllocation(inner) => {
13546                    <getAllocationCall as alloy_sol_types::SolCall>::abi_encoded_size(
13547                        inner,
13548                    )
13549                }
13550                Self::getAllocationDelay(inner) => {
13551                    <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
13552                        inner,
13553                    )
13554                }
13555                Self::getAllocations(inner) => {
13556                    <getAllocationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13557                        inner,
13558                    )
13559                }
13560                Self::getEncumberedMagnitude(inner) => {
13561                    <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_encoded_size(
13562                        inner,
13563                    )
13564                }
13565                Self::getMaxMagnitude(inner) => {
13566                    <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_encoded_size(
13567                        inner,
13568                    )
13569                }
13570                Self::getMaxMagnitudes_0(inner) => {
13571                    <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_encoded_size(
13572                        inner,
13573                    )
13574                }
13575                Self::getMaxMagnitudes_1(inner) => {
13576                    <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_encoded_size(
13577                        inner,
13578                    )
13579                }
13580                Self::getMaxMagnitudesAtBlock(inner) => {
13581                    <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
13582                        inner,
13583                    )
13584                }
13585                Self::getMemberCount(inner) => {
13586                    <getMemberCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
13587                        inner,
13588                    )
13589                }
13590                Self::getMembers(inner) => {
13591                    <getMembersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
13592                }
13593                Self::getMinimumSlashableStake(inner) => {
13594                    <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_encoded_size(
13595                        inner,
13596                    )
13597                }
13598                Self::getOperatorSetCount(inner) => {
13599                    <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_encoded_size(
13600                        inner,
13601                    )
13602                }
13603                Self::getRegisteredSets(inner) => {
13604                    <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13605                        inner,
13606                    )
13607                }
13608                Self::getStrategiesInOperatorSet(inner) => {
13609                    <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
13610                        inner,
13611                    )
13612                }
13613                Self::getStrategyAllocations(inner) => {
13614                    <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13615                        inner,
13616                    )
13617                }
13618                Self::initialize(inner) => {
13619                    <initializeCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
13620                }
13621                Self::isMemberOfOperatorSet(inner) => {
13622                    <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
13623                        inner,
13624                    )
13625                }
13626                Self::isOperatorSet(inner) => {
13627                    <isOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
13628                        inner,
13629                    )
13630                }
13631                Self::isOperatorSlashable(inner) => {
13632                    <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_encoded_size(
13633                        inner,
13634                    )
13635                }
13636                Self::modifyAllocations(inner) => {
13637                    <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13638                        inner,
13639                    )
13640                }
13641                Self::registerForOperatorSets(inner) => {
13642                    <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_encoded_size(
13643                        inner,
13644                    )
13645                }
13646                Self::removeStrategiesFromOperatorSet(inner) => {
13647                    <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_encoded_size(
13648                        inner,
13649                    )
13650                }
13651                Self::setAVSRegistrar(inner) => {
13652                    <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encoded_size(
13653                        inner,
13654                    )
13655                }
13656                Self::setAllocationDelay(inner) => {
13657                    <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_encoded_size(
13658                        inner,
13659                    )
13660                }
13661                Self::slashOperator(inner) => {
13662                    <slashOperatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
13663                        inner,
13664                    )
13665                }
13666                Self::updateAVSMetadataURI(inner) => {
13667                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encoded_size(
13668                        inner,
13669                    )
13670                }
13671                Self::version(inner) => {
13672                    <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
13673                }
13674            }
13675        }
13676        #[inline]
13677        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
13678            match self {
13679                Self::addStrategiesToOperatorSet(inner) => {
13680                    <addStrategiesToOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
13681                        inner,
13682                        out,
13683                    )
13684                }
13685                Self::clearDeallocationQueue(inner) => {
13686                    <clearDeallocationQueueCall as alloy_sol_types::SolCall>::abi_encode_raw(
13687                        inner,
13688                        out,
13689                    )
13690                }
13691                Self::createOperatorSets(inner) => {
13692                    <createOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13693                        inner,
13694                        out,
13695                    )
13696                }
13697                Self::deregisterFromOperatorSets(inner) => {
13698                    <deregisterFromOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13699                        inner,
13700                        out,
13701                    )
13702                }
13703                Self::getAVSRegistrar(inner) => {
13704                    <getAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encode_raw(
13705                        inner,
13706                        out,
13707                    )
13708                }
13709                Self::getAllocatableMagnitude(inner) => {
13710                    <getAllocatableMagnitudeCall as alloy_sol_types::SolCall>::abi_encode_raw(
13711                        inner,
13712                        out,
13713                    )
13714                }
13715                Self::getAllocatedSets(inner) => {
13716                    <getAllocatedSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13717                        inner,
13718                        out,
13719                    )
13720                }
13721                Self::getAllocatedStake(inner) => {
13722                    <getAllocatedStakeCall as alloy_sol_types::SolCall>::abi_encode_raw(
13723                        inner,
13724                        out,
13725                    )
13726                }
13727                Self::getAllocatedStrategies(inner) => {
13728                    <getAllocatedStrategiesCall as alloy_sol_types::SolCall>::abi_encode_raw(
13729                        inner,
13730                        out,
13731                    )
13732                }
13733                Self::getAllocation(inner) => {
13734                    <getAllocationCall as alloy_sol_types::SolCall>::abi_encode_raw(
13735                        inner,
13736                        out,
13737                    )
13738                }
13739                Self::getAllocationDelay(inner) => {
13740                    <getAllocationDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
13741                        inner,
13742                        out,
13743                    )
13744                }
13745                Self::getAllocations(inner) => {
13746                    <getAllocationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13747                        inner,
13748                        out,
13749                    )
13750                }
13751                Self::getEncumberedMagnitude(inner) => {
13752                    <getEncumberedMagnitudeCall as alloy_sol_types::SolCall>::abi_encode_raw(
13753                        inner,
13754                        out,
13755                    )
13756                }
13757                Self::getMaxMagnitude(inner) => {
13758                    <getMaxMagnitudeCall as alloy_sol_types::SolCall>::abi_encode_raw(
13759                        inner,
13760                        out,
13761                    )
13762                }
13763                Self::getMaxMagnitudes_0(inner) => {
13764                    <getMaxMagnitudes_0Call as alloy_sol_types::SolCall>::abi_encode_raw(
13765                        inner,
13766                        out,
13767                    )
13768                }
13769                Self::getMaxMagnitudes_1(inner) => {
13770                    <getMaxMagnitudes_1Call as alloy_sol_types::SolCall>::abi_encode_raw(
13771                        inner,
13772                        out,
13773                    )
13774                }
13775                Self::getMaxMagnitudesAtBlock(inner) => {
13776                    <getMaxMagnitudesAtBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
13777                        inner,
13778                        out,
13779                    )
13780                }
13781                Self::getMemberCount(inner) => {
13782                    <getMemberCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
13783                        inner,
13784                        out,
13785                    )
13786                }
13787                Self::getMembers(inner) => {
13788                    <getMembersCall as alloy_sol_types::SolCall>::abi_encode_raw(
13789                        inner,
13790                        out,
13791                    )
13792                }
13793                Self::getMinimumSlashableStake(inner) => {
13794                    <getMinimumSlashableStakeCall as alloy_sol_types::SolCall>::abi_encode_raw(
13795                        inner,
13796                        out,
13797                    )
13798                }
13799                Self::getOperatorSetCount(inner) => {
13800                    <getOperatorSetCountCall as alloy_sol_types::SolCall>::abi_encode_raw(
13801                        inner,
13802                        out,
13803                    )
13804                }
13805                Self::getRegisteredSets(inner) => {
13806                    <getRegisteredSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13807                        inner,
13808                        out,
13809                    )
13810                }
13811                Self::getStrategiesInOperatorSet(inner) => {
13812                    <getStrategiesInOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
13813                        inner,
13814                        out,
13815                    )
13816                }
13817                Self::getStrategyAllocations(inner) => {
13818                    <getStrategyAllocationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13819                        inner,
13820                        out,
13821                    )
13822                }
13823                Self::initialize(inner) => {
13824                    <initializeCall as alloy_sol_types::SolCall>::abi_encode_raw(
13825                        inner,
13826                        out,
13827                    )
13828                }
13829                Self::isMemberOfOperatorSet(inner) => {
13830                    <isMemberOfOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
13831                        inner,
13832                        out,
13833                    )
13834                }
13835                Self::isOperatorSet(inner) => {
13836                    <isOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
13837                        inner,
13838                        out,
13839                    )
13840                }
13841                Self::isOperatorSlashable(inner) => {
13842                    <isOperatorSlashableCall as alloy_sol_types::SolCall>::abi_encode_raw(
13843                        inner,
13844                        out,
13845                    )
13846                }
13847                Self::modifyAllocations(inner) => {
13848                    <modifyAllocationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13849                        inner,
13850                        out,
13851                    )
13852                }
13853                Self::registerForOperatorSets(inner) => {
13854                    <registerForOperatorSetsCall as alloy_sol_types::SolCall>::abi_encode_raw(
13855                        inner,
13856                        out,
13857                    )
13858                }
13859                Self::removeStrategiesFromOperatorSet(inner) => {
13860                    <removeStrategiesFromOperatorSetCall as alloy_sol_types::SolCall>::abi_encode_raw(
13861                        inner,
13862                        out,
13863                    )
13864                }
13865                Self::setAVSRegistrar(inner) => {
13866                    <setAVSRegistrarCall as alloy_sol_types::SolCall>::abi_encode_raw(
13867                        inner,
13868                        out,
13869                    )
13870                }
13871                Self::setAllocationDelay(inner) => {
13872                    <setAllocationDelayCall as alloy_sol_types::SolCall>::abi_encode_raw(
13873                        inner,
13874                        out,
13875                    )
13876                }
13877                Self::slashOperator(inner) => {
13878                    <slashOperatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
13879                        inner,
13880                        out,
13881                    )
13882                }
13883                Self::updateAVSMetadataURI(inner) => {
13884                    <updateAVSMetadataURICall as alloy_sol_types::SolCall>::abi_encode_raw(
13885                        inner,
13886                        out,
13887                    )
13888                }
13889                Self::version(inner) => {
13890                    <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
13891                }
13892            }
13893        }
13894    }
13895    ///Container for all the [`IAllocationManager`](self) custom errors.
13896    #[derive(serde::Serialize, serde::Deserialize)]
13897    #[derive(Debug, PartialEq, Eq, Hash)]
13898    pub enum IAllocationManagerErrors {
13899        #[allow(missing_docs)]
13900        AlreadyMemberOfSet(AlreadyMemberOfSet),
13901        #[allow(missing_docs)]
13902        InputArrayLengthMismatch(InputArrayLengthMismatch),
13903        #[allow(missing_docs)]
13904        InsufficientMagnitude(InsufficientMagnitude),
13905        #[allow(missing_docs)]
13906        InvalidAVSRegistrar(InvalidAVSRegistrar),
13907        #[allow(missing_docs)]
13908        InvalidCaller(InvalidCaller),
13909        #[allow(missing_docs)]
13910        InvalidOperator(InvalidOperator),
13911        #[allow(missing_docs)]
13912        InvalidOperatorSet(InvalidOperatorSet),
13913        #[allow(missing_docs)]
13914        InvalidWadToSlash(InvalidWadToSlash),
13915        #[allow(missing_docs)]
13916        ModificationAlreadyPending(ModificationAlreadyPending),
13917        #[allow(missing_docs)]
13918        NonexistentAVSMetadata(NonexistentAVSMetadata),
13919        #[allow(missing_docs)]
13920        NotMemberOfSet(NotMemberOfSet),
13921        #[allow(missing_docs)]
13922        OperatorNotSlashable(OperatorNotSlashable),
13923        #[allow(missing_docs)]
13924        SameMagnitude(SameMagnitude),
13925        #[allow(missing_docs)]
13926        StrategiesMustBeInAscendingOrder(StrategiesMustBeInAscendingOrder),
13927        #[allow(missing_docs)]
13928        StrategyAlreadyInOperatorSet(StrategyAlreadyInOperatorSet),
13929        #[allow(missing_docs)]
13930        StrategyNotInOperatorSet(StrategyNotInOperatorSet),
13931        #[allow(missing_docs)]
13932        UninitializedAllocationDelay(UninitializedAllocationDelay),
13933    }
13934    #[automatically_derived]
13935    impl IAllocationManagerErrors {
13936        /// All the selectors of this enum.
13937        ///
13938        /// Note that the selectors might not be in the same order as the variants.
13939        /// No guarantees are made about the order of the selectors.
13940        ///
13941        /// Prefer using `SolInterface` methods instead.
13942        pub const SELECTORS: &'static [[u8; 4usize]] = &[
13943            [19u8, 83u8, 96u8, 49u8],
13944            [37u8, 19u8, 29u8, 79u8],
13945            [67u8, 113u8, 74u8, 253u8],
13946            [72u8, 245u8, 195u8, 237u8],
13947            [72u8, 247u8, 219u8, 185u8],
13948            [88u8, 92u8, 251u8, 47u8],
13949            [99u8, 120u8, 104u8, 78u8],
13950            [108u8, 155u8, 224u8, 191u8],
13951            [126u8, 197u8, 193u8, 84u8],
13952            [140u8, 12u8, 47u8, 38u8],
13953            [159u8, 28u8, 128u8, 83u8],
13954            [204u8, 234u8, 158u8, 111u8],
13955            [216u8, 216u8, 220u8, 78u8],
13956            [216u8, 252u8, 190u8, 48u8],
13957            [232u8, 88u8, 158u8, 8u8],
13958            [235u8, 191u8, 244u8, 151u8],
13959            [250u8, 85u8, 252u8, 129u8],
13960        ];
13961    }
13962    #[automatically_derived]
13963    impl alloy_sol_types::SolInterface for IAllocationManagerErrors {
13964        const NAME: &'static str = "IAllocationManagerErrors";
13965        const MIN_DATA_LENGTH: usize = 0usize;
13966        const COUNT: usize = 17usize;
13967        #[inline]
13968        fn selector(&self) -> [u8; 4] {
13969            match self {
13970                Self::AlreadyMemberOfSet(_) => {
13971                    <AlreadyMemberOfSet as alloy_sol_types::SolError>::SELECTOR
13972                }
13973                Self::InputArrayLengthMismatch(_) => {
13974                    <InputArrayLengthMismatch as alloy_sol_types::SolError>::SELECTOR
13975                }
13976                Self::InsufficientMagnitude(_) => {
13977                    <InsufficientMagnitude as alloy_sol_types::SolError>::SELECTOR
13978                }
13979                Self::InvalidAVSRegistrar(_) => {
13980                    <InvalidAVSRegistrar as alloy_sol_types::SolError>::SELECTOR
13981                }
13982                Self::InvalidCaller(_) => {
13983                    <InvalidCaller as alloy_sol_types::SolError>::SELECTOR
13984                }
13985                Self::InvalidOperator(_) => {
13986                    <InvalidOperator as alloy_sol_types::SolError>::SELECTOR
13987                }
13988                Self::InvalidOperatorSet(_) => {
13989                    <InvalidOperatorSet as alloy_sol_types::SolError>::SELECTOR
13990                }
13991                Self::InvalidWadToSlash(_) => {
13992                    <InvalidWadToSlash as alloy_sol_types::SolError>::SELECTOR
13993                }
13994                Self::ModificationAlreadyPending(_) => {
13995                    <ModificationAlreadyPending as alloy_sol_types::SolError>::SELECTOR
13996                }
13997                Self::NonexistentAVSMetadata(_) => {
13998                    <NonexistentAVSMetadata as alloy_sol_types::SolError>::SELECTOR
13999                }
14000                Self::NotMemberOfSet(_) => {
14001                    <NotMemberOfSet as alloy_sol_types::SolError>::SELECTOR
14002                }
14003                Self::OperatorNotSlashable(_) => {
14004                    <OperatorNotSlashable as alloy_sol_types::SolError>::SELECTOR
14005                }
14006                Self::SameMagnitude(_) => {
14007                    <SameMagnitude as alloy_sol_types::SolError>::SELECTOR
14008                }
14009                Self::StrategiesMustBeInAscendingOrder(_) => {
14010                    <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::SELECTOR
14011                }
14012                Self::StrategyAlreadyInOperatorSet(_) => {
14013                    <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::SELECTOR
14014                }
14015                Self::StrategyNotInOperatorSet(_) => {
14016                    <StrategyNotInOperatorSet as alloy_sol_types::SolError>::SELECTOR
14017                }
14018                Self::UninitializedAllocationDelay(_) => {
14019                    <UninitializedAllocationDelay as alloy_sol_types::SolError>::SELECTOR
14020                }
14021            }
14022        }
14023        #[inline]
14024        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
14025            Self::SELECTORS.get(i).copied()
14026        }
14027        #[inline]
14028        fn valid_selector(selector: [u8; 4]) -> bool {
14029            Self::SELECTORS.binary_search(&selector).is_ok()
14030        }
14031        #[inline]
14032        #[allow(non_snake_case)]
14033        fn abi_decode_raw(
14034            selector: [u8; 4],
14035            data: &[u8],
14036        ) -> alloy_sol_types::Result<Self> {
14037            static DECODE_SHIMS: &[fn(
14038                &[u8],
14039            ) -> alloy_sol_types::Result<IAllocationManagerErrors>] = &[
14040                {
14041                    fn InvalidWadToSlash(
14042                        data: &[u8],
14043                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14044                        <InvalidWadToSlash as alloy_sol_types::SolError>::abi_decode_raw(
14045                                data,
14046                            )
14047                            .map(IAllocationManagerErrors::InvalidWadToSlash)
14048                    }
14049                    InvalidWadToSlash
14050                },
14051                {
14052                    fn NotMemberOfSet(
14053                        data: &[u8],
14054                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14055                        <NotMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw(
14056                                data,
14057                            )
14058                            .map(IAllocationManagerErrors::NotMemberOfSet)
14059                    }
14060                    NotMemberOfSet
14061                },
14062                {
14063                    fn InputArrayLengthMismatch(
14064                        data: &[u8],
14065                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14066                        <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw(
14067                                data,
14068                            )
14069                            .map(IAllocationManagerErrors::InputArrayLengthMismatch)
14070                    }
14071                    InputArrayLengthMismatch
14072                },
14073                {
14074                    fn InvalidCaller(
14075                        data: &[u8],
14076                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14077                        <InvalidCaller as alloy_sol_types::SolError>::abi_decode_raw(
14078                                data,
14079                            )
14080                            .map(IAllocationManagerErrors::InvalidCaller)
14081                    }
14082                    InvalidCaller
14083                },
14084                {
14085                    fn NonexistentAVSMetadata(
14086                        data: &[u8],
14087                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14088                        <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_decode_raw(
14089                                data,
14090                            )
14091                            .map(IAllocationManagerErrors::NonexistentAVSMetadata)
14092                    }
14093                    NonexistentAVSMetadata
14094                },
14095                {
14096                    fn StrategyAlreadyInOperatorSet(
14097                        data: &[u8],
14098                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14099                        <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw(
14100                                data,
14101                            )
14102                            .map(IAllocationManagerErrors::StrategyAlreadyInOperatorSet)
14103                    }
14104                    StrategyAlreadyInOperatorSet
14105                },
14106                {
14107                    fn StrategyNotInOperatorSet(
14108                        data: &[u8],
14109                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14110                        <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw(
14111                                data,
14112                            )
14113                            .map(IAllocationManagerErrors::StrategyNotInOperatorSet)
14114                    }
14115                    StrategyNotInOperatorSet
14116                },
14117                {
14118                    fn InsufficientMagnitude(
14119                        data: &[u8],
14120                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14121                        <InsufficientMagnitude as alloy_sol_types::SolError>::abi_decode_raw(
14122                                data,
14123                            )
14124                            .map(IAllocationManagerErrors::InsufficientMagnitude)
14125                    }
14126                    InsufficientMagnitude
14127                },
14128                {
14129                    fn InvalidOperatorSet(
14130                        data: &[u8],
14131                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14132                        <InvalidOperatorSet as alloy_sol_types::SolError>::abi_decode_raw(
14133                                data,
14134                            )
14135                            .map(IAllocationManagerErrors::InvalidOperatorSet)
14136                    }
14137                    InvalidOperatorSet
14138                },
14139                {
14140                    fn SameMagnitude(
14141                        data: &[u8],
14142                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14143                        <SameMagnitude as alloy_sol_types::SolError>::abi_decode_raw(
14144                                data,
14145                            )
14146                            .map(IAllocationManagerErrors::SameMagnitude)
14147                    }
14148                    SameMagnitude
14149                },
14150                {
14151                    fn StrategiesMustBeInAscendingOrder(
14152                        data: &[u8],
14153                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14154                        <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_decode_raw(
14155                                data,
14156                            )
14157                            .map(
14158                                IAllocationManagerErrors::StrategiesMustBeInAscendingOrder,
14159                            )
14160                    }
14161                    StrategiesMustBeInAscendingOrder
14162                },
14163                {
14164                    fn InvalidOperator(
14165                        data: &[u8],
14166                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14167                        <InvalidOperator as alloy_sol_types::SolError>::abi_decode_raw(
14168                                data,
14169                            )
14170                            .map(IAllocationManagerErrors::InvalidOperator)
14171                    }
14172                    InvalidOperator
14173                },
14174                {
14175                    fn AlreadyMemberOfSet(
14176                        data: &[u8],
14177                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14178                        <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw(
14179                                data,
14180                            )
14181                            .map(IAllocationManagerErrors::AlreadyMemberOfSet)
14182                    }
14183                    AlreadyMemberOfSet
14184                },
14185                {
14186                    fn ModificationAlreadyPending(
14187                        data: &[u8],
14188                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14189                        <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_decode_raw(
14190                                data,
14191                            )
14192                            .map(IAllocationManagerErrors::ModificationAlreadyPending)
14193                    }
14194                    ModificationAlreadyPending
14195                },
14196                {
14197                    fn InvalidAVSRegistrar(
14198                        data: &[u8],
14199                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14200                        <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_decode_raw(
14201                                data,
14202                            )
14203                            .map(IAllocationManagerErrors::InvalidAVSRegistrar)
14204                    }
14205                    InvalidAVSRegistrar
14206                },
14207                {
14208                    fn OperatorNotSlashable(
14209                        data: &[u8],
14210                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14211                        <OperatorNotSlashable as alloy_sol_types::SolError>::abi_decode_raw(
14212                                data,
14213                            )
14214                            .map(IAllocationManagerErrors::OperatorNotSlashable)
14215                    }
14216                    OperatorNotSlashable
14217                },
14218                {
14219                    fn UninitializedAllocationDelay(
14220                        data: &[u8],
14221                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14222                        <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_decode_raw(
14223                                data,
14224                            )
14225                            .map(IAllocationManagerErrors::UninitializedAllocationDelay)
14226                    }
14227                    UninitializedAllocationDelay
14228                },
14229            ];
14230            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
14231                return Err(
14232                    alloy_sol_types::Error::unknown_selector(
14233                        <Self as alloy_sol_types::SolInterface>::NAME,
14234                        selector,
14235                    ),
14236                );
14237            };
14238            DECODE_SHIMS[idx](data)
14239        }
14240        #[inline]
14241        #[allow(non_snake_case)]
14242        fn abi_decode_raw_validate(
14243            selector: [u8; 4],
14244            data: &[u8],
14245        ) -> alloy_sol_types::Result<Self> {
14246            static DECODE_VALIDATE_SHIMS: &[fn(
14247                &[u8],
14248            ) -> alloy_sol_types::Result<IAllocationManagerErrors>] = &[
14249                {
14250                    fn InvalidWadToSlash(
14251                        data: &[u8],
14252                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14253                        <InvalidWadToSlash as alloy_sol_types::SolError>::abi_decode_raw_validate(
14254                                data,
14255                            )
14256                            .map(IAllocationManagerErrors::InvalidWadToSlash)
14257                    }
14258                    InvalidWadToSlash
14259                },
14260                {
14261                    fn NotMemberOfSet(
14262                        data: &[u8],
14263                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14264                        <NotMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
14265                                data,
14266                            )
14267                            .map(IAllocationManagerErrors::NotMemberOfSet)
14268                    }
14269                    NotMemberOfSet
14270                },
14271                {
14272                    fn InputArrayLengthMismatch(
14273                        data: &[u8],
14274                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14275                        <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_decode_raw_validate(
14276                                data,
14277                            )
14278                            .map(IAllocationManagerErrors::InputArrayLengthMismatch)
14279                    }
14280                    InputArrayLengthMismatch
14281                },
14282                {
14283                    fn InvalidCaller(
14284                        data: &[u8],
14285                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14286                        <InvalidCaller as alloy_sol_types::SolError>::abi_decode_raw_validate(
14287                                data,
14288                            )
14289                            .map(IAllocationManagerErrors::InvalidCaller)
14290                    }
14291                    InvalidCaller
14292                },
14293                {
14294                    fn NonexistentAVSMetadata(
14295                        data: &[u8],
14296                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14297                        <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_decode_raw_validate(
14298                                data,
14299                            )
14300                            .map(IAllocationManagerErrors::NonexistentAVSMetadata)
14301                    }
14302                    NonexistentAVSMetadata
14303                },
14304                {
14305                    fn StrategyAlreadyInOperatorSet(
14306                        data: &[u8],
14307                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14308                        <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
14309                                data,
14310                            )
14311                            .map(IAllocationManagerErrors::StrategyAlreadyInOperatorSet)
14312                    }
14313                    StrategyAlreadyInOperatorSet
14314                },
14315                {
14316                    fn StrategyNotInOperatorSet(
14317                        data: &[u8],
14318                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14319                        <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
14320                                data,
14321                            )
14322                            .map(IAllocationManagerErrors::StrategyNotInOperatorSet)
14323                    }
14324                    StrategyNotInOperatorSet
14325                },
14326                {
14327                    fn InsufficientMagnitude(
14328                        data: &[u8],
14329                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14330                        <InsufficientMagnitude as alloy_sol_types::SolError>::abi_decode_raw_validate(
14331                                data,
14332                            )
14333                            .map(IAllocationManagerErrors::InsufficientMagnitude)
14334                    }
14335                    InsufficientMagnitude
14336                },
14337                {
14338                    fn InvalidOperatorSet(
14339                        data: &[u8],
14340                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14341                        <InvalidOperatorSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
14342                                data,
14343                            )
14344                            .map(IAllocationManagerErrors::InvalidOperatorSet)
14345                    }
14346                    InvalidOperatorSet
14347                },
14348                {
14349                    fn SameMagnitude(
14350                        data: &[u8],
14351                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14352                        <SameMagnitude as alloy_sol_types::SolError>::abi_decode_raw_validate(
14353                                data,
14354                            )
14355                            .map(IAllocationManagerErrors::SameMagnitude)
14356                    }
14357                    SameMagnitude
14358                },
14359                {
14360                    fn StrategiesMustBeInAscendingOrder(
14361                        data: &[u8],
14362                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14363                        <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_decode_raw_validate(
14364                                data,
14365                            )
14366                            .map(
14367                                IAllocationManagerErrors::StrategiesMustBeInAscendingOrder,
14368                            )
14369                    }
14370                    StrategiesMustBeInAscendingOrder
14371                },
14372                {
14373                    fn InvalidOperator(
14374                        data: &[u8],
14375                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14376                        <InvalidOperator as alloy_sol_types::SolError>::abi_decode_raw_validate(
14377                                data,
14378                            )
14379                            .map(IAllocationManagerErrors::InvalidOperator)
14380                    }
14381                    InvalidOperator
14382                },
14383                {
14384                    fn AlreadyMemberOfSet(
14385                        data: &[u8],
14386                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14387                        <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
14388                                data,
14389                            )
14390                            .map(IAllocationManagerErrors::AlreadyMemberOfSet)
14391                    }
14392                    AlreadyMemberOfSet
14393                },
14394                {
14395                    fn ModificationAlreadyPending(
14396                        data: &[u8],
14397                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14398                        <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_decode_raw_validate(
14399                                data,
14400                            )
14401                            .map(IAllocationManagerErrors::ModificationAlreadyPending)
14402                    }
14403                    ModificationAlreadyPending
14404                },
14405                {
14406                    fn InvalidAVSRegistrar(
14407                        data: &[u8],
14408                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14409                        <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_decode_raw_validate(
14410                                data,
14411                            )
14412                            .map(IAllocationManagerErrors::InvalidAVSRegistrar)
14413                    }
14414                    InvalidAVSRegistrar
14415                },
14416                {
14417                    fn OperatorNotSlashable(
14418                        data: &[u8],
14419                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14420                        <OperatorNotSlashable as alloy_sol_types::SolError>::abi_decode_raw_validate(
14421                                data,
14422                            )
14423                            .map(IAllocationManagerErrors::OperatorNotSlashable)
14424                    }
14425                    OperatorNotSlashable
14426                },
14427                {
14428                    fn UninitializedAllocationDelay(
14429                        data: &[u8],
14430                    ) -> alloy_sol_types::Result<IAllocationManagerErrors> {
14431                        <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_decode_raw_validate(
14432                                data,
14433                            )
14434                            .map(IAllocationManagerErrors::UninitializedAllocationDelay)
14435                    }
14436                    UninitializedAllocationDelay
14437                },
14438            ];
14439            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
14440                return Err(
14441                    alloy_sol_types::Error::unknown_selector(
14442                        <Self as alloy_sol_types::SolInterface>::NAME,
14443                        selector,
14444                    ),
14445                );
14446            };
14447            DECODE_VALIDATE_SHIMS[idx](data)
14448        }
14449        #[inline]
14450        fn abi_encoded_size(&self) -> usize {
14451            match self {
14452                Self::AlreadyMemberOfSet(inner) => {
14453                    <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_encoded_size(
14454                        inner,
14455                    )
14456                }
14457                Self::InputArrayLengthMismatch(inner) => {
14458                    <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_encoded_size(
14459                        inner,
14460                    )
14461                }
14462                Self::InsufficientMagnitude(inner) => {
14463                    <InsufficientMagnitude as alloy_sol_types::SolError>::abi_encoded_size(
14464                        inner,
14465                    )
14466                }
14467                Self::InvalidAVSRegistrar(inner) => {
14468                    <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_encoded_size(
14469                        inner,
14470                    )
14471                }
14472                Self::InvalidCaller(inner) => {
14473                    <InvalidCaller as alloy_sol_types::SolError>::abi_encoded_size(inner)
14474                }
14475                Self::InvalidOperator(inner) => {
14476                    <InvalidOperator as alloy_sol_types::SolError>::abi_encoded_size(
14477                        inner,
14478                    )
14479                }
14480                Self::InvalidOperatorSet(inner) => {
14481                    <InvalidOperatorSet as alloy_sol_types::SolError>::abi_encoded_size(
14482                        inner,
14483                    )
14484                }
14485                Self::InvalidWadToSlash(inner) => {
14486                    <InvalidWadToSlash as alloy_sol_types::SolError>::abi_encoded_size(
14487                        inner,
14488                    )
14489                }
14490                Self::ModificationAlreadyPending(inner) => {
14491                    <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_encoded_size(
14492                        inner,
14493                    )
14494                }
14495                Self::NonexistentAVSMetadata(inner) => {
14496                    <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_encoded_size(
14497                        inner,
14498                    )
14499                }
14500                Self::NotMemberOfSet(inner) => {
14501                    <NotMemberOfSet as alloy_sol_types::SolError>::abi_encoded_size(
14502                        inner,
14503                    )
14504                }
14505                Self::OperatorNotSlashable(inner) => {
14506                    <OperatorNotSlashable as alloy_sol_types::SolError>::abi_encoded_size(
14507                        inner,
14508                    )
14509                }
14510                Self::SameMagnitude(inner) => {
14511                    <SameMagnitude as alloy_sol_types::SolError>::abi_encoded_size(inner)
14512                }
14513                Self::StrategiesMustBeInAscendingOrder(inner) => {
14514                    <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_encoded_size(
14515                        inner,
14516                    )
14517                }
14518                Self::StrategyAlreadyInOperatorSet(inner) => {
14519                    <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_encoded_size(
14520                        inner,
14521                    )
14522                }
14523                Self::StrategyNotInOperatorSet(inner) => {
14524                    <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_encoded_size(
14525                        inner,
14526                    )
14527                }
14528                Self::UninitializedAllocationDelay(inner) => {
14529                    <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_encoded_size(
14530                        inner,
14531                    )
14532                }
14533            }
14534        }
14535        #[inline]
14536        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
14537            match self {
14538                Self::AlreadyMemberOfSet(inner) => {
14539                    <AlreadyMemberOfSet as alloy_sol_types::SolError>::abi_encode_raw(
14540                        inner,
14541                        out,
14542                    )
14543                }
14544                Self::InputArrayLengthMismatch(inner) => {
14545                    <InputArrayLengthMismatch as alloy_sol_types::SolError>::abi_encode_raw(
14546                        inner,
14547                        out,
14548                    )
14549                }
14550                Self::InsufficientMagnitude(inner) => {
14551                    <InsufficientMagnitude as alloy_sol_types::SolError>::abi_encode_raw(
14552                        inner,
14553                        out,
14554                    )
14555                }
14556                Self::InvalidAVSRegistrar(inner) => {
14557                    <InvalidAVSRegistrar as alloy_sol_types::SolError>::abi_encode_raw(
14558                        inner,
14559                        out,
14560                    )
14561                }
14562                Self::InvalidCaller(inner) => {
14563                    <InvalidCaller as alloy_sol_types::SolError>::abi_encode_raw(
14564                        inner,
14565                        out,
14566                    )
14567                }
14568                Self::InvalidOperator(inner) => {
14569                    <InvalidOperator as alloy_sol_types::SolError>::abi_encode_raw(
14570                        inner,
14571                        out,
14572                    )
14573                }
14574                Self::InvalidOperatorSet(inner) => {
14575                    <InvalidOperatorSet as alloy_sol_types::SolError>::abi_encode_raw(
14576                        inner,
14577                        out,
14578                    )
14579                }
14580                Self::InvalidWadToSlash(inner) => {
14581                    <InvalidWadToSlash as alloy_sol_types::SolError>::abi_encode_raw(
14582                        inner,
14583                        out,
14584                    )
14585                }
14586                Self::ModificationAlreadyPending(inner) => {
14587                    <ModificationAlreadyPending as alloy_sol_types::SolError>::abi_encode_raw(
14588                        inner,
14589                        out,
14590                    )
14591                }
14592                Self::NonexistentAVSMetadata(inner) => {
14593                    <NonexistentAVSMetadata as alloy_sol_types::SolError>::abi_encode_raw(
14594                        inner,
14595                        out,
14596                    )
14597                }
14598                Self::NotMemberOfSet(inner) => {
14599                    <NotMemberOfSet as alloy_sol_types::SolError>::abi_encode_raw(
14600                        inner,
14601                        out,
14602                    )
14603                }
14604                Self::OperatorNotSlashable(inner) => {
14605                    <OperatorNotSlashable as alloy_sol_types::SolError>::abi_encode_raw(
14606                        inner,
14607                        out,
14608                    )
14609                }
14610                Self::SameMagnitude(inner) => {
14611                    <SameMagnitude as alloy_sol_types::SolError>::abi_encode_raw(
14612                        inner,
14613                        out,
14614                    )
14615                }
14616                Self::StrategiesMustBeInAscendingOrder(inner) => {
14617                    <StrategiesMustBeInAscendingOrder as alloy_sol_types::SolError>::abi_encode_raw(
14618                        inner,
14619                        out,
14620                    )
14621                }
14622                Self::StrategyAlreadyInOperatorSet(inner) => {
14623                    <StrategyAlreadyInOperatorSet as alloy_sol_types::SolError>::abi_encode_raw(
14624                        inner,
14625                        out,
14626                    )
14627                }
14628                Self::StrategyNotInOperatorSet(inner) => {
14629                    <StrategyNotInOperatorSet as alloy_sol_types::SolError>::abi_encode_raw(
14630                        inner,
14631                        out,
14632                    )
14633                }
14634                Self::UninitializedAllocationDelay(inner) => {
14635                    <UninitializedAllocationDelay as alloy_sol_types::SolError>::abi_encode_raw(
14636                        inner,
14637                        out,
14638                    )
14639                }
14640            }
14641        }
14642    }
14643    ///Container for all the [`IAllocationManager`](self) events.
14644    #[derive(serde::Serialize, serde::Deserialize)]
14645    #[derive(Debug, PartialEq, Eq, Hash)]
14646    pub enum IAllocationManagerEvents {
14647        #[allow(missing_docs)]
14648        AVSMetadataURIUpdated(AVSMetadataURIUpdated),
14649        #[allow(missing_docs)]
14650        AVSRegistrarSet(AVSRegistrarSet),
14651        #[allow(missing_docs)]
14652        AllocationDelaySet(AllocationDelaySet),
14653        #[allow(missing_docs)]
14654        AllocationUpdated(AllocationUpdated),
14655        #[allow(missing_docs)]
14656        EncumberedMagnitudeUpdated(EncumberedMagnitudeUpdated),
14657        #[allow(missing_docs)]
14658        MaxMagnitudeUpdated(MaxMagnitudeUpdated),
14659        #[allow(missing_docs)]
14660        OperatorAddedToOperatorSet(OperatorAddedToOperatorSet),
14661        #[allow(missing_docs)]
14662        OperatorRemovedFromOperatorSet(OperatorRemovedFromOperatorSet),
14663        #[allow(missing_docs)]
14664        OperatorSetCreated(OperatorSetCreated),
14665        #[allow(missing_docs)]
14666        OperatorSlashed(OperatorSlashed),
14667        #[allow(missing_docs)]
14668        StrategyAddedToOperatorSet(StrategyAddedToOperatorSet),
14669        #[allow(missing_docs)]
14670        StrategyRemovedFromOperatorSet(StrategyRemovedFromOperatorSet),
14671    }
14672    #[automatically_derived]
14673    impl IAllocationManagerEvents {
14674        /// All the selectors of this enum.
14675        ///
14676        /// Note that the selectors might not be in the same order as the variants.
14677        /// No guarantees are made about the order of the selectors.
14678        ///
14679        /// Prefer using `SolInterface` methods instead.
14680        pub const SELECTORS: &'static [[u8; 32usize]] = &[
14681            [
14682                20u8, 135u8, 175u8, 84u8, 24u8, 196u8, 126u8, 229u8, 234u8, 69u8, 239u8,
14683                74u8, 147u8, 57u8, 134u8, 104u8, 18u8, 8u8, 144u8, 119u8, 74u8, 158u8,
14684                19u8, 72u8, 126u8, 97u8, 233u8, 220u8, 59u8, 175u8, 118u8, 221u8,
14685            ],
14686            [
14687                28u8, 100u8, 88u8, 7u8, 154u8, 65u8, 7u8, 125u8, 0u8, 60u8, 17u8, 250u8,
14688                249u8, 191u8, 9u8, 126u8, 105u8, 59u8, 214u8, 121u8, 121u8, 228u8, 230u8,
14689                80u8, 11u8, 172u8, 123u8, 41u8, 219u8, 119u8, 155u8, 92u8,
14690            ],
14691            [
14692                42u8, 233u8, 69u8, 196u8, 12u8, 68u8, 220u8, 14u8, 194u8, 99u8, 249u8,
14693                86u8, 9u8, 195u8, 253u8, 198u8, 149u8, 46u8, 10u8, 239u8, 162u8, 45u8,
14694                99u8, 116u8, 228u8, 79u8, 44u8, 153u8, 122u8, 206u8, 223u8, 133u8,
14695            ],
14696            [
14697                49u8, 98u8, 146u8, 133u8, 234u8, 210u8, 51u8, 90u8, 224u8, 147u8, 63u8,
14698                134u8, 237u8, 42u8, 230u8, 51u8, 33u8, 247u8, 175u8, 119u8, 180u8, 230u8,
14699                234u8, 171u8, 196u8, 44u8, 5u8, 120u8, 128u8, 151u8, 126u8, 108u8,
14700            ],
14701            [
14702                67u8, 35u8, 46u8, 223u8, 144u8, 113u8, 117u8, 61u8, 35u8, 33u8, 229u8,
14703                250u8, 126u8, 1u8, 131u8, 99u8, 238u8, 36u8, 142u8, 95u8, 33u8, 66u8,
14704                230u8, 192u8, 142u8, 221u8, 50u8, 101u8, 191u8, 180u8, 137u8, 94u8,
14705            ],
14706            [
14707                78u8, 133u8, 117u8, 29u8, 99u8, 49u8, 80u8, 108u8, 108u8, 98u8, 51u8,
14708                95u8, 32u8, 126u8, 179u8, 31u8, 18u8, 166u8, 30u8, 87u8, 15u8, 52u8,
14709                245u8, 193u8, 118u8, 64u8, 48u8, 135u8, 133u8, 198u8, 212u8, 219u8,
14710            ],
14711            [
14712                122u8, 178u8, 96u8, 254u8, 10u8, 241u8, 147u8, 219u8, 95u8, 73u8, 134u8,
14713                119u8, 13u8, 131u8, 27u8, 218u8, 78u8, 164u8, 96u8, 153u8, 220u8, 129u8,
14714                126u8, 139u8, 103u8, 22u8, 220u8, 174u8, 138u8, 248u8, 232u8, 139u8,
14715            ],
14716            [
14717                123u8, 75u8, 7u8, 61u8, 128u8, 220u8, 172u8, 85u8, 161u8, 17u8, 119u8,
14718                216u8, 69u8, 154u8, 217u8, 246u8, 100u8, 206u8, 235u8, 145u8, 247u8,
14719                31u8, 39u8, 22u8, 123u8, 177u8, 79u8, 129u8, 82u8, 167u8, 238u8, 238u8,
14720            ],
14721            [
14722                128u8, 150u8, 154u8, 210u8, 148u8, 40u8, 214u8, 121u8, 126u8, 231u8,
14723                170u8, 208u8, 132u8, 249u8, 228u8, 164u8, 42u8, 130u8, 252u8, 80u8,
14724                109u8, 205u8, 44u8, 163u8, 182u8, 251u8, 67u8, 31u8, 133u8, 204u8, 235u8,
14725                229u8,
14726            ],
14727            [
14728                168u8, 156u8, 29u8, 194u8, 67u8, 216u8, 144u8, 138u8, 150u8, 221u8,
14729                132u8, 148u8, 75u8, 204u8, 151u8, 214u8, 188u8, 106u8, 192u8, 13u8,
14730                215u8, 142u8, 32u8, 98u8, 21u8, 118u8, 190u8, 106u8, 60u8, 148u8, 55u8,
14731                19u8,
14732            ],
14733            [
14734                172u8, 249u8, 9u8, 95u8, 235u8, 58u8, 55u8, 12u8, 156u8, 246u8, 146u8,
14735                66u8, 28u8, 105u8, 239u8, 50u8, 13u8, 77u8, 181u8, 198u8, 110u8, 106u8,
14736                125u8, 41u8, 199u8, 105u8, 78u8, 176u8, 35u8, 100u8, 252u8, 85u8,
14737            ],
14738            [
14739                173u8, 52u8, 195u8, 7u8, 11u8, 225u8, 223u8, 251u8, 202u8, 164u8, 153u8,
14740                208u8, 0u8, 186u8, 43u8, 141u8, 152u8, 72u8, 174u8, 252u8, 172u8, 48u8,
14741                89u8, 223u8, 36u8, 93u8, 217u8, 92u8, 78u8, 206u8, 20u8, 254u8,
14742            ],
14743        ];
14744    }
14745    #[automatically_derived]
14746    impl alloy_sol_types::SolEventInterface for IAllocationManagerEvents {
14747        const NAME: &'static str = "IAllocationManagerEvents";
14748        const COUNT: usize = 12usize;
14749        fn decode_raw_log(
14750            topics: &[alloy_sol_types::Word],
14751            data: &[u8],
14752        ) -> alloy_sol_types::Result<Self> {
14753            match topics.first().copied() {
14754                Some(
14755                    <AVSMetadataURIUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14756                ) => {
14757                    <AVSMetadataURIUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14758                            topics,
14759                            data,
14760                        )
14761                        .map(Self::AVSMetadataURIUpdated)
14762                }
14763                Some(<AVSRegistrarSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
14764                    <AVSRegistrarSet as alloy_sol_types::SolEvent>::decode_raw_log(
14765                            topics,
14766                            data,
14767                        )
14768                        .map(Self::AVSRegistrarSet)
14769                }
14770                Some(
14771                    <AllocationDelaySet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14772                ) => {
14773                    <AllocationDelaySet as alloy_sol_types::SolEvent>::decode_raw_log(
14774                            topics,
14775                            data,
14776                        )
14777                        .map(Self::AllocationDelaySet)
14778                }
14779                Some(
14780                    <AllocationUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14781                ) => {
14782                    <AllocationUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14783                            topics,
14784                            data,
14785                        )
14786                        .map(Self::AllocationUpdated)
14787                }
14788                Some(
14789                    <EncumberedMagnitudeUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14790                ) => {
14791                    <EncumberedMagnitudeUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14792                            topics,
14793                            data,
14794                        )
14795                        .map(Self::EncumberedMagnitudeUpdated)
14796                }
14797                Some(
14798                    <MaxMagnitudeUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14799                ) => {
14800                    <MaxMagnitudeUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
14801                            topics,
14802                            data,
14803                        )
14804                        .map(Self::MaxMagnitudeUpdated)
14805                }
14806                Some(
14807                    <OperatorAddedToOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14808                ) => {
14809                    <OperatorAddedToOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
14810                            topics,
14811                            data,
14812                        )
14813                        .map(Self::OperatorAddedToOperatorSet)
14814                }
14815                Some(
14816                    <OperatorRemovedFromOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14817                ) => {
14818                    <OperatorRemovedFromOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
14819                            topics,
14820                            data,
14821                        )
14822                        .map(Self::OperatorRemovedFromOperatorSet)
14823                }
14824                Some(
14825                    <OperatorSetCreated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14826                ) => {
14827                    <OperatorSetCreated as alloy_sol_types::SolEvent>::decode_raw_log(
14828                            topics,
14829                            data,
14830                        )
14831                        .map(Self::OperatorSetCreated)
14832                }
14833                Some(<OperatorSlashed as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
14834                    <OperatorSlashed as alloy_sol_types::SolEvent>::decode_raw_log(
14835                            topics,
14836                            data,
14837                        )
14838                        .map(Self::OperatorSlashed)
14839                }
14840                Some(
14841                    <StrategyAddedToOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14842                ) => {
14843                    <StrategyAddedToOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
14844                            topics,
14845                            data,
14846                        )
14847                        .map(Self::StrategyAddedToOperatorSet)
14848                }
14849                Some(
14850                    <StrategyRemovedFromOperatorSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
14851                ) => {
14852                    <StrategyRemovedFromOperatorSet as alloy_sol_types::SolEvent>::decode_raw_log(
14853                            topics,
14854                            data,
14855                        )
14856                        .map(Self::StrategyRemovedFromOperatorSet)
14857                }
14858                _ => {
14859                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
14860                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
14861                        log: alloy_sol_types::private::Box::new(
14862                            alloy_sol_types::private::LogData::new_unchecked(
14863                                topics.to_vec(),
14864                                data.to_vec().into(),
14865                            ),
14866                        ),
14867                    })
14868                }
14869            }
14870        }
14871    }
14872    #[automatically_derived]
14873    impl alloy_sol_types::private::IntoLogData for IAllocationManagerEvents {
14874        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
14875            match self {
14876                Self::AVSMetadataURIUpdated(inner) => {
14877                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14878                }
14879                Self::AVSRegistrarSet(inner) => {
14880                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14881                }
14882                Self::AllocationDelaySet(inner) => {
14883                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14884                }
14885                Self::AllocationUpdated(inner) => {
14886                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14887                }
14888                Self::EncumberedMagnitudeUpdated(inner) => {
14889                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14890                }
14891                Self::MaxMagnitudeUpdated(inner) => {
14892                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14893                }
14894                Self::OperatorAddedToOperatorSet(inner) => {
14895                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14896                }
14897                Self::OperatorRemovedFromOperatorSet(inner) => {
14898                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14899                }
14900                Self::OperatorSetCreated(inner) => {
14901                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14902                }
14903                Self::OperatorSlashed(inner) => {
14904                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14905                }
14906                Self::StrategyAddedToOperatorSet(inner) => {
14907                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14908                }
14909                Self::StrategyRemovedFromOperatorSet(inner) => {
14910                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
14911                }
14912            }
14913        }
14914        fn into_log_data(self) -> alloy_sol_types::private::LogData {
14915            match self {
14916                Self::AVSMetadataURIUpdated(inner) => {
14917                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14918                }
14919                Self::AVSRegistrarSet(inner) => {
14920                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14921                }
14922                Self::AllocationDelaySet(inner) => {
14923                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14924                }
14925                Self::AllocationUpdated(inner) => {
14926                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14927                }
14928                Self::EncumberedMagnitudeUpdated(inner) => {
14929                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14930                }
14931                Self::MaxMagnitudeUpdated(inner) => {
14932                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14933                }
14934                Self::OperatorAddedToOperatorSet(inner) => {
14935                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14936                }
14937                Self::OperatorRemovedFromOperatorSet(inner) => {
14938                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14939                }
14940                Self::OperatorSetCreated(inner) => {
14941                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14942                }
14943                Self::OperatorSlashed(inner) => {
14944                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14945                }
14946                Self::StrategyAddedToOperatorSet(inner) => {
14947                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14948                }
14949                Self::StrategyRemovedFromOperatorSet(inner) => {
14950                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
14951                }
14952            }
14953        }
14954    }
14955    use alloy::contract as alloy_contract;
14956    /**Creates a new wrapper around an on-chain [`IAllocationManager`](self) contract instance.
14957
14958See the [wrapper's documentation](`IAllocationManagerInstance`) for more details.*/
14959    #[inline]
14960    pub const fn new<
14961        P: alloy_contract::private::Provider<N>,
14962        N: alloy_contract::private::Network,
14963    >(
14964        address: alloy_sol_types::private::Address,
14965        provider: P,
14966    ) -> IAllocationManagerInstance<P, N> {
14967        IAllocationManagerInstance::<P, N>::new(address, provider)
14968    }
14969    /**Deploys this contract using the given `provider` and constructor arguments, if any.
14970
14971Returns a new instance of the contract, if the deployment was successful.
14972
14973For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
14974    #[inline]
14975    pub fn deploy<
14976        P: alloy_contract::private::Provider<N>,
14977        N: alloy_contract::private::Network,
14978    >(
14979        provider: P,
14980    ) -> impl ::core::future::Future<
14981        Output = alloy_contract::Result<IAllocationManagerInstance<P, N>>,
14982    > {
14983        IAllocationManagerInstance::<P, N>::deploy(provider)
14984    }
14985    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
14986and constructor arguments, if any.
14987
14988This is a simple wrapper around creating a `RawCallBuilder` with the data set to
14989the bytecode concatenated with the constructor's ABI-encoded arguments.*/
14990    #[inline]
14991    pub fn deploy_builder<
14992        P: alloy_contract::private::Provider<N>,
14993        N: alloy_contract::private::Network,
14994    >(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
14995        IAllocationManagerInstance::<P, N>::deploy_builder(provider)
14996    }
14997    /**A [`IAllocationManager`](self) instance.
14998
14999Contains type-safe methods for interacting with an on-chain instance of the
15000[`IAllocationManager`](self) contract located at a given `address`, using a given
15001provider `P`.
15002
15003If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
15004documentation on how to provide it), the `deploy` and `deploy_builder` methods can
15005be used to deploy a new instance of the contract.
15006
15007See the [module-level documentation](self) for all the available methods.*/
15008    #[derive(Clone)]
15009    pub struct IAllocationManagerInstance<P, N = alloy_contract::private::Ethereum> {
15010        address: alloy_sol_types::private::Address,
15011        provider: P,
15012        _network: ::core::marker::PhantomData<N>,
15013    }
15014    #[automatically_derived]
15015    impl<P, N> ::core::fmt::Debug for IAllocationManagerInstance<P, N> {
15016        #[inline]
15017        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
15018            f.debug_tuple("IAllocationManagerInstance").field(&self.address).finish()
15019        }
15020    }
15021    /// Instantiation and getters/setters.
15022    #[automatically_derived]
15023    impl<
15024        P: alloy_contract::private::Provider<N>,
15025        N: alloy_contract::private::Network,
15026    > IAllocationManagerInstance<P, N> {
15027        /**Creates a new wrapper around an on-chain [`IAllocationManager`](self) contract instance.
15028
15029See the [wrapper's documentation](`IAllocationManagerInstance`) for more details.*/
15030        #[inline]
15031        pub const fn new(
15032            address: alloy_sol_types::private::Address,
15033            provider: P,
15034        ) -> Self {
15035            Self {
15036                address,
15037                provider,
15038                _network: ::core::marker::PhantomData,
15039            }
15040        }
15041        /**Deploys this contract using the given `provider` and constructor arguments, if any.
15042
15043Returns a new instance of the contract, if the deployment was successful.
15044
15045For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
15046        #[inline]
15047        pub async fn deploy(
15048            provider: P,
15049        ) -> alloy_contract::Result<IAllocationManagerInstance<P, N>> {
15050            let call_builder = Self::deploy_builder(provider);
15051            let contract_address = call_builder.deploy().await?;
15052            Ok(Self::new(contract_address, call_builder.provider))
15053        }
15054        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
15055and constructor arguments, if any.
15056
15057This is a simple wrapper around creating a `RawCallBuilder` with the data set to
15058the bytecode concatenated with the constructor's ABI-encoded arguments.*/
15059        #[inline]
15060        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
15061            alloy_contract::RawCallBuilder::new_raw_deploy(
15062                provider,
15063                ::core::clone::Clone::clone(&BYTECODE),
15064            )
15065        }
15066        /// Returns a reference to the address.
15067        #[inline]
15068        pub const fn address(&self) -> &alloy_sol_types::private::Address {
15069            &self.address
15070        }
15071        /// Sets the address.
15072        #[inline]
15073        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
15074            self.address = address;
15075        }
15076        /// Sets the address and returns `self`.
15077        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
15078            self.set_address(address);
15079            self
15080        }
15081        /// Returns a reference to the provider.
15082        #[inline]
15083        pub const fn provider(&self) -> &P {
15084            &self.provider
15085        }
15086    }
15087    impl<P: ::core::clone::Clone, N> IAllocationManagerInstance<&P, N> {
15088        /// Clones the provider and returns a new instance with the cloned provider.
15089        #[inline]
15090        pub fn with_cloned_provider(self) -> IAllocationManagerInstance<P, N> {
15091            IAllocationManagerInstance {
15092                address: self.address,
15093                provider: ::core::clone::Clone::clone(&self.provider),
15094                _network: ::core::marker::PhantomData,
15095            }
15096        }
15097    }
15098    /// Function calls.
15099    #[automatically_derived]
15100    impl<
15101        P: alloy_contract::private::Provider<N>,
15102        N: alloy_contract::private::Network,
15103    > IAllocationManagerInstance<P, N> {
15104        /// Creates a new call builder using this contract instance's provider and address.
15105        ///
15106        /// Note that the call can be any function call, not just those defined in this
15107        /// contract. Prefer using the other methods for building type-safe contract calls.
15108        pub fn call_builder<C: alloy_sol_types::SolCall>(
15109            &self,
15110            call: &C,
15111        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
15112            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
15113        }
15114        ///Creates a new call builder for the [`addStrategiesToOperatorSet`] function.
15115        pub fn addStrategiesToOperatorSet(
15116            &self,
15117            avs: alloy::sol_types::private::Address,
15118            operatorSetId: u32,
15119            strategies: alloy::sol_types::private::Vec<
15120                alloy::sol_types::private::Address,
15121            >,
15122        ) -> alloy_contract::SolCallBuilder<&P, addStrategiesToOperatorSetCall, N> {
15123            self.call_builder(
15124                &addStrategiesToOperatorSetCall {
15125                    avs,
15126                    operatorSetId,
15127                    strategies,
15128                },
15129            )
15130        }
15131        ///Creates a new call builder for the [`clearDeallocationQueue`] function.
15132        pub fn clearDeallocationQueue(
15133            &self,
15134            operator: alloy::sol_types::private::Address,
15135            strategies: alloy::sol_types::private::Vec<
15136                alloy::sol_types::private::Address,
15137            >,
15138            numToClear: alloy::sol_types::private::Vec<u16>,
15139        ) -> alloy_contract::SolCallBuilder<&P, clearDeallocationQueueCall, N> {
15140            self.call_builder(
15141                &clearDeallocationQueueCall {
15142                    operator,
15143                    strategies,
15144                    numToClear,
15145                },
15146            )
15147        }
15148        ///Creates a new call builder for the [`createOperatorSets`] function.
15149        pub fn createOperatorSets(
15150            &self,
15151            avs: alloy::sol_types::private::Address,
15152            params: alloy::sol_types::private::Vec<
15153                <IAllocationManagerTypes::CreateSetParams as alloy::sol_types::SolType>::RustType,
15154            >,
15155        ) -> alloy_contract::SolCallBuilder<&P, createOperatorSetsCall, N> {
15156            self.call_builder(
15157                &createOperatorSetsCall {
15158                    avs,
15159                    params,
15160                },
15161            )
15162        }
15163        ///Creates a new call builder for the [`deregisterFromOperatorSets`] function.
15164        pub fn deregisterFromOperatorSets(
15165            &self,
15166            params: <IAllocationManagerTypes::DeregisterParams as alloy::sol_types::SolType>::RustType,
15167        ) -> alloy_contract::SolCallBuilder<&P, deregisterFromOperatorSetsCall, N> {
15168            self.call_builder(
15169                &deregisterFromOperatorSetsCall {
15170                    params,
15171                },
15172            )
15173        }
15174        ///Creates a new call builder for the [`getAVSRegistrar`] function.
15175        pub fn getAVSRegistrar(
15176            &self,
15177            avs: alloy::sol_types::private::Address,
15178        ) -> alloy_contract::SolCallBuilder<&P, getAVSRegistrarCall, N> {
15179            self.call_builder(&getAVSRegistrarCall { avs })
15180        }
15181        ///Creates a new call builder for the [`getAllocatableMagnitude`] function.
15182        pub fn getAllocatableMagnitude(
15183            &self,
15184            operator: alloy::sol_types::private::Address,
15185            strategy: alloy::sol_types::private::Address,
15186        ) -> alloy_contract::SolCallBuilder<&P, getAllocatableMagnitudeCall, N> {
15187            self.call_builder(
15188                &getAllocatableMagnitudeCall {
15189                    operator,
15190                    strategy,
15191                },
15192            )
15193        }
15194        ///Creates a new call builder for the [`getAllocatedSets`] function.
15195        pub fn getAllocatedSets(
15196            &self,
15197            operator: alloy::sol_types::private::Address,
15198        ) -> alloy_contract::SolCallBuilder<&P, getAllocatedSetsCall, N> {
15199            self.call_builder(&getAllocatedSetsCall { operator })
15200        }
15201        ///Creates a new call builder for the [`getAllocatedStake`] function.
15202        pub fn getAllocatedStake(
15203            &self,
15204            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15205            operators: alloy::sol_types::private::Vec<
15206                alloy::sol_types::private::Address,
15207            >,
15208            strategies: alloy::sol_types::private::Vec<
15209                alloy::sol_types::private::Address,
15210            >,
15211        ) -> alloy_contract::SolCallBuilder<&P, getAllocatedStakeCall, N> {
15212            self.call_builder(
15213                &getAllocatedStakeCall {
15214                    operatorSet,
15215                    operators,
15216                    strategies,
15217                },
15218            )
15219        }
15220        ///Creates a new call builder for the [`getAllocatedStrategies`] function.
15221        pub fn getAllocatedStrategies(
15222            &self,
15223            operator: alloy::sol_types::private::Address,
15224            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15225        ) -> alloy_contract::SolCallBuilder<&P, getAllocatedStrategiesCall, N> {
15226            self.call_builder(
15227                &getAllocatedStrategiesCall {
15228                    operator,
15229                    operatorSet,
15230                },
15231            )
15232        }
15233        ///Creates a new call builder for the [`getAllocation`] function.
15234        pub fn getAllocation(
15235            &self,
15236            operator: alloy::sol_types::private::Address,
15237            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15238            strategy: alloy::sol_types::private::Address,
15239        ) -> alloy_contract::SolCallBuilder<&P, getAllocationCall, N> {
15240            self.call_builder(
15241                &getAllocationCall {
15242                    operator,
15243                    operatorSet,
15244                    strategy,
15245                },
15246            )
15247        }
15248        ///Creates a new call builder for the [`getAllocationDelay`] function.
15249        pub fn getAllocationDelay(
15250            &self,
15251            operator: alloy::sol_types::private::Address,
15252        ) -> alloy_contract::SolCallBuilder<&P, getAllocationDelayCall, N> {
15253            self.call_builder(&getAllocationDelayCall { operator })
15254        }
15255        ///Creates a new call builder for the [`getAllocations`] function.
15256        pub fn getAllocations(
15257            &self,
15258            operators: alloy::sol_types::private::Vec<
15259                alloy::sol_types::private::Address,
15260            >,
15261            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15262            strategy: alloy::sol_types::private::Address,
15263        ) -> alloy_contract::SolCallBuilder<&P, getAllocationsCall, N> {
15264            self.call_builder(
15265                &getAllocationsCall {
15266                    operators,
15267                    operatorSet,
15268                    strategy,
15269                },
15270            )
15271        }
15272        ///Creates a new call builder for the [`getEncumberedMagnitude`] function.
15273        pub fn getEncumberedMagnitude(
15274            &self,
15275            operator: alloy::sol_types::private::Address,
15276            strategy: alloy::sol_types::private::Address,
15277        ) -> alloy_contract::SolCallBuilder<&P, getEncumberedMagnitudeCall, N> {
15278            self.call_builder(
15279                &getEncumberedMagnitudeCall {
15280                    operator,
15281                    strategy,
15282                },
15283            )
15284        }
15285        ///Creates a new call builder for the [`getMaxMagnitude`] function.
15286        pub fn getMaxMagnitude(
15287            &self,
15288            operator: alloy::sol_types::private::Address,
15289            strategy: alloy::sol_types::private::Address,
15290        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudeCall, N> {
15291            self.call_builder(
15292                &getMaxMagnitudeCall {
15293                    operator,
15294                    strategy,
15295                },
15296            )
15297        }
15298        ///Creates a new call builder for the [`getMaxMagnitudes_0`] function.
15299        pub fn getMaxMagnitudes_0(
15300            &self,
15301            operators: alloy::sol_types::private::Vec<
15302                alloy::sol_types::private::Address,
15303            >,
15304            strategy: alloy::sol_types::private::Address,
15305        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudes_0Call, N> {
15306            self.call_builder(
15307                &getMaxMagnitudes_0Call {
15308                    operators,
15309                    strategy,
15310                },
15311            )
15312        }
15313        ///Creates a new call builder for the [`getMaxMagnitudes_1`] function.
15314        pub fn getMaxMagnitudes_1(
15315            &self,
15316            operator: alloy::sol_types::private::Address,
15317            strategies: alloy::sol_types::private::Vec<
15318                alloy::sol_types::private::Address,
15319            >,
15320        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudes_1Call, N> {
15321            self.call_builder(
15322                &getMaxMagnitudes_1Call {
15323                    operator,
15324                    strategies,
15325                },
15326            )
15327        }
15328        ///Creates a new call builder for the [`getMaxMagnitudesAtBlock`] function.
15329        pub fn getMaxMagnitudesAtBlock(
15330            &self,
15331            operator: alloy::sol_types::private::Address,
15332            strategies: alloy::sol_types::private::Vec<
15333                alloy::sol_types::private::Address,
15334            >,
15335            blockNumber: u32,
15336        ) -> alloy_contract::SolCallBuilder<&P, getMaxMagnitudesAtBlockCall, N> {
15337            self.call_builder(
15338                &getMaxMagnitudesAtBlockCall {
15339                    operator,
15340                    strategies,
15341                    blockNumber,
15342                },
15343            )
15344        }
15345        ///Creates a new call builder for the [`getMemberCount`] function.
15346        pub fn getMemberCount(
15347            &self,
15348            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15349        ) -> alloy_contract::SolCallBuilder<&P, getMemberCountCall, N> {
15350            self.call_builder(&getMemberCountCall { operatorSet })
15351        }
15352        ///Creates a new call builder for the [`getMembers`] function.
15353        pub fn getMembers(
15354            &self,
15355            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15356        ) -> alloy_contract::SolCallBuilder<&P, getMembersCall, N> {
15357            self.call_builder(&getMembersCall { operatorSet })
15358        }
15359        ///Creates a new call builder for the [`getMinimumSlashableStake`] function.
15360        pub fn getMinimumSlashableStake(
15361            &self,
15362            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15363            operators: alloy::sol_types::private::Vec<
15364                alloy::sol_types::private::Address,
15365            >,
15366            strategies: alloy::sol_types::private::Vec<
15367                alloy::sol_types::private::Address,
15368            >,
15369            futureBlock: u32,
15370        ) -> alloy_contract::SolCallBuilder<&P, getMinimumSlashableStakeCall, N> {
15371            self.call_builder(
15372                &getMinimumSlashableStakeCall {
15373                    operatorSet,
15374                    operators,
15375                    strategies,
15376                    futureBlock,
15377                },
15378            )
15379        }
15380        ///Creates a new call builder for the [`getOperatorSetCount`] function.
15381        pub fn getOperatorSetCount(
15382            &self,
15383            avs: alloy::sol_types::private::Address,
15384        ) -> alloy_contract::SolCallBuilder<&P, getOperatorSetCountCall, N> {
15385            self.call_builder(&getOperatorSetCountCall { avs })
15386        }
15387        ///Creates a new call builder for the [`getRegisteredSets`] function.
15388        pub fn getRegisteredSets(
15389            &self,
15390            operator: alloy::sol_types::private::Address,
15391        ) -> alloy_contract::SolCallBuilder<&P, getRegisteredSetsCall, N> {
15392            self.call_builder(&getRegisteredSetsCall { operator })
15393        }
15394        ///Creates a new call builder for the [`getStrategiesInOperatorSet`] function.
15395        pub fn getStrategiesInOperatorSet(
15396            &self,
15397            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15398        ) -> alloy_contract::SolCallBuilder<&P, getStrategiesInOperatorSetCall, N> {
15399            self.call_builder(
15400                &getStrategiesInOperatorSetCall {
15401                    operatorSet,
15402                },
15403            )
15404        }
15405        ///Creates a new call builder for the [`getStrategyAllocations`] function.
15406        pub fn getStrategyAllocations(
15407            &self,
15408            operator: alloy::sol_types::private::Address,
15409            strategy: alloy::sol_types::private::Address,
15410        ) -> alloy_contract::SolCallBuilder<&P, getStrategyAllocationsCall, N> {
15411            self.call_builder(
15412                &getStrategyAllocationsCall {
15413                    operator,
15414                    strategy,
15415                },
15416            )
15417        }
15418        ///Creates a new call builder for the [`initialize`] function.
15419        pub fn initialize(
15420            &self,
15421            initialOwner: alloy::sol_types::private::Address,
15422            initialPausedStatus: alloy::sol_types::private::primitives::aliases::U256,
15423        ) -> alloy_contract::SolCallBuilder<&P, initializeCall, N> {
15424            self.call_builder(
15425                &initializeCall {
15426                    initialOwner,
15427                    initialPausedStatus,
15428                },
15429            )
15430        }
15431        ///Creates a new call builder for the [`isMemberOfOperatorSet`] function.
15432        pub fn isMemberOfOperatorSet(
15433            &self,
15434            operator: alloy::sol_types::private::Address,
15435            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15436        ) -> alloy_contract::SolCallBuilder<&P, isMemberOfOperatorSetCall, N> {
15437            self.call_builder(
15438                &isMemberOfOperatorSetCall {
15439                    operator,
15440                    operatorSet,
15441                },
15442            )
15443        }
15444        ///Creates a new call builder for the [`isOperatorSet`] function.
15445        pub fn isOperatorSet(
15446            &self,
15447            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15448        ) -> alloy_contract::SolCallBuilder<&P, isOperatorSetCall, N> {
15449            self.call_builder(&isOperatorSetCall { operatorSet })
15450        }
15451        ///Creates a new call builder for the [`isOperatorSlashable`] function.
15452        pub fn isOperatorSlashable(
15453            &self,
15454            operator: alloy::sol_types::private::Address,
15455            operatorSet: <OperatorSet as alloy::sol_types::SolType>::RustType,
15456        ) -> alloy_contract::SolCallBuilder<&P, isOperatorSlashableCall, N> {
15457            self.call_builder(
15458                &isOperatorSlashableCall {
15459                    operator,
15460                    operatorSet,
15461                },
15462            )
15463        }
15464        ///Creates a new call builder for the [`modifyAllocations`] function.
15465        pub fn modifyAllocations(
15466            &self,
15467            operator: alloy::sol_types::private::Address,
15468            params: alloy::sol_types::private::Vec<
15469                <IAllocationManagerTypes::AllocateParams as alloy::sol_types::SolType>::RustType,
15470            >,
15471        ) -> alloy_contract::SolCallBuilder<&P, modifyAllocationsCall, N> {
15472            self.call_builder(
15473                &modifyAllocationsCall {
15474                    operator,
15475                    params,
15476                },
15477            )
15478        }
15479        ///Creates a new call builder for the [`registerForOperatorSets`] function.
15480        pub fn registerForOperatorSets(
15481            &self,
15482            operator: alloy::sol_types::private::Address,
15483            params: <IAllocationManagerTypes::RegisterParams as alloy::sol_types::SolType>::RustType,
15484        ) -> alloy_contract::SolCallBuilder<&P, registerForOperatorSetsCall, N> {
15485            self.call_builder(
15486                &registerForOperatorSetsCall {
15487                    operator,
15488                    params,
15489                },
15490            )
15491        }
15492        ///Creates a new call builder for the [`removeStrategiesFromOperatorSet`] function.
15493        pub fn removeStrategiesFromOperatorSet(
15494            &self,
15495            avs: alloy::sol_types::private::Address,
15496            operatorSetId: u32,
15497            strategies: alloy::sol_types::private::Vec<
15498                alloy::sol_types::private::Address,
15499            >,
15500        ) -> alloy_contract::SolCallBuilder<&P, removeStrategiesFromOperatorSetCall, N> {
15501            self.call_builder(
15502                &removeStrategiesFromOperatorSetCall {
15503                    avs,
15504                    operatorSetId,
15505                    strategies,
15506                },
15507            )
15508        }
15509        ///Creates a new call builder for the [`setAVSRegistrar`] function.
15510        pub fn setAVSRegistrar(
15511            &self,
15512            avs: alloy::sol_types::private::Address,
15513            registrar: alloy::sol_types::private::Address,
15514        ) -> alloy_contract::SolCallBuilder<&P, setAVSRegistrarCall, N> {
15515            self.call_builder(
15516                &setAVSRegistrarCall {
15517                    avs,
15518                    registrar,
15519                },
15520            )
15521        }
15522        ///Creates a new call builder for the [`setAllocationDelay`] function.
15523        pub fn setAllocationDelay(
15524            &self,
15525            operator: alloy::sol_types::private::Address,
15526            delay: u32,
15527        ) -> alloy_contract::SolCallBuilder<&P, setAllocationDelayCall, N> {
15528            self.call_builder(
15529                &setAllocationDelayCall {
15530                    operator,
15531                    delay,
15532                },
15533            )
15534        }
15535        ///Creates a new call builder for the [`slashOperator`] function.
15536        pub fn slashOperator(
15537            &self,
15538            avs: alloy::sol_types::private::Address,
15539            params: <IAllocationManagerTypes::SlashingParams as alloy::sol_types::SolType>::RustType,
15540        ) -> alloy_contract::SolCallBuilder<&P, slashOperatorCall, N> {
15541            self.call_builder(&slashOperatorCall { avs, params })
15542        }
15543        ///Creates a new call builder for the [`updateAVSMetadataURI`] function.
15544        pub fn updateAVSMetadataURI(
15545            &self,
15546            avs: alloy::sol_types::private::Address,
15547            metadataURI: alloy::sol_types::private::String,
15548        ) -> alloy_contract::SolCallBuilder<&P, updateAVSMetadataURICall, N> {
15549            self.call_builder(
15550                &updateAVSMetadataURICall {
15551                    avs,
15552                    metadataURI,
15553                },
15554            )
15555        }
15556        ///Creates a new call builder for the [`version`] function.
15557        pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
15558            self.call_builder(&versionCall)
15559        }
15560    }
15561    /// Event filters.
15562    #[automatically_derived]
15563    impl<
15564        P: alloy_contract::private::Provider<N>,
15565        N: alloy_contract::private::Network,
15566    > IAllocationManagerInstance<P, N> {
15567        /// Creates a new event filter using this contract instance's provider and address.
15568        ///
15569        /// Note that the type can be any event, not just those defined in this contract.
15570        /// Prefer using the other methods for building type-safe event filters.
15571        pub fn event_filter<E: alloy_sol_types::SolEvent>(
15572            &self,
15573        ) -> alloy_contract::Event<&P, E, N> {
15574            alloy_contract::Event::new_sol(&self.provider, &self.address)
15575        }
15576        ///Creates a new event filter for the [`AVSMetadataURIUpdated`] event.
15577        pub fn AVSMetadataURIUpdated_filter(
15578            &self,
15579        ) -> alloy_contract::Event<&P, AVSMetadataURIUpdated, N> {
15580            self.event_filter::<AVSMetadataURIUpdated>()
15581        }
15582        ///Creates a new event filter for the [`AVSRegistrarSet`] event.
15583        pub fn AVSRegistrarSet_filter(
15584            &self,
15585        ) -> alloy_contract::Event<&P, AVSRegistrarSet, N> {
15586            self.event_filter::<AVSRegistrarSet>()
15587        }
15588        ///Creates a new event filter for the [`AllocationDelaySet`] event.
15589        pub fn AllocationDelaySet_filter(
15590            &self,
15591        ) -> alloy_contract::Event<&P, AllocationDelaySet, N> {
15592            self.event_filter::<AllocationDelaySet>()
15593        }
15594        ///Creates a new event filter for the [`AllocationUpdated`] event.
15595        pub fn AllocationUpdated_filter(
15596            &self,
15597        ) -> alloy_contract::Event<&P, AllocationUpdated, N> {
15598            self.event_filter::<AllocationUpdated>()
15599        }
15600        ///Creates a new event filter for the [`EncumberedMagnitudeUpdated`] event.
15601        pub fn EncumberedMagnitudeUpdated_filter(
15602            &self,
15603        ) -> alloy_contract::Event<&P, EncumberedMagnitudeUpdated, N> {
15604            self.event_filter::<EncumberedMagnitudeUpdated>()
15605        }
15606        ///Creates a new event filter for the [`MaxMagnitudeUpdated`] event.
15607        pub fn MaxMagnitudeUpdated_filter(
15608            &self,
15609        ) -> alloy_contract::Event<&P, MaxMagnitudeUpdated, N> {
15610            self.event_filter::<MaxMagnitudeUpdated>()
15611        }
15612        ///Creates a new event filter for the [`OperatorAddedToOperatorSet`] event.
15613        pub fn OperatorAddedToOperatorSet_filter(
15614            &self,
15615        ) -> alloy_contract::Event<&P, OperatorAddedToOperatorSet, N> {
15616            self.event_filter::<OperatorAddedToOperatorSet>()
15617        }
15618        ///Creates a new event filter for the [`OperatorRemovedFromOperatorSet`] event.
15619        pub fn OperatorRemovedFromOperatorSet_filter(
15620            &self,
15621        ) -> alloy_contract::Event<&P, OperatorRemovedFromOperatorSet, N> {
15622            self.event_filter::<OperatorRemovedFromOperatorSet>()
15623        }
15624        ///Creates a new event filter for the [`OperatorSetCreated`] event.
15625        pub fn OperatorSetCreated_filter(
15626            &self,
15627        ) -> alloy_contract::Event<&P, OperatorSetCreated, N> {
15628            self.event_filter::<OperatorSetCreated>()
15629        }
15630        ///Creates a new event filter for the [`OperatorSlashed`] event.
15631        pub fn OperatorSlashed_filter(
15632            &self,
15633        ) -> alloy_contract::Event<&P, OperatorSlashed, N> {
15634            self.event_filter::<OperatorSlashed>()
15635        }
15636        ///Creates a new event filter for the [`StrategyAddedToOperatorSet`] event.
15637        pub fn StrategyAddedToOperatorSet_filter(
15638            &self,
15639        ) -> alloy_contract::Event<&P, StrategyAddedToOperatorSet, N> {
15640            self.event_filter::<StrategyAddedToOperatorSet>()
15641        }
15642        ///Creates a new event filter for the [`StrategyRemovedFromOperatorSet`] event.
15643        pub fn StrategyRemovedFromOperatorSet_filter(
15644            &self,
15645        ) -> alloy_contract::Event<&P, StrategyRemovedFromOperatorSet, N> {
15646            self.event_filter::<StrategyRemovedFromOperatorSet>()
15647        }
15648    }
15649}
eigenlayer_contract_deployer/bindings/core/i_allocation_manager.rs

eigenlayer_contract_deployer/bindings/core/
i_allocation_manager.rs
