fluence_marketplace_api_draft/
workermanager.rs

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

fluence_marketplace_api_draft/
workermanager.rs
