fluence_marketplace_api_draft/
config.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/**
642
643Generated by the following Solidity interface...
644```solidity
645library Common {
646    struct CIDV1 {
647        bytes4 prefixes;
648        bytes32 hash;
649    }
650}
651
652library IConfig {
653    type AccessType is uint8;
654}
655
656interface Config {
657    error InvalidInitialization();
658    error NotInitializing();
659    error OwnableInvalidOwner(address owner);
660    error OwnableUnauthorizedAccount(address account);
661
662    event AppCIDChanged(Common.CIDV1 newAppCID);
663    event Initialized(uint64 version);
664    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
665    event ProviderAddedToAccessList(address provider);
666    event ProviderRemovedFromAccessList(address provider);
667    event ProvidersAccessTypeChanged(IConfig.AccessType newAccessType);
668
669    function addProviderToAccessList(address provider) external;
670    function appCID() external view returns (Common.CIDV1 memory);
671    function changeProvidersAccessType(IConfig.AccessType accessType) external;
672    function creationBlock() external view returns (uint256);
673    function cuCountPerWorker() external view returns (uint256);
674    function effectors() external view returns (Common.CIDV1[] memory);
675    function isProviderAllowed(address account) external view returns (bool);
676    function maxWorkersPerProvider() external view returns (uint256);
677    function minWorkers() external view returns (uint256);
678    function owner() external view returns (address);
679    function paymentToken() external view returns (address);
680    function pricePerCuPerEpoch() external view returns (uint256);
681    function providersAccessType() external view returns (IConfig.AccessType);
682    function removeProviderFromAccessList(address provider) external;
683    function renounceOwnership() external;
684    function setAppCID(Common.CIDV1 memory appCID_) external;
685    function targetWorkers() external view returns (uint256);
686    function transferOwnership(address newOwner) external;
687}
688```
689
690...which was generated by the following JSON ABI:
691```json
692[
693  {
694    "type": "function",
695    "name": "addProviderToAccessList",
696    "inputs": [
697      {
698        "name": "provider",
699        "type": "address",
700        "internalType": "address"
701      }
702    ],
703    "outputs": [],
704    "stateMutability": "nonpayable"
705  },
706  {
707    "type": "function",
708    "name": "appCID",
709    "inputs": [],
710    "outputs": [
711      {
712        "name": "",
713        "type": "tuple",
714        "internalType": "struct Common.CIDV1",
715        "components": [
716          {
717            "name": "prefixes",
718            "type": "bytes4",
719            "internalType": "bytes4"
720          },
721          {
722            "name": "hash",
723            "type": "bytes32",
724            "internalType": "bytes32"
725          }
726        ]
727      }
728    ],
729    "stateMutability": "view"
730  },
731  {
732    "type": "function",
733    "name": "changeProvidersAccessType",
734    "inputs": [
735      {
736        "name": "accessType",
737        "type": "uint8",
738        "internalType": "enum IConfig.AccessType"
739      }
740    ],
741    "outputs": [],
742    "stateMutability": "nonpayable"
743  },
744  {
745    "type": "function",
746    "name": "creationBlock",
747    "inputs": [],
748    "outputs": [
749      {
750        "name": "",
751        "type": "uint256",
752        "internalType": "uint256"
753      }
754    ],
755    "stateMutability": "view"
756  },
757  {
758    "type": "function",
759    "name": "cuCountPerWorker",
760    "inputs": [],
761    "outputs": [
762      {
763        "name": "",
764        "type": "uint256",
765        "internalType": "uint256"
766      }
767    ],
768    "stateMutability": "view"
769  },
770  {
771    "type": "function",
772    "name": "effectors",
773    "inputs": [],
774    "outputs": [
775      {
776        "name": "",
777        "type": "tuple[]",
778        "internalType": "struct Common.CIDV1[]",
779        "components": [
780          {
781            "name": "prefixes",
782            "type": "bytes4",
783            "internalType": "bytes4"
784          },
785          {
786            "name": "hash",
787            "type": "bytes32",
788            "internalType": "bytes32"
789          }
790        ]
791      }
792    ],
793    "stateMutability": "view"
794  },
795  {
796    "type": "function",
797    "name": "isProviderAllowed",
798    "inputs": [
799      {
800        "name": "account",
801        "type": "address",
802        "internalType": "address"
803      }
804    ],
805    "outputs": [
806      {
807        "name": "",
808        "type": "bool",
809        "internalType": "bool"
810      }
811    ],
812    "stateMutability": "view"
813  },
814  {
815    "type": "function",
816    "name": "maxWorkersPerProvider",
817    "inputs": [],
818    "outputs": [
819      {
820        "name": "",
821        "type": "uint256",
822        "internalType": "uint256"
823      }
824    ],
825    "stateMutability": "view"
826  },
827  {
828    "type": "function",
829    "name": "minWorkers",
830    "inputs": [],
831    "outputs": [
832      {
833        "name": "",
834        "type": "uint256",
835        "internalType": "uint256"
836      }
837    ],
838    "stateMutability": "view"
839  },
840  {
841    "type": "function",
842    "name": "owner",
843    "inputs": [],
844    "outputs": [
845      {
846        "name": "",
847        "type": "address",
848        "internalType": "address"
849      }
850    ],
851    "stateMutability": "view"
852  },
853  {
854    "type": "function",
855    "name": "paymentToken",
856    "inputs": [],
857    "outputs": [
858      {
859        "name": "",
860        "type": "address",
861        "internalType": "contract IERC20"
862      }
863    ],
864    "stateMutability": "view"
865  },
866  {
867    "type": "function",
868    "name": "pricePerCuPerEpoch",
869    "inputs": [],
870    "outputs": [
871      {
872        "name": "",
873        "type": "uint256",
874        "internalType": "uint256"
875      }
876    ],
877    "stateMutability": "view"
878  },
879  {
880    "type": "function",
881    "name": "providersAccessType",
882    "inputs": [],
883    "outputs": [
884      {
885        "name": "",
886        "type": "uint8",
887        "internalType": "enum IConfig.AccessType"
888      }
889    ],
890    "stateMutability": "view"
891  },
892  {
893    "type": "function",
894    "name": "removeProviderFromAccessList",
895    "inputs": [
896      {
897        "name": "provider",
898        "type": "address",
899        "internalType": "address"
900      }
901    ],
902    "outputs": [],
903    "stateMutability": "nonpayable"
904  },
905  {
906    "type": "function",
907    "name": "renounceOwnership",
908    "inputs": [],
909    "outputs": [],
910    "stateMutability": "nonpayable"
911  },
912  {
913    "type": "function",
914    "name": "setAppCID",
915    "inputs": [
916      {
917        "name": "appCID_",
918        "type": "tuple",
919        "internalType": "struct Common.CIDV1",
920        "components": [
921          {
922            "name": "prefixes",
923            "type": "bytes4",
924            "internalType": "bytes4"
925          },
926          {
927            "name": "hash",
928            "type": "bytes32",
929            "internalType": "bytes32"
930          }
931        ]
932      }
933    ],
934    "outputs": [],
935    "stateMutability": "nonpayable"
936  },
937  {
938    "type": "function",
939    "name": "targetWorkers",
940    "inputs": [],
941    "outputs": [
942      {
943        "name": "",
944        "type": "uint256",
945        "internalType": "uint256"
946      }
947    ],
948    "stateMutability": "view"
949  },
950  {
951    "type": "function",
952    "name": "transferOwnership",
953    "inputs": [
954      {
955        "name": "newOwner",
956        "type": "address",
957        "internalType": "address"
958      }
959    ],
960    "outputs": [],
961    "stateMutability": "nonpayable"
962  },
963  {
964    "type": "event",
965    "name": "AppCIDChanged",
966    "inputs": [
967      {
968        "name": "newAppCID",
969        "type": "tuple",
970        "indexed": false,
971        "internalType": "struct Common.CIDV1",
972        "components": [
973          {
974            "name": "prefixes",
975            "type": "bytes4",
976            "internalType": "bytes4"
977          },
978          {
979            "name": "hash",
980            "type": "bytes32",
981            "internalType": "bytes32"
982          }
983        ]
984      }
985    ],
986    "anonymous": false
987  },
988  {
989    "type": "event",
990    "name": "Initialized",
991    "inputs": [
992      {
993        "name": "version",
994        "type": "uint64",
995        "indexed": false,
996        "internalType": "uint64"
997      }
998    ],
999    "anonymous": false
1000  },
1001  {
1002    "type": "event",
1003    "name": "OwnershipTransferred",
1004    "inputs": [
1005      {
1006        "name": "previousOwner",
1007        "type": "address",
1008        "indexed": true,
1009        "internalType": "address"
1010      },
1011      {
1012        "name": "newOwner",
1013        "type": "address",
1014        "indexed": true,
1015        "internalType": "address"
1016      }
1017    ],
1018    "anonymous": false
1019  },
1020  {
1021    "type": "event",
1022    "name": "ProviderAddedToAccessList",
1023    "inputs": [
1024      {
1025        "name": "provider",
1026        "type": "address",
1027        "indexed": false,
1028        "internalType": "address"
1029      }
1030    ],
1031    "anonymous": false
1032  },
1033  {
1034    "type": "event",
1035    "name": "ProviderRemovedFromAccessList",
1036    "inputs": [
1037      {
1038        "name": "provider",
1039        "type": "address",
1040        "indexed": false,
1041        "internalType": "address"
1042      }
1043    ],
1044    "anonymous": false
1045  },
1046  {
1047    "type": "event",
1048    "name": "ProvidersAccessTypeChanged",
1049    "inputs": [
1050      {
1051        "name": "newAccessType",
1052        "type": "uint8",
1053        "indexed": false,
1054        "internalType": "enum IConfig.AccessType"
1055      }
1056    ],
1057    "anonymous": false
1058  },
1059  {
1060    "type": "error",
1061    "name": "InvalidInitialization",
1062    "inputs": []
1063  },
1064  {
1065    "type": "error",
1066    "name": "NotInitializing",
1067    "inputs": []
1068  },
1069  {
1070    "type": "error",
1071    "name": "OwnableInvalidOwner",
1072    "inputs": [
1073      {
1074        "name": "owner",
1075        "type": "address",
1076        "internalType": "address"
1077      }
1078    ]
1079  },
1080  {
1081    "type": "error",
1082    "name": "OwnableUnauthorizedAccount",
1083    "inputs": [
1084      {
1085        "name": "account",
1086        "type": "address",
1087        "internalType": "address"
1088      }
1089    ]
1090  }
1091]
1092```*/
1093#[allow(
1094    non_camel_case_types,
1095    non_snake_case,
1096    clippy::pub_underscore_fields,
1097    clippy::style,
1098    clippy::empty_structs_with_brackets
1099)]
1100pub mod Config {
1101    use super::*;
1102    use alloy::sol_types as alloy_sol_types;
1103    /// The creation / init bytecode of the contract.
1104    ///
1105    /// ```text
1106    ///0x
1107    /// ```
1108    #[rustfmt::skip]
1109    #[allow(clippy::all)]
1110    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1111        b"",
1112    );
1113    /// The runtime bytecode of the contract, as deployed on the network.
1114    ///
1115    /// ```text
1116    ///0x
1117    /// ```
1118    #[rustfmt::skip]
1119    #[allow(clippy::all)]
1120    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
1121        b"",
1122    );
1123    /**Custom error with signature `InvalidInitialization()` and selector `0xf92ee8a9`.
1124```solidity
1125error InvalidInitialization();
1126```*/
1127    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1128    #[derive(Clone)]
1129    pub struct InvalidInitialization {}
1130    #[allow(
1131        non_camel_case_types,
1132        non_snake_case,
1133        clippy::pub_underscore_fields,
1134        clippy::style
1135    )]
1136    const _: () = {
1137        use alloy::sol_types as alloy_sol_types;
1138        #[doc(hidden)]
1139        type UnderlyingSolTuple<'a> = ();
1140        #[doc(hidden)]
1141        type UnderlyingRustTuple<'a> = ();
1142        #[cfg(test)]
1143        #[allow(dead_code, unreachable_patterns)]
1144        fn _type_assertion(
1145            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1146        ) {
1147            match _t {
1148                alloy_sol_types::private::AssertTypeEq::<
1149                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1150                >(_) => {}
1151            }
1152        }
1153        #[automatically_derived]
1154        #[doc(hidden)]
1155        impl ::core::convert::From<InvalidInitialization> for UnderlyingRustTuple<'_> {
1156            fn from(value: InvalidInitialization) -> Self {
1157                ()
1158            }
1159        }
1160        #[automatically_derived]
1161        #[doc(hidden)]
1162        impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidInitialization {
1163            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1164                Self {}
1165            }
1166        }
1167        #[automatically_derived]
1168        impl alloy_sol_types::SolError for InvalidInitialization {
1169            type Parameters<'a> = UnderlyingSolTuple<'a>;
1170            type Token<'a> = <Self::Parameters<
1171                'a,
1172            > as alloy_sol_types::SolType>::Token<'a>;
1173            const SIGNATURE: &'static str = "InvalidInitialization()";
1174            const SELECTOR: [u8; 4] = [249u8, 46u8, 232u8, 169u8];
1175            #[inline]
1176            fn new<'a>(
1177                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1178            ) -> Self {
1179                tuple.into()
1180            }
1181            #[inline]
1182            fn tokenize(&self) -> Self::Token<'_> {
1183                ()
1184            }
1185        }
1186    };
1187    /**Custom error with signature `NotInitializing()` and selector `0xd7e6bcf8`.
1188```solidity
1189error NotInitializing();
1190```*/
1191    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1192    #[derive(Clone)]
1193    pub struct NotInitializing {}
1194    #[allow(
1195        non_camel_case_types,
1196        non_snake_case,
1197        clippy::pub_underscore_fields,
1198        clippy::style
1199    )]
1200    const _: () = {
1201        use alloy::sol_types as alloy_sol_types;
1202        #[doc(hidden)]
1203        type UnderlyingSolTuple<'a> = ();
1204        #[doc(hidden)]
1205        type UnderlyingRustTuple<'a> = ();
1206        #[cfg(test)]
1207        #[allow(dead_code, unreachable_patterns)]
1208        fn _type_assertion(
1209            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1210        ) {
1211            match _t {
1212                alloy_sol_types::private::AssertTypeEq::<
1213                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1214                >(_) => {}
1215            }
1216        }
1217        #[automatically_derived]
1218        #[doc(hidden)]
1219        impl ::core::convert::From<NotInitializing> for UnderlyingRustTuple<'_> {
1220            fn from(value: NotInitializing) -> Self {
1221                ()
1222            }
1223        }
1224        #[automatically_derived]
1225        #[doc(hidden)]
1226        impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotInitializing {
1227            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1228                Self {}
1229            }
1230        }
1231        #[automatically_derived]
1232        impl alloy_sol_types::SolError for NotInitializing {
1233            type Parameters<'a> = UnderlyingSolTuple<'a>;
1234            type Token<'a> = <Self::Parameters<
1235                'a,
1236            > as alloy_sol_types::SolType>::Token<'a>;
1237            const SIGNATURE: &'static str = "NotInitializing()";
1238            const SELECTOR: [u8; 4] = [215u8, 230u8, 188u8, 248u8];
1239            #[inline]
1240            fn new<'a>(
1241                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1242            ) -> Self {
1243                tuple.into()
1244            }
1245            #[inline]
1246            fn tokenize(&self) -> Self::Token<'_> {
1247                ()
1248            }
1249        }
1250    };
1251    /**Custom error with signature `OwnableInvalidOwner(address)` and selector `0x1e4fbdf7`.
1252```solidity
1253error OwnableInvalidOwner(address owner);
1254```*/
1255    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1256    #[derive(Clone)]
1257    pub struct OwnableInvalidOwner {
1258        #[allow(missing_docs)]
1259        pub owner: alloy::sol_types::private::Address,
1260    }
1261    #[allow(
1262        non_camel_case_types,
1263        non_snake_case,
1264        clippy::pub_underscore_fields,
1265        clippy::style
1266    )]
1267    const _: () = {
1268        use alloy::sol_types as alloy_sol_types;
1269        #[doc(hidden)]
1270        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1271        #[doc(hidden)]
1272        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1273        #[cfg(test)]
1274        #[allow(dead_code, unreachable_patterns)]
1275        fn _type_assertion(
1276            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1277        ) {
1278            match _t {
1279                alloy_sol_types::private::AssertTypeEq::<
1280                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1281                >(_) => {}
1282            }
1283        }
1284        #[automatically_derived]
1285        #[doc(hidden)]
1286        impl ::core::convert::From<OwnableInvalidOwner> for UnderlyingRustTuple<'_> {
1287            fn from(value: OwnableInvalidOwner) -> Self {
1288                (value.owner,)
1289            }
1290        }
1291        #[automatically_derived]
1292        #[doc(hidden)]
1293        impl ::core::convert::From<UnderlyingRustTuple<'_>> for OwnableInvalidOwner {
1294            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1295                Self { owner: tuple.0 }
1296            }
1297        }
1298        #[automatically_derived]
1299        impl alloy_sol_types::SolError for OwnableInvalidOwner {
1300            type Parameters<'a> = UnderlyingSolTuple<'a>;
1301            type Token<'a> = <Self::Parameters<
1302                'a,
1303            > as alloy_sol_types::SolType>::Token<'a>;
1304            const SIGNATURE: &'static str = "OwnableInvalidOwner(address)";
1305            const SELECTOR: [u8; 4] = [30u8, 79u8, 189u8, 247u8];
1306            #[inline]
1307            fn new<'a>(
1308                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1309            ) -> Self {
1310                tuple.into()
1311            }
1312            #[inline]
1313            fn tokenize(&self) -> Self::Token<'_> {
1314                (
1315                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1316                        &self.owner,
1317                    ),
1318                )
1319            }
1320        }
1321    };
1322    /**Custom error with signature `OwnableUnauthorizedAccount(address)` and selector `0x118cdaa7`.
1323```solidity
1324error OwnableUnauthorizedAccount(address account);
1325```*/
1326    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1327    #[derive(Clone)]
1328    pub struct OwnableUnauthorizedAccount {
1329        #[allow(missing_docs)]
1330        pub account: alloy::sol_types::private::Address,
1331    }
1332    #[allow(
1333        non_camel_case_types,
1334        non_snake_case,
1335        clippy::pub_underscore_fields,
1336        clippy::style
1337    )]
1338    const _: () = {
1339        use alloy::sol_types as alloy_sol_types;
1340        #[doc(hidden)]
1341        type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1342        #[doc(hidden)]
1343        type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1344        #[cfg(test)]
1345        #[allow(dead_code, unreachable_patterns)]
1346        fn _type_assertion(
1347            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1348        ) {
1349            match _t {
1350                alloy_sol_types::private::AssertTypeEq::<
1351                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1352                >(_) => {}
1353            }
1354        }
1355        #[automatically_derived]
1356        #[doc(hidden)]
1357        impl ::core::convert::From<OwnableUnauthorizedAccount>
1358        for UnderlyingRustTuple<'_> {
1359            fn from(value: OwnableUnauthorizedAccount) -> Self {
1360                (value.account,)
1361            }
1362        }
1363        #[automatically_derived]
1364        #[doc(hidden)]
1365        impl ::core::convert::From<UnderlyingRustTuple<'_>>
1366        for OwnableUnauthorizedAccount {
1367            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1368                Self { account: tuple.0 }
1369            }
1370        }
1371        #[automatically_derived]
1372        impl alloy_sol_types::SolError for OwnableUnauthorizedAccount {
1373            type Parameters<'a> = UnderlyingSolTuple<'a>;
1374            type Token<'a> = <Self::Parameters<
1375                'a,
1376            > as alloy_sol_types::SolType>::Token<'a>;
1377            const SIGNATURE: &'static str = "OwnableUnauthorizedAccount(address)";
1378            const SELECTOR: [u8; 4] = [17u8, 140u8, 218u8, 167u8];
1379            #[inline]
1380            fn new<'a>(
1381                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1382            ) -> Self {
1383                tuple.into()
1384            }
1385            #[inline]
1386            fn tokenize(&self) -> Self::Token<'_> {
1387                (
1388                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1389                        &self.account,
1390                    ),
1391                )
1392            }
1393        }
1394    };
1395    /**Event with signature `AppCIDChanged((bytes4,bytes32))` and selector `0xc820a66d3bdd50a45cf12cda6dc8ec9e94fb5123edd7da736eea18316f8523a0`.
1396```solidity
1397event AppCIDChanged(Common.CIDV1 newAppCID);
1398```*/
1399    #[allow(
1400        non_camel_case_types,
1401        non_snake_case,
1402        clippy::pub_underscore_fields,
1403        clippy::style
1404    )]
1405    #[derive(Clone)]
1406    pub struct AppCIDChanged {
1407        #[allow(missing_docs)]
1408        pub newAppCID: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
1409    }
1410    #[allow(
1411        non_camel_case_types,
1412        non_snake_case,
1413        clippy::pub_underscore_fields,
1414        clippy::style
1415    )]
1416    const _: () = {
1417        use alloy::sol_types as alloy_sol_types;
1418        #[automatically_derived]
1419        impl alloy_sol_types::SolEvent for AppCIDChanged {
1420            type DataTuple<'a> = (Common::CIDV1,);
1421            type DataToken<'a> = <Self::DataTuple<
1422                'a,
1423            > as alloy_sol_types::SolType>::Token<'a>;
1424            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1425            const SIGNATURE: &'static str = "AppCIDChanged((bytes4,bytes32))";
1426            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1427                200u8,
1428                32u8,
1429                166u8,
1430                109u8,
1431                59u8,
1432                221u8,
1433                80u8,
1434                164u8,
1435                92u8,
1436                241u8,
1437                44u8,
1438                218u8,
1439                109u8,
1440                200u8,
1441                236u8,
1442                158u8,
1443                148u8,
1444                251u8,
1445                81u8,
1446                35u8,
1447                237u8,
1448                215u8,
1449                218u8,
1450                115u8,
1451                110u8,
1452                234u8,
1453                24u8,
1454                49u8,
1455                111u8,
1456                133u8,
1457                35u8,
1458                160u8,
1459            ]);
1460            const ANONYMOUS: bool = false;
1461            #[allow(unused_variables)]
1462            #[inline]
1463            fn new(
1464                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1465                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1466            ) -> Self {
1467                Self { newAppCID: data.0 }
1468            }
1469            #[inline]
1470            fn check_signature(
1471                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1472            ) -> alloy_sol_types::Result<()> {
1473                if topics.0 != Self::SIGNATURE_HASH {
1474                    return Err(
1475                        alloy_sol_types::Error::invalid_event_signature_hash(
1476                            Self::SIGNATURE,
1477                            topics.0,
1478                            Self::SIGNATURE_HASH,
1479                        ),
1480                    );
1481                }
1482                Ok(())
1483            }
1484            #[inline]
1485            fn tokenize_body(&self) -> Self::DataToken<'_> {
1486                (<Common::CIDV1 as alloy_sol_types::SolType>::tokenize(&self.newAppCID),)
1487            }
1488            #[inline]
1489            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1490                (Self::SIGNATURE_HASH.into(),)
1491            }
1492            #[inline]
1493            fn encode_topics_raw(
1494                &self,
1495                out: &mut [alloy_sol_types::abi::token::WordToken],
1496            ) -> alloy_sol_types::Result<()> {
1497                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1498                    return Err(alloy_sol_types::Error::Overrun);
1499                }
1500                out[0usize] = alloy_sol_types::abi::token::WordToken(
1501                    Self::SIGNATURE_HASH,
1502                );
1503                Ok(())
1504            }
1505        }
1506        #[automatically_derived]
1507        impl alloy_sol_types::private::IntoLogData for AppCIDChanged {
1508            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1509                From::from(self)
1510            }
1511            fn into_log_data(self) -> alloy_sol_types::private::LogData {
1512                From::from(&self)
1513            }
1514        }
1515        #[automatically_derived]
1516        impl From<&AppCIDChanged> for alloy_sol_types::private::LogData {
1517            #[inline]
1518            fn from(this: &AppCIDChanged) -> alloy_sol_types::private::LogData {
1519                alloy_sol_types::SolEvent::encode_log_data(this)
1520            }
1521        }
1522    };
1523    /**Event with signature `Initialized(uint64)` and selector `0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2`.
1524```solidity
1525event Initialized(uint64 version);
1526```*/
1527    #[allow(
1528        non_camel_case_types,
1529        non_snake_case,
1530        clippy::pub_underscore_fields,
1531        clippy::style
1532    )]
1533    #[derive(Clone)]
1534    pub struct Initialized {
1535        #[allow(missing_docs)]
1536        pub version: u64,
1537    }
1538    #[allow(
1539        non_camel_case_types,
1540        non_snake_case,
1541        clippy::pub_underscore_fields,
1542        clippy::style
1543    )]
1544    const _: () = {
1545        use alloy::sol_types as alloy_sol_types;
1546        #[automatically_derived]
1547        impl alloy_sol_types::SolEvent for Initialized {
1548            type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<64>,);
1549            type DataToken<'a> = <Self::DataTuple<
1550                'a,
1551            > as alloy_sol_types::SolType>::Token<'a>;
1552            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1553            const SIGNATURE: &'static str = "Initialized(uint64)";
1554            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1555                199u8,
1556                245u8,
1557                5u8,
1558                178u8,
1559                243u8,
1560                113u8,
1561                174u8,
1562                33u8,
1563                117u8,
1564                238u8,
1565                73u8,
1566                19u8,
1567                244u8,
1568                73u8,
1569                158u8,
1570                31u8,
1571                38u8,
1572                51u8,
1573                167u8,
1574                181u8,
1575                147u8,
1576                99u8,
1577                33u8,
1578                238u8,
1579                209u8,
1580                205u8,
1581                174u8,
1582                182u8,
1583                17u8,
1584                81u8,
1585                129u8,
1586                210u8,
1587            ]);
1588            const ANONYMOUS: bool = false;
1589            #[allow(unused_variables)]
1590            #[inline]
1591            fn new(
1592                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1593                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1594            ) -> Self {
1595                Self { version: data.0 }
1596            }
1597            #[inline]
1598            fn check_signature(
1599                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1600            ) -> alloy_sol_types::Result<()> {
1601                if topics.0 != Self::SIGNATURE_HASH {
1602                    return Err(
1603                        alloy_sol_types::Error::invalid_event_signature_hash(
1604                            Self::SIGNATURE,
1605                            topics.0,
1606                            Self::SIGNATURE_HASH,
1607                        ),
1608                    );
1609                }
1610                Ok(())
1611            }
1612            #[inline]
1613            fn tokenize_body(&self) -> Self::DataToken<'_> {
1614                (
1615                    <alloy::sol_types::sol_data::Uint<
1616                        64,
1617                    > as alloy_sol_types::SolType>::tokenize(&self.version),
1618                )
1619            }
1620            #[inline]
1621            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1622                (Self::SIGNATURE_HASH.into(),)
1623            }
1624            #[inline]
1625            fn encode_topics_raw(
1626                &self,
1627                out: &mut [alloy_sol_types::abi::token::WordToken],
1628            ) -> alloy_sol_types::Result<()> {
1629                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1630                    return Err(alloy_sol_types::Error::Overrun);
1631                }
1632                out[0usize] = alloy_sol_types::abi::token::WordToken(
1633                    Self::SIGNATURE_HASH,
1634                );
1635                Ok(())
1636            }
1637        }
1638        #[automatically_derived]
1639        impl alloy_sol_types::private::IntoLogData for Initialized {
1640            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1641                From::from(self)
1642            }
1643            fn into_log_data(self) -> alloy_sol_types::private::LogData {
1644                From::from(&self)
1645            }
1646        }
1647        #[automatically_derived]
1648        impl From<&Initialized> for alloy_sol_types::private::LogData {
1649            #[inline]
1650            fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1651                alloy_sol_types::SolEvent::encode_log_data(this)
1652            }
1653        }
1654    };
1655    /**Event with signature `OwnershipTransferred(address,address)` and selector `0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0`.
1656```solidity
1657event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
1658```*/
1659    #[allow(
1660        non_camel_case_types,
1661        non_snake_case,
1662        clippy::pub_underscore_fields,
1663        clippy::style
1664    )]
1665    #[derive(Clone)]
1666    pub struct OwnershipTransferred {
1667        #[allow(missing_docs)]
1668        pub previousOwner: alloy::sol_types::private::Address,
1669        #[allow(missing_docs)]
1670        pub newOwner: alloy::sol_types::private::Address,
1671    }
1672    #[allow(
1673        non_camel_case_types,
1674        non_snake_case,
1675        clippy::pub_underscore_fields,
1676        clippy::style
1677    )]
1678    const _: () = {
1679        use alloy::sol_types as alloy_sol_types;
1680        #[automatically_derived]
1681        impl alloy_sol_types::SolEvent for OwnershipTransferred {
1682            type DataTuple<'a> = ();
1683            type DataToken<'a> = <Self::DataTuple<
1684                'a,
1685            > as alloy_sol_types::SolType>::Token<'a>;
1686            type TopicList = (
1687                alloy_sol_types::sol_data::FixedBytes<32>,
1688                alloy::sol_types::sol_data::Address,
1689                alloy::sol_types::sol_data::Address,
1690            );
1691            const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
1692            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1693                139u8,
1694                224u8,
1695                7u8,
1696                156u8,
1697                83u8,
1698                22u8,
1699                89u8,
1700                20u8,
1701                19u8,
1702                68u8,
1703                205u8,
1704                31u8,
1705                208u8,
1706                164u8,
1707                242u8,
1708                132u8,
1709                25u8,
1710                73u8,
1711                127u8,
1712                151u8,
1713                34u8,
1714                163u8,
1715                218u8,
1716                175u8,
1717                227u8,
1718                180u8,
1719                24u8,
1720                111u8,
1721                107u8,
1722                100u8,
1723                87u8,
1724                224u8,
1725            ]);
1726            const ANONYMOUS: bool = false;
1727            #[allow(unused_variables)]
1728            #[inline]
1729            fn new(
1730                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1731                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1732            ) -> Self {
1733                Self {
1734                    previousOwner: topics.1,
1735                    newOwner: topics.2,
1736                }
1737            }
1738            #[inline]
1739            fn check_signature(
1740                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1741            ) -> alloy_sol_types::Result<()> {
1742                if topics.0 != Self::SIGNATURE_HASH {
1743                    return Err(
1744                        alloy_sol_types::Error::invalid_event_signature_hash(
1745                            Self::SIGNATURE,
1746                            topics.0,
1747                            Self::SIGNATURE_HASH,
1748                        ),
1749                    );
1750                }
1751                Ok(())
1752            }
1753            #[inline]
1754            fn tokenize_body(&self) -> Self::DataToken<'_> {
1755                ()
1756            }
1757            #[inline]
1758            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1759                (
1760                    Self::SIGNATURE_HASH.into(),
1761                    self.previousOwner.clone(),
1762                    self.newOwner.clone(),
1763                )
1764            }
1765            #[inline]
1766            fn encode_topics_raw(
1767                &self,
1768                out: &mut [alloy_sol_types::abi::token::WordToken],
1769            ) -> alloy_sol_types::Result<()> {
1770                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1771                    return Err(alloy_sol_types::Error::Overrun);
1772                }
1773                out[0usize] = alloy_sol_types::abi::token::WordToken(
1774                    Self::SIGNATURE_HASH,
1775                );
1776                out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1777                    &self.previousOwner,
1778                );
1779                out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1780                    &self.newOwner,
1781                );
1782                Ok(())
1783            }
1784        }
1785        #[automatically_derived]
1786        impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
1787            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1788                From::from(self)
1789            }
1790            fn into_log_data(self) -> alloy_sol_types::private::LogData {
1791                From::from(&self)
1792            }
1793        }
1794        #[automatically_derived]
1795        impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
1796            #[inline]
1797            fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
1798                alloy_sol_types::SolEvent::encode_log_data(this)
1799            }
1800        }
1801    };
1802    /**Event with signature `ProviderAddedToAccessList(address)` and selector `0x4c26e4de691e265be6cf03e639754839907bf74687cd524a6734851331527ffd`.
1803```solidity
1804event ProviderAddedToAccessList(address provider);
1805```*/
1806    #[allow(
1807        non_camel_case_types,
1808        non_snake_case,
1809        clippy::pub_underscore_fields,
1810        clippy::style
1811    )]
1812    #[derive(Clone)]
1813    pub struct ProviderAddedToAccessList {
1814        #[allow(missing_docs)]
1815        pub provider: alloy::sol_types::private::Address,
1816    }
1817    #[allow(
1818        non_camel_case_types,
1819        non_snake_case,
1820        clippy::pub_underscore_fields,
1821        clippy::style
1822    )]
1823    const _: () = {
1824        use alloy::sol_types as alloy_sol_types;
1825        #[automatically_derived]
1826        impl alloy_sol_types::SolEvent for ProviderAddedToAccessList {
1827            type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1828            type DataToken<'a> = <Self::DataTuple<
1829                'a,
1830            > as alloy_sol_types::SolType>::Token<'a>;
1831            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1832            const SIGNATURE: &'static str = "ProviderAddedToAccessList(address)";
1833            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1834                76u8,
1835                38u8,
1836                228u8,
1837                222u8,
1838                105u8,
1839                30u8,
1840                38u8,
1841                91u8,
1842                230u8,
1843                207u8,
1844                3u8,
1845                230u8,
1846                57u8,
1847                117u8,
1848                72u8,
1849                57u8,
1850                144u8,
1851                123u8,
1852                247u8,
1853                70u8,
1854                135u8,
1855                205u8,
1856                82u8,
1857                74u8,
1858                103u8,
1859                52u8,
1860                133u8,
1861                19u8,
1862                49u8,
1863                82u8,
1864                127u8,
1865                253u8,
1866            ]);
1867            const ANONYMOUS: bool = false;
1868            #[allow(unused_variables)]
1869            #[inline]
1870            fn new(
1871                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1872                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1873            ) -> Self {
1874                Self { provider: data.0 }
1875            }
1876            #[inline]
1877            fn check_signature(
1878                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1879            ) -> alloy_sol_types::Result<()> {
1880                if topics.0 != Self::SIGNATURE_HASH {
1881                    return Err(
1882                        alloy_sol_types::Error::invalid_event_signature_hash(
1883                            Self::SIGNATURE,
1884                            topics.0,
1885                            Self::SIGNATURE_HASH,
1886                        ),
1887                    );
1888                }
1889                Ok(())
1890            }
1891            #[inline]
1892            fn tokenize_body(&self) -> Self::DataToken<'_> {
1893                (
1894                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1895                        &self.provider,
1896                    ),
1897                )
1898            }
1899            #[inline]
1900            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1901                (Self::SIGNATURE_HASH.into(),)
1902            }
1903            #[inline]
1904            fn encode_topics_raw(
1905                &self,
1906                out: &mut [alloy_sol_types::abi::token::WordToken],
1907            ) -> alloy_sol_types::Result<()> {
1908                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1909                    return Err(alloy_sol_types::Error::Overrun);
1910                }
1911                out[0usize] = alloy_sol_types::abi::token::WordToken(
1912                    Self::SIGNATURE_HASH,
1913                );
1914                Ok(())
1915            }
1916        }
1917        #[automatically_derived]
1918        impl alloy_sol_types::private::IntoLogData for ProviderAddedToAccessList {
1919            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1920                From::from(self)
1921            }
1922            fn into_log_data(self) -> alloy_sol_types::private::LogData {
1923                From::from(&self)
1924            }
1925        }
1926        #[automatically_derived]
1927        impl From<&ProviderAddedToAccessList> for alloy_sol_types::private::LogData {
1928            #[inline]
1929            fn from(
1930                this: &ProviderAddedToAccessList,
1931            ) -> alloy_sol_types::private::LogData {
1932                alloy_sol_types::SolEvent::encode_log_data(this)
1933            }
1934        }
1935    };
1936    /**Event with signature `ProviderRemovedFromAccessList(address)` and selector `0x38fb081a0b484406977bd94ff8edb79be44b5ca514130361182516b39e2c4528`.
1937```solidity
1938event ProviderRemovedFromAccessList(address provider);
1939```*/
1940    #[allow(
1941        non_camel_case_types,
1942        non_snake_case,
1943        clippy::pub_underscore_fields,
1944        clippy::style
1945    )]
1946    #[derive(Clone)]
1947    pub struct ProviderRemovedFromAccessList {
1948        #[allow(missing_docs)]
1949        pub provider: alloy::sol_types::private::Address,
1950    }
1951    #[allow(
1952        non_camel_case_types,
1953        non_snake_case,
1954        clippy::pub_underscore_fields,
1955        clippy::style
1956    )]
1957    const _: () = {
1958        use alloy::sol_types as alloy_sol_types;
1959        #[automatically_derived]
1960        impl alloy_sol_types::SolEvent for ProviderRemovedFromAccessList {
1961            type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1962            type DataToken<'a> = <Self::DataTuple<
1963                'a,
1964            > as alloy_sol_types::SolType>::Token<'a>;
1965            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1966            const SIGNATURE: &'static str = "ProviderRemovedFromAccessList(address)";
1967            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1968                56u8,
1969                251u8,
1970                8u8,
1971                26u8,
1972                11u8,
1973                72u8,
1974                68u8,
1975                6u8,
1976                151u8,
1977                123u8,
1978                217u8,
1979                79u8,
1980                248u8,
1981                237u8,
1982                183u8,
1983                155u8,
1984                228u8,
1985                75u8,
1986                92u8,
1987                165u8,
1988                20u8,
1989                19u8,
1990                3u8,
1991                97u8,
1992                24u8,
1993                37u8,
1994                22u8,
1995                179u8,
1996                158u8,
1997                44u8,
1998                69u8,
1999                40u8,
2000            ]);
2001            const ANONYMOUS: bool = false;
2002            #[allow(unused_variables)]
2003            #[inline]
2004            fn new(
2005                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2006                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2007            ) -> Self {
2008                Self { provider: data.0 }
2009            }
2010            #[inline]
2011            fn check_signature(
2012                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2013            ) -> alloy_sol_types::Result<()> {
2014                if topics.0 != Self::SIGNATURE_HASH {
2015                    return Err(
2016                        alloy_sol_types::Error::invalid_event_signature_hash(
2017                            Self::SIGNATURE,
2018                            topics.0,
2019                            Self::SIGNATURE_HASH,
2020                        ),
2021                    );
2022                }
2023                Ok(())
2024            }
2025            #[inline]
2026            fn tokenize_body(&self) -> Self::DataToken<'_> {
2027                (
2028                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2029                        &self.provider,
2030                    ),
2031                )
2032            }
2033            #[inline]
2034            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2035                (Self::SIGNATURE_HASH.into(),)
2036            }
2037            #[inline]
2038            fn encode_topics_raw(
2039                &self,
2040                out: &mut [alloy_sol_types::abi::token::WordToken],
2041            ) -> alloy_sol_types::Result<()> {
2042                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2043                    return Err(alloy_sol_types::Error::Overrun);
2044                }
2045                out[0usize] = alloy_sol_types::abi::token::WordToken(
2046                    Self::SIGNATURE_HASH,
2047                );
2048                Ok(())
2049            }
2050        }
2051        #[automatically_derived]
2052        impl alloy_sol_types::private::IntoLogData for ProviderRemovedFromAccessList {
2053            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2054                From::from(self)
2055            }
2056            fn into_log_data(self) -> alloy_sol_types::private::LogData {
2057                From::from(&self)
2058            }
2059        }
2060        #[automatically_derived]
2061        impl From<&ProviderRemovedFromAccessList> for alloy_sol_types::private::LogData {
2062            #[inline]
2063            fn from(
2064                this: &ProviderRemovedFromAccessList,
2065            ) -> alloy_sol_types::private::LogData {
2066                alloy_sol_types::SolEvent::encode_log_data(this)
2067            }
2068        }
2069    };
2070    /**Event with signature `ProvidersAccessTypeChanged(uint8)` and selector `0x1f5a251428f76335a835fcae94ab6a9bcf09ac33bd3c782eb6a81bdf878a7393`.
2071```solidity
2072event ProvidersAccessTypeChanged(IConfig.AccessType newAccessType);
2073```*/
2074    #[allow(
2075        non_camel_case_types,
2076        non_snake_case,
2077        clippy::pub_underscore_fields,
2078        clippy::style
2079    )]
2080    #[derive(Clone)]
2081    pub struct ProvidersAccessTypeChanged {
2082        #[allow(missing_docs)]
2083        pub newAccessType: <IConfig::AccessType as alloy::sol_types::SolType>::RustType,
2084    }
2085    #[allow(
2086        non_camel_case_types,
2087        non_snake_case,
2088        clippy::pub_underscore_fields,
2089        clippy::style
2090    )]
2091    const _: () = {
2092        use alloy::sol_types as alloy_sol_types;
2093        #[automatically_derived]
2094        impl alloy_sol_types::SolEvent for ProvidersAccessTypeChanged {
2095            type DataTuple<'a> = (IConfig::AccessType,);
2096            type DataToken<'a> = <Self::DataTuple<
2097                'a,
2098            > as alloy_sol_types::SolType>::Token<'a>;
2099            type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
2100            const SIGNATURE: &'static str = "ProvidersAccessTypeChanged(uint8)";
2101            const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2102                31u8,
2103                90u8,
2104                37u8,
2105                20u8,
2106                40u8,
2107                247u8,
2108                99u8,
2109                53u8,
2110                168u8,
2111                53u8,
2112                252u8,
2113                174u8,
2114                148u8,
2115                171u8,
2116                106u8,
2117                155u8,
2118                207u8,
2119                9u8,
2120                172u8,
2121                51u8,
2122                189u8,
2123                60u8,
2124                120u8,
2125                46u8,
2126                182u8,
2127                168u8,
2128                27u8,
2129                223u8,
2130                135u8,
2131                138u8,
2132                115u8,
2133                147u8,
2134            ]);
2135            const ANONYMOUS: bool = false;
2136            #[allow(unused_variables)]
2137            #[inline]
2138            fn new(
2139                topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2140                data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2141            ) -> Self {
2142                Self { newAccessType: data.0 }
2143            }
2144            #[inline]
2145            fn check_signature(
2146                topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2147            ) -> alloy_sol_types::Result<()> {
2148                if topics.0 != Self::SIGNATURE_HASH {
2149                    return Err(
2150                        alloy_sol_types::Error::invalid_event_signature_hash(
2151                            Self::SIGNATURE,
2152                            topics.0,
2153                            Self::SIGNATURE_HASH,
2154                        ),
2155                    );
2156                }
2157                Ok(())
2158            }
2159            #[inline]
2160            fn tokenize_body(&self) -> Self::DataToken<'_> {
2161                (
2162                    <IConfig::AccessType as alloy_sol_types::SolType>::tokenize(
2163                        &self.newAccessType,
2164                    ),
2165                )
2166            }
2167            #[inline]
2168            fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2169                (Self::SIGNATURE_HASH.into(),)
2170            }
2171            #[inline]
2172            fn encode_topics_raw(
2173                &self,
2174                out: &mut [alloy_sol_types::abi::token::WordToken],
2175            ) -> alloy_sol_types::Result<()> {
2176                if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2177                    return Err(alloy_sol_types::Error::Overrun);
2178                }
2179                out[0usize] = alloy_sol_types::abi::token::WordToken(
2180                    Self::SIGNATURE_HASH,
2181                );
2182                Ok(())
2183            }
2184        }
2185        #[automatically_derived]
2186        impl alloy_sol_types::private::IntoLogData for ProvidersAccessTypeChanged {
2187            fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2188                From::from(self)
2189            }
2190            fn into_log_data(self) -> alloy_sol_types::private::LogData {
2191                From::from(&self)
2192            }
2193        }
2194        #[automatically_derived]
2195        impl From<&ProvidersAccessTypeChanged> for alloy_sol_types::private::LogData {
2196            #[inline]
2197            fn from(
2198                this: &ProvidersAccessTypeChanged,
2199            ) -> alloy_sol_types::private::LogData {
2200                alloy_sol_types::SolEvent::encode_log_data(this)
2201            }
2202        }
2203    };
2204    /**Function with signature `addProviderToAccessList(address)` and selector `0x73134c15`.
2205```solidity
2206function addProviderToAccessList(address provider) external;
2207```*/
2208    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2209    #[derive(Clone)]
2210    pub struct addProviderToAccessListCall {
2211        #[allow(missing_docs)]
2212        pub provider: alloy::sol_types::private::Address,
2213    }
2214    ///Container type for the return parameters of the [`addProviderToAccessList(address)`](addProviderToAccessListCall) function.
2215    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2216    #[derive(Clone)]
2217    pub struct addProviderToAccessListReturn {}
2218    #[allow(
2219        non_camel_case_types,
2220        non_snake_case,
2221        clippy::pub_underscore_fields,
2222        clippy::style
2223    )]
2224    const _: () = {
2225        use alloy::sol_types as alloy_sol_types;
2226        {
2227            #[doc(hidden)]
2228            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2229            #[doc(hidden)]
2230            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2231            #[cfg(test)]
2232            #[allow(dead_code, unreachable_patterns)]
2233            fn _type_assertion(
2234                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2235            ) {
2236                match _t {
2237                    alloy_sol_types::private::AssertTypeEq::<
2238                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2239                    >(_) => {}
2240                }
2241            }
2242            #[automatically_derived]
2243            #[doc(hidden)]
2244            impl ::core::convert::From<addProviderToAccessListCall>
2245            for UnderlyingRustTuple<'_> {
2246                fn from(value: addProviderToAccessListCall) -> Self {
2247                    (value.provider,)
2248                }
2249            }
2250            #[automatically_derived]
2251            #[doc(hidden)]
2252            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2253            for addProviderToAccessListCall {
2254                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2255                    Self { provider: tuple.0 }
2256                }
2257            }
2258        }
2259        {
2260            #[doc(hidden)]
2261            type UnderlyingSolTuple<'a> = ();
2262            #[doc(hidden)]
2263            type UnderlyingRustTuple<'a> = ();
2264            #[cfg(test)]
2265            #[allow(dead_code, unreachable_patterns)]
2266            fn _type_assertion(
2267                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2268            ) {
2269                match _t {
2270                    alloy_sol_types::private::AssertTypeEq::<
2271                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2272                    >(_) => {}
2273                }
2274            }
2275            #[automatically_derived]
2276            #[doc(hidden)]
2277            impl ::core::convert::From<addProviderToAccessListReturn>
2278            for UnderlyingRustTuple<'_> {
2279                fn from(value: addProviderToAccessListReturn) -> Self {
2280                    ()
2281                }
2282            }
2283            #[automatically_derived]
2284            #[doc(hidden)]
2285            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2286            for addProviderToAccessListReturn {
2287                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2288                    Self {}
2289                }
2290            }
2291        }
2292        #[automatically_derived]
2293        impl alloy_sol_types::SolCall for addProviderToAccessListCall {
2294            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2295            type Token<'a> = <Self::Parameters<
2296                'a,
2297            > as alloy_sol_types::SolType>::Token<'a>;
2298            type Return = addProviderToAccessListReturn;
2299            type ReturnTuple<'a> = ();
2300            type ReturnToken<'a> = <Self::ReturnTuple<
2301                'a,
2302            > as alloy_sol_types::SolType>::Token<'a>;
2303            const SIGNATURE: &'static str = "addProviderToAccessList(address)";
2304            const SELECTOR: [u8; 4] = [115u8, 19u8, 76u8, 21u8];
2305            #[inline]
2306            fn new<'a>(
2307                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2308            ) -> Self {
2309                tuple.into()
2310            }
2311            #[inline]
2312            fn tokenize(&self) -> Self::Token<'_> {
2313                (
2314                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2315                        &self.provider,
2316                    ),
2317                )
2318            }
2319            #[inline]
2320            fn abi_decode_returns(
2321                data: &[u8],
2322                validate: bool,
2323            ) -> alloy_sol_types::Result<Self::Return> {
2324                <Self::ReturnTuple<
2325                    '_,
2326                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2327                    .map(Into::into)
2328            }
2329        }
2330    };
2331    /**Function with signature `appCID()` and selector `0x9bc66868`.
2332```solidity
2333function appCID() external view returns (Common.CIDV1 memory);
2334```*/
2335    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2336    #[derive(Clone)]
2337    pub struct appCIDCall {}
2338    ///Container type for the return parameters of the [`appCID()`](appCIDCall) function.
2339    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2340    #[derive(Clone)]
2341    pub struct appCIDReturn {
2342        #[allow(missing_docs)]
2343        pub _0: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
2344    }
2345    #[allow(
2346        non_camel_case_types,
2347        non_snake_case,
2348        clippy::pub_underscore_fields,
2349        clippy::style
2350    )]
2351    const _: () = {
2352        use alloy::sol_types as alloy_sol_types;
2353        {
2354            #[doc(hidden)]
2355            type UnderlyingSolTuple<'a> = ();
2356            #[doc(hidden)]
2357            type UnderlyingRustTuple<'a> = ();
2358            #[cfg(test)]
2359            #[allow(dead_code, unreachable_patterns)]
2360            fn _type_assertion(
2361                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2362            ) {
2363                match _t {
2364                    alloy_sol_types::private::AssertTypeEq::<
2365                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2366                    >(_) => {}
2367                }
2368            }
2369            #[automatically_derived]
2370            #[doc(hidden)]
2371            impl ::core::convert::From<appCIDCall> for UnderlyingRustTuple<'_> {
2372                fn from(value: appCIDCall) -> Self {
2373                    ()
2374                }
2375            }
2376            #[automatically_derived]
2377            #[doc(hidden)]
2378            impl ::core::convert::From<UnderlyingRustTuple<'_>> for appCIDCall {
2379                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2380                    Self {}
2381                }
2382            }
2383        }
2384        {
2385            #[doc(hidden)]
2386            type UnderlyingSolTuple<'a> = (Common::CIDV1,);
2387            #[doc(hidden)]
2388            type UnderlyingRustTuple<'a> = (
2389                <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
2390            );
2391            #[cfg(test)]
2392            #[allow(dead_code, unreachable_patterns)]
2393            fn _type_assertion(
2394                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2395            ) {
2396                match _t {
2397                    alloy_sol_types::private::AssertTypeEq::<
2398                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2399                    >(_) => {}
2400                }
2401            }
2402            #[automatically_derived]
2403            #[doc(hidden)]
2404            impl ::core::convert::From<appCIDReturn> for UnderlyingRustTuple<'_> {
2405                fn from(value: appCIDReturn) -> Self {
2406                    (value._0,)
2407                }
2408            }
2409            #[automatically_derived]
2410            #[doc(hidden)]
2411            impl ::core::convert::From<UnderlyingRustTuple<'_>> for appCIDReturn {
2412                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2413                    Self { _0: tuple.0 }
2414                }
2415            }
2416        }
2417        #[automatically_derived]
2418        impl alloy_sol_types::SolCall for appCIDCall {
2419            type Parameters<'a> = ();
2420            type Token<'a> = <Self::Parameters<
2421                'a,
2422            > as alloy_sol_types::SolType>::Token<'a>;
2423            type Return = appCIDReturn;
2424            type ReturnTuple<'a> = (Common::CIDV1,);
2425            type ReturnToken<'a> = <Self::ReturnTuple<
2426                'a,
2427            > as alloy_sol_types::SolType>::Token<'a>;
2428            const SIGNATURE: &'static str = "appCID()";
2429            const SELECTOR: [u8; 4] = [155u8, 198u8, 104u8, 104u8];
2430            #[inline]
2431            fn new<'a>(
2432                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2433            ) -> Self {
2434                tuple.into()
2435            }
2436            #[inline]
2437            fn tokenize(&self) -> Self::Token<'_> {
2438                ()
2439            }
2440            #[inline]
2441            fn abi_decode_returns(
2442                data: &[u8],
2443                validate: bool,
2444            ) -> alloy_sol_types::Result<Self::Return> {
2445                <Self::ReturnTuple<
2446                    '_,
2447                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2448                    .map(Into::into)
2449            }
2450        }
2451    };
2452    /**Function with signature `changeProvidersAccessType(uint8)` and selector `0x636fcefb`.
2453```solidity
2454function changeProvidersAccessType(IConfig.AccessType accessType) external;
2455```*/
2456    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2457    #[derive(Clone)]
2458    pub struct changeProvidersAccessTypeCall {
2459        #[allow(missing_docs)]
2460        pub accessType: <IConfig::AccessType as alloy::sol_types::SolType>::RustType,
2461    }
2462    ///Container type for the return parameters of the [`changeProvidersAccessType(uint8)`](changeProvidersAccessTypeCall) function.
2463    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2464    #[derive(Clone)]
2465    pub struct changeProvidersAccessTypeReturn {}
2466    #[allow(
2467        non_camel_case_types,
2468        non_snake_case,
2469        clippy::pub_underscore_fields,
2470        clippy::style
2471    )]
2472    const _: () = {
2473        use alloy::sol_types as alloy_sol_types;
2474        {
2475            #[doc(hidden)]
2476            type UnderlyingSolTuple<'a> = (IConfig::AccessType,);
2477            #[doc(hidden)]
2478            type UnderlyingRustTuple<'a> = (
2479                <IConfig::AccessType as alloy::sol_types::SolType>::RustType,
2480            );
2481            #[cfg(test)]
2482            #[allow(dead_code, unreachable_patterns)]
2483            fn _type_assertion(
2484                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2485            ) {
2486                match _t {
2487                    alloy_sol_types::private::AssertTypeEq::<
2488                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2489                    >(_) => {}
2490                }
2491            }
2492            #[automatically_derived]
2493            #[doc(hidden)]
2494            impl ::core::convert::From<changeProvidersAccessTypeCall>
2495            for UnderlyingRustTuple<'_> {
2496                fn from(value: changeProvidersAccessTypeCall) -> Self {
2497                    (value.accessType,)
2498                }
2499            }
2500            #[automatically_derived]
2501            #[doc(hidden)]
2502            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2503            for changeProvidersAccessTypeCall {
2504                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2505                    Self { accessType: tuple.0 }
2506                }
2507            }
2508        }
2509        {
2510            #[doc(hidden)]
2511            type UnderlyingSolTuple<'a> = ();
2512            #[doc(hidden)]
2513            type UnderlyingRustTuple<'a> = ();
2514            #[cfg(test)]
2515            #[allow(dead_code, unreachable_patterns)]
2516            fn _type_assertion(
2517                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2518            ) {
2519                match _t {
2520                    alloy_sol_types::private::AssertTypeEq::<
2521                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2522                    >(_) => {}
2523                }
2524            }
2525            #[automatically_derived]
2526            #[doc(hidden)]
2527            impl ::core::convert::From<changeProvidersAccessTypeReturn>
2528            for UnderlyingRustTuple<'_> {
2529                fn from(value: changeProvidersAccessTypeReturn) -> Self {
2530                    ()
2531                }
2532            }
2533            #[automatically_derived]
2534            #[doc(hidden)]
2535            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2536            for changeProvidersAccessTypeReturn {
2537                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2538                    Self {}
2539                }
2540            }
2541        }
2542        #[automatically_derived]
2543        impl alloy_sol_types::SolCall for changeProvidersAccessTypeCall {
2544            type Parameters<'a> = (IConfig::AccessType,);
2545            type Token<'a> = <Self::Parameters<
2546                'a,
2547            > as alloy_sol_types::SolType>::Token<'a>;
2548            type Return = changeProvidersAccessTypeReturn;
2549            type ReturnTuple<'a> = ();
2550            type ReturnToken<'a> = <Self::ReturnTuple<
2551                'a,
2552            > as alloy_sol_types::SolType>::Token<'a>;
2553            const SIGNATURE: &'static str = "changeProvidersAccessType(uint8)";
2554            const SELECTOR: [u8; 4] = [99u8, 111u8, 206u8, 251u8];
2555            #[inline]
2556            fn new<'a>(
2557                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2558            ) -> Self {
2559                tuple.into()
2560            }
2561            #[inline]
2562            fn tokenize(&self) -> Self::Token<'_> {
2563                (
2564                    <IConfig::AccessType as alloy_sol_types::SolType>::tokenize(
2565                        &self.accessType,
2566                    ),
2567                )
2568            }
2569            #[inline]
2570            fn abi_decode_returns(
2571                data: &[u8],
2572                validate: bool,
2573            ) -> alloy_sol_types::Result<Self::Return> {
2574                <Self::ReturnTuple<
2575                    '_,
2576                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2577                    .map(Into::into)
2578            }
2579        }
2580    };
2581    /**Function with signature `creationBlock()` and selector `0x17634514`.
2582```solidity
2583function creationBlock() external view returns (uint256);
2584```*/
2585    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2586    #[derive(Clone)]
2587    pub struct creationBlockCall {}
2588    ///Container type for the return parameters of the [`creationBlock()`](creationBlockCall) function.
2589    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2590    #[derive(Clone)]
2591    pub struct creationBlockReturn {
2592        #[allow(missing_docs)]
2593        pub _0: alloy::sol_types::private::primitives::aliases::U256,
2594    }
2595    #[allow(
2596        non_camel_case_types,
2597        non_snake_case,
2598        clippy::pub_underscore_fields,
2599        clippy::style
2600    )]
2601    const _: () = {
2602        use alloy::sol_types as alloy_sol_types;
2603        {
2604            #[doc(hidden)]
2605            type UnderlyingSolTuple<'a> = ();
2606            #[doc(hidden)]
2607            type UnderlyingRustTuple<'a> = ();
2608            #[cfg(test)]
2609            #[allow(dead_code, unreachable_patterns)]
2610            fn _type_assertion(
2611                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2612            ) {
2613                match _t {
2614                    alloy_sol_types::private::AssertTypeEq::<
2615                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2616                    >(_) => {}
2617                }
2618            }
2619            #[automatically_derived]
2620            #[doc(hidden)]
2621            impl ::core::convert::From<creationBlockCall> for UnderlyingRustTuple<'_> {
2622                fn from(value: creationBlockCall) -> Self {
2623                    ()
2624                }
2625            }
2626            #[automatically_derived]
2627            #[doc(hidden)]
2628            impl ::core::convert::From<UnderlyingRustTuple<'_>> for creationBlockCall {
2629                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2630                    Self {}
2631                }
2632            }
2633        }
2634        {
2635            #[doc(hidden)]
2636            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2637            #[doc(hidden)]
2638            type UnderlyingRustTuple<'a> = (
2639                alloy::sol_types::private::primitives::aliases::U256,
2640            );
2641            #[cfg(test)]
2642            #[allow(dead_code, unreachable_patterns)]
2643            fn _type_assertion(
2644                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2645            ) {
2646                match _t {
2647                    alloy_sol_types::private::AssertTypeEq::<
2648                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2649                    >(_) => {}
2650                }
2651            }
2652            #[automatically_derived]
2653            #[doc(hidden)]
2654            impl ::core::convert::From<creationBlockReturn> for UnderlyingRustTuple<'_> {
2655                fn from(value: creationBlockReturn) -> Self {
2656                    (value._0,)
2657                }
2658            }
2659            #[automatically_derived]
2660            #[doc(hidden)]
2661            impl ::core::convert::From<UnderlyingRustTuple<'_>> for creationBlockReturn {
2662                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2663                    Self { _0: tuple.0 }
2664                }
2665            }
2666        }
2667        #[automatically_derived]
2668        impl alloy_sol_types::SolCall for creationBlockCall {
2669            type Parameters<'a> = ();
2670            type Token<'a> = <Self::Parameters<
2671                'a,
2672            > as alloy_sol_types::SolType>::Token<'a>;
2673            type Return = creationBlockReturn;
2674            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2675            type ReturnToken<'a> = <Self::ReturnTuple<
2676                'a,
2677            > as alloy_sol_types::SolType>::Token<'a>;
2678            const SIGNATURE: &'static str = "creationBlock()";
2679            const SELECTOR: [u8; 4] = [23u8, 99u8, 69u8, 20u8];
2680            #[inline]
2681            fn new<'a>(
2682                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2683            ) -> Self {
2684                tuple.into()
2685            }
2686            #[inline]
2687            fn tokenize(&self) -> Self::Token<'_> {
2688                ()
2689            }
2690            #[inline]
2691            fn abi_decode_returns(
2692                data: &[u8],
2693                validate: bool,
2694            ) -> alloy_sol_types::Result<Self::Return> {
2695                <Self::ReturnTuple<
2696                    '_,
2697                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2698                    .map(Into::into)
2699            }
2700        }
2701    };
2702    /**Function with signature `cuCountPerWorker()` and selector `0x15a0f31a`.
2703```solidity
2704function cuCountPerWorker() external view returns (uint256);
2705```*/
2706    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2707    #[derive(Clone)]
2708    pub struct cuCountPerWorkerCall {}
2709    ///Container type for the return parameters of the [`cuCountPerWorker()`](cuCountPerWorkerCall) function.
2710    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2711    #[derive(Clone)]
2712    pub struct cuCountPerWorkerReturn {
2713        #[allow(missing_docs)]
2714        pub _0: alloy::sol_types::private::primitives::aliases::U256,
2715    }
2716    #[allow(
2717        non_camel_case_types,
2718        non_snake_case,
2719        clippy::pub_underscore_fields,
2720        clippy::style
2721    )]
2722    const _: () = {
2723        use alloy::sol_types as alloy_sol_types;
2724        {
2725            #[doc(hidden)]
2726            type UnderlyingSolTuple<'a> = ();
2727            #[doc(hidden)]
2728            type UnderlyingRustTuple<'a> = ();
2729            #[cfg(test)]
2730            #[allow(dead_code, unreachable_patterns)]
2731            fn _type_assertion(
2732                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2733            ) {
2734                match _t {
2735                    alloy_sol_types::private::AssertTypeEq::<
2736                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2737                    >(_) => {}
2738                }
2739            }
2740            #[automatically_derived]
2741            #[doc(hidden)]
2742            impl ::core::convert::From<cuCountPerWorkerCall>
2743            for UnderlyingRustTuple<'_> {
2744                fn from(value: cuCountPerWorkerCall) -> Self {
2745                    ()
2746                }
2747            }
2748            #[automatically_derived]
2749            #[doc(hidden)]
2750            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2751            for cuCountPerWorkerCall {
2752                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2753                    Self {}
2754                }
2755            }
2756        }
2757        {
2758            #[doc(hidden)]
2759            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2760            #[doc(hidden)]
2761            type UnderlyingRustTuple<'a> = (
2762                alloy::sol_types::private::primitives::aliases::U256,
2763            );
2764            #[cfg(test)]
2765            #[allow(dead_code, unreachable_patterns)]
2766            fn _type_assertion(
2767                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2768            ) {
2769                match _t {
2770                    alloy_sol_types::private::AssertTypeEq::<
2771                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2772                    >(_) => {}
2773                }
2774            }
2775            #[automatically_derived]
2776            #[doc(hidden)]
2777            impl ::core::convert::From<cuCountPerWorkerReturn>
2778            for UnderlyingRustTuple<'_> {
2779                fn from(value: cuCountPerWorkerReturn) -> Self {
2780                    (value._0,)
2781                }
2782            }
2783            #[automatically_derived]
2784            #[doc(hidden)]
2785            impl ::core::convert::From<UnderlyingRustTuple<'_>>
2786            for cuCountPerWorkerReturn {
2787                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2788                    Self { _0: tuple.0 }
2789                }
2790            }
2791        }
2792        #[automatically_derived]
2793        impl alloy_sol_types::SolCall for cuCountPerWorkerCall {
2794            type Parameters<'a> = ();
2795            type Token<'a> = <Self::Parameters<
2796                'a,
2797            > as alloy_sol_types::SolType>::Token<'a>;
2798            type Return = cuCountPerWorkerReturn;
2799            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2800            type ReturnToken<'a> = <Self::ReturnTuple<
2801                'a,
2802            > as alloy_sol_types::SolType>::Token<'a>;
2803            const SIGNATURE: &'static str = "cuCountPerWorker()";
2804            const SELECTOR: [u8; 4] = [21u8, 160u8, 243u8, 26u8];
2805            #[inline]
2806            fn new<'a>(
2807                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2808            ) -> Self {
2809                tuple.into()
2810            }
2811            #[inline]
2812            fn tokenize(&self) -> Self::Token<'_> {
2813                ()
2814            }
2815            #[inline]
2816            fn abi_decode_returns(
2817                data: &[u8],
2818                validate: bool,
2819            ) -> alloy_sol_types::Result<Self::Return> {
2820                <Self::ReturnTuple<
2821                    '_,
2822                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2823                    .map(Into::into)
2824            }
2825        }
2826    };
2827    /**Function with signature `effectors()` and selector `0xfc1e5e2a`.
2828```solidity
2829function effectors() external view returns (Common.CIDV1[] memory);
2830```*/
2831    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2832    #[derive(Clone)]
2833    pub struct effectorsCall {}
2834    ///Container type for the return parameters of the [`effectors()`](effectorsCall) function.
2835    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2836    #[derive(Clone)]
2837    pub struct effectorsReturn {
2838        #[allow(missing_docs)]
2839        pub _0: alloy::sol_types::private::Vec<
2840            <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
2841        >,
2842    }
2843    #[allow(
2844        non_camel_case_types,
2845        non_snake_case,
2846        clippy::pub_underscore_fields,
2847        clippy::style
2848    )]
2849    const _: () = {
2850        use alloy::sol_types as alloy_sol_types;
2851        {
2852            #[doc(hidden)]
2853            type UnderlyingSolTuple<'a> = ();
2854            #[doc(hidden)]
2855            type UnderlyingRustTuple<'a> = ();
2856            #[cfg(test)]
2857            #[allow(dead_code, unreachable_patterns)]
2858            fn _type_assertion(
2859                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2860            ) {
2861                match _t {
2862                    alloy_sol_types::private::AssertTypeEq::<
2863                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2864                    >(_) => {}
2865                }
2866            }
2867            #[automatically_derived]
2868            #[doc(hidden)]
2869            impl ::core::convert::From<effectorsCall> for UnderlyingRustTuple<'_> {
2870                fn from(value: effectorsCall) -> Self {
2871                    ()
2872                }
2873            }
2874            #[automatically_derived]
2875            #[doc(hidden)]
2876            impl ::core::convert::From<UnderlyingRustTuple<'_>> for effectorsCall {
2877                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2878                    Self {}
2879                }
2880            }
2881        }
2882        {
2883            #[doc(hidden)]
2884            type UnderlyingSolTuple<'a> = (
2885                alloy::sol_types::sol_data::Array<Common::CIDV1>,
2886            );
2887            #[doc(hidden)]
2888            type UnderlyingRustTuple<'a> = (
2889                alloy::sol_types::private::Vec<
2890                    <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
2891                >,
2892            );
2893            #[cfg(test)]
2894            #[allow(dead_code, unreachable_patterns)]
2895            fn _type_assertion(
2896                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2897            ) {
2898                match _t {
2899                    alloy_sol_types::private::AssertTypeEq::<
2900                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2901                    >(_) => {}
2902                }
2903            }
2904            #[automatically_derived]
2905            #[doc(hidden)]
2906            impl ::core::convert::From<effectorsReturn> for UnderlyingRustTuple<'_> {
2907                fn from(value: effectorsReturn) -> Self {
2908                    (value._0,)
2909                }
2910            }
2911            #[automatically_derived]
2912            #[doc(hidden)]
2913            impl ::core::convert::From<UnderlyingRustTuple<'_>> for effectorsReturn {
2914                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2915                    Self { _0: tuple.0 }
2916                }
2917            }
2918        }
2919        #[automatically_derived]
2920        impl alloy_sol_types::SolCall for effectorsCall {
2921            type Parameters<'a> = ();
2922            type Token<'a> = <Self::Parameters<
2923                'a,
2924            > as alloy_sol_types::SolType>::Token<'a>;
2925            type Return = effectorsReturn;
2926            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Array<Common::CIDV1>,);
2927            type ReturnToken<'a> = <Self::ReturnTuple<
2928                'a,
2929            > as alloy_sol_types::SolType>::Token<'a>;
2930            const SIGNATURE: &'static str = "effectors()";
2931            const SELECTOR: [u8; 4] = [252u8, 30u8, 94u8, 42u8];
2932            #[inline]
2933            fn new<'a>(
2934                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2935            ) -> Self {
2936                tuple.into()
2937            }
2938            #[inline]
2939            fn tokenize(&self) -> Self::Token<'_> {
2940                ()
2941            }
2942            #[inline]
2943            fn abi_decode_returns(
2944                data: &[u8],
2945                validate: bool,
2946            ) -> alloy_sol_types::Result<Self::Return> {
2947                <Self::ReturnTuple<
2948                    '_,
2949                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2950                    .map(Into::into)
2951            }
2952        }
2953    };
2954    /**Function with signature `isProviderAllowed(address)` and selector `0x3e8ae1ae`.
2955```solidity
2956function isProviderAllowed(address account) external view returns (bool);
2957```*/
2958    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2959    #[derive(Clone)]
2960    pub struct isProviderAllowedCall {
2961        #[allow(missing_docs)]
2962        pub account: alloy::sol_types::private::Address,
2963    }
2964    ///Container type for the return parameters of the [`isProviderAllowed(address)`](isProviderAllowedCall) function.
2965    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2966    #[derive(Clone)]
2967    pub struct isProviderAllowedReturn {
2968        #[allow(missing_docs)]
2969        pub _0: bool,
2970    }
2971    #[allow(
2972        non_camel_case_types,
2973        non_snake_case,
2974        clippy::pub_underscore_fields,
2975        clippy::style
2976    )]
2977    const _: () = {
2978        use alloy::sol_types as alloy_sol_types;
2979        {
2980            #[doc(hidden)]
2981            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2982            #[doc(hidden)]
2983            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2984            #[cfg(test)]
2985            #[allow(dead_code, unreachable_patterns)]
2986            fn _type_assertion(
2987                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2988            ) {
2989                match _t {
2990                    alloy_sol_types::private::AssertTypeEq::<
2991                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2992                    >(_) => {}
2993                }
2994            }
2995            #[automatically_derived]
2996            #[doc(hidden)]
2997            impl ::core::convert::From<isProviderAllowedCall>
2998            for UnderlyingRustTuple<'_> {
2999                fn from(value: isProviderAllowedCall) -> Self {
3000                    (value.account,)
3001                }
3002            }
3003            #[automatically_derived]
3004            #[doc(hidden)]
3005            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3006            for isProviderAllowedCall {
3007                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3008                    Self { account: tuple.0 }
3009                }
3010            }
3011        }
3012        {
3013            #[doc(hidden)]
3014            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3015            #[doc(hidden)]
3016            type UnderlyingRustTuple<'a> = (bool,);
3017            #[cfg(test)]
3018            #[allow(dead_code, unreachable_patterns)]
3019            fn _type_assertion(
3020                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3021            ) {
3022                match _t {
3023                    alloy_sol_types::private::AssertTypeEq::<
3024                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3025                    >(_) => {}
3026                }
3027            }
3028            #[automatically_derived]
3029            #[doc(hidden)]
3030            impl ::core::convert::From<isProviderAllowedReturn>
3031            for UnderlyingRustTuple<'_> {
3032                fn from(value: isProviderAllowedReturn) -> Self {
3033                    (value._0,)
3034                }
3035            }
3036            #[automatically_derived]
3037            #[doc(hidden)]
3038            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3039            for isProviderAllowedReturn {
3040                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3041                    Self { _0: tuple.0 }
3042                }
3043            }
3044        }
3045        #[automatically_derived]
3046        impl alloy_sol_types::SolCall for isProviderAllowedCall {
3047            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3048            type Token<'a> = <Self::Parameters<
3049                'a,
3050            > as alloy_sol_types::SolType>::Token<'a>;
3051            type Return = isProviderAllowedReturn;
3052            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3053            type ReturnToken<'a> = <Self::ReturnTuple<
3054                'a,
3055            > as alloy_sol_types::SolType>::Token<'a>;
3056            const SIGNATURE: &'static str = "isProviderAllowed(address)";
3057            const SELECTOR: [u8; 4] = [62u8, 138u8, 225u8, 174u8];
3058            #[inline]
3059            fn new<'a>(
3060                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3061            ) -> Self {
3062                tuple.into()
3063            }
3064            #[inline]
3065            fn tokenize(&self) -> Self::Token<'_> {
3066                (
3067                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3068                        &self.account,
3069                    ),
3070                )
3071            }
3072            #[inline]
3073            fn abi_decode_returns(
3074                data: &[u8],
3075                validate: bool,
3076            ) -> alloy_sol_types::Result<Self::Return> {
3077                <Self::ReturnTuple<
3078                    '_,
3079                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3080                    .map(Into::into)
3081            }
3082        }
3083    };
3084    /**Function with signature `maxWorkersPerProvider()` and selector `0x8a0c725b`.
3085```solidity
3086function maxWorkersPerProvider() external view returns (uint256);
3087```*/
3088    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3089    #[derive(Clone)]
3090    pub struct maxWorkersPerProviderCall {}
3091    ///Container type for the return parameters of the [`maxWorkersPerProvider()`](maxWorkersPerProviderCall) function.
3092    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3093    #[derive(Clone)]
3094    pub struct maxWorkersPerProviderReturn {
3095        #[allow(missing_docs)]
3096        pub _0: alloy::sol_types::private::primitives::aliases::U256,
3097    }
3098    #[allow(
3099        non_camel_case_types,
3100        non_snake_case,
3101        clippy::pub_underscore_fields,
3102        clippy::style
3103    )]
3104    const _: () = {
3105        use alloy::sol_types as alloy_sol_types;
3106        {
3107            #[doc(hidden)]
3108            type UnderlyingSolTuple<'a> = ();
3109            #[doc(hidden)]
3110            type UnderlyingRustTuple<'a> = ();
3111            #[cfg(test)]
3112            #[allow(dead_code, unreachable_patterns)]
3113            fn _type_assertion(
3114                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3115            ) {
3116                match _t {
3117                    alloy_sol_types::private::AssertTypeEq::<
3118                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3119                    >(_) => {}
3120                }
3121            }
3122            #[automatically_derived]
3123            #[doc(hidden)]
3124            impl ::core::convert::From<maxWorkersPerProviderCall>
3125            for UnderlyingRustTuple<'_> {
3126                fn from(value: maxWorkersPerProviderCall) -> Self {
3127                    ()
3128                }
3129            }
3130            #[automatically_derived]
3131            #[doc(hidden)]
3132            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3133            for maxWorkersPerProviderCall {
3134                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3135                    Self {}
3136                }
3137            }
3138        }
3139        {
3140            #[doc(hidden)]
3141            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3142            #[doc(hidden)]
3143            type UnderlyingRustTuple<'a> = (
3144                alloy::sol_types::private::primitives::aliases::U256,
3145            );
3146            #[cfg(test)]
3147            #[allow(dead_code, unreachable_patterns)]
3148            fn _type_assertion(
3149                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3150            ) {
3151                match _t {
3152                    alloy_sol_types::private::AssertTypeEq::<
3153                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3154                    >(_) => {}
3155                }
3156            }
3157            #[automatically_derived]
3158            #[doc(hidden)]
3159            impl ::core::convert::From<maxWorkersPerProviderReturn>
3160            for UnderlyingRustTuple<'_> {
3161                fn from(value: maxWorkersPerProviderReturn) -> Self {
3162                    (value._0,)
3163                }
3164            }
3165            #[automatically_derived]
3166            #[doc(hidden)]
3167            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3168            for maxWorkersPerProviderReturn {
3169                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3170                    Self { _0: tuple.0 }
3171                }
3172            }
3173        }
3174        #[automatically_derived]
3175        impl alloy_sol_types::SolCall for maxWorkersPerProviderCall {
3176            type Parameters<'a> = ();
3177            type Token<'a> = <Self::Parameters<
3178                'a,
3179            > as alloy_sol_types::SolType>::Token<'a>;
3180            type Return = maxWorkersPerProviderReturn;
3181            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3182            type ReturnToken<'a> = <Self::ReturnTuple<
3183                'a,
3184            > as alloy_sol_types::SolType>::Token<'a>;
3185            const SIGNATURE: &'static str = "maxWorkersPerProvider()";
3186            const SELECTOR: [u8; 4] = [138u8, 12u8, 114u8, 91u8];
3187            #[inline]
3188            fn new<'a>(
3189                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3190            ) -> Self {
3191                tuple.into()
3192            }
3193            #[inline]
3194            fn tokenize(&self) -> Self::Token<'_> {
3195                ()
3196            }
3197            #[inline]
3198            fn abi_decode_returns(
3199                data: &[u8],
3200                validate: bool,
3201            ) -> alloy_sol_types::Result<Self::Return> {
3202                <Self::ReturnTuple<
3203                    '_,
3204                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3205                    .map(Into::into)
3206            }
3207        }
3208    };
3209    /**Function with signature `minWorkers()` and selector `0x2db31193`.
3210```solidity
3211function minWorkers() external view returns (uint256);
3212```*/
3213    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3214    #[derive(Clone)]
3215    pub struct minWorkersCall {}
3216    ///Container type for the return parameters of the [`minWorkers()`](minWorkersCall) function.
3217    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3218    #[derive(Clone)]
3219    pub struct minWorkersReturn {
3220        #[allow(missing_docs)]
3221        pub _0: alloy::sol_types::private::primitives::aliases::U256,
3222    }
3223    #[allow(
3224        non_camel_case_types,
3225        non_snake_case,
3226        clippy::pub_underscore_fields,
3227        clippy::style
3228    )]
3229    const _: () = {
3230        use alloy::sol_types as alloy_sol_types;
3231        {
3232            #[doc(hidden)]
3233            type UnderlyingSolTuple<'a> = ();
3234            #[doc(hidden)]
3235            type UnderlyingRustTuple<'a> = ();
3236            #[cfg(test)]
3237            #[allow(dead_code, unreachable_patterns)]
3238            fn _type_assertion(
3239                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3240            ) {
3241                match _t {
3242                    alloy_sol_types::private::AssertTypeEq::<
3243                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3244                    >(_) => {}
3245                }
3246            }
3247            #[automatically_derived]
3248            #[doc(hidden)]
3249            impl ::core::convert::From<minWorkersCall> for UnderlyingRustTuple<'_> {
3250                fn from(value: minWorkersCall) -> Self {
3251                    ()
3252                }
3253            }
3254            #[automatically_derived]
3255            #[doc(hidden)]
3256            impl ::core::convert::From<UnderlyingRustTuple<'_>> for minWorkersCall {
3257                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3258                    Self {}
3259                }
3260            }
3261        }
3262        {
3263            #[doc(hidden)]
3264            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3265            #[doc(hidden)]
3266            type UnderlyingRustTuple<'a> = (
3267                alloy::sol_types::private::primitives::aliases::U256,
3268            );
3269            #[cfg(test)]
3270            #[allow(dead_code, unreachable_patterns)]
3271            fn _type_assertion(
3272                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3273            ) {
3274                match _t {
3275                    alloy_sol_types::private::AssertTypeEq::<
3276                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3277                    >(_) => {}
3278                }
3279            }
3280            #[automatically_derived]
3281            #[doc(hidden)]
3282            impl ::core::convert::From<minWorkersReturn> for UnderlyingRustTuple<'_> {
3283                fn from(value: minWorkersReturn) -> Self {
3284                    (value._0,)
3285                }
3286            }
3287            #[automatically_derived]
3288            #[doc(hidden)]
3289            impl ::core::convert::From<UnderlyingRustTuple<'_>> for minWorkersReturn {
3290                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3291                    Self { _0: tuple.0 }
3292                }
3293            }
3294        }
3295        #[automatically_derived]
3296        impl alloy_sol_types::SolCall for minWorkersCall {
3297            type Parameters<'a> = ();
3298            type Token<'a> = <Self::Parameters<
3299                'a,
3300            > as alloy_sol_types::SolType>::Token<'a>;
3301            type Return = minWorkersReturn;
3302            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3303            type ReturnToken<'a> = <Self::ReturnTuple<
3304                'a,
3305            > as alloy_sol_types::SolType>::Token<'a>;
3306            const SIGNATURE: &'static str = "minWorkers()";
3307            const SELECTOR: [u8; 4] = [45u8, 179u8, 17u8, 147u8];
3308            #[inline]
3309            fn new<'a>(
3310                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3311            ) -> Self {
3312                tuple.into()
3313            }
3314            #[inline]
3315            fn tokenize(&self) -> Self::Token<'_> {
3316                ()
3317            }
3318            #[inline]
3319            fn abi_decode_returns(
3320                data: &[u8],
3321                validate: bool,
3322            ) -> alloy_sol_types::Result<Self::Return> {
3323                <Self::ReturnTuple<
3324                    '_,
3325                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3326                    .map(Into::into)
3327            }
3328        }
3329    };
3330    /**Function with signature `owner()` and selector `0x8da5cb5b`.
3331```solidity
3332function owner() external view returns (address);
3333```*/
3334    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3335    #[derive(Clone)]
3336    pub struct ownerCall {}
3337    ///Container type for the return parameters of the [`owner()`](ownerCall) function.
3338    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3339    #[derive(Clone)]
3340    pub struct ownerReturn {
3341        #[allow(missing_docs)]
3342        pub _0: alloy::sol_types::private::Address,
3343    }
3344    #[allow(
3345        non_camel_case_types,
3346        non_snake_case,
3347        clippy::pub_underscore_fields,
3348        clippy::style
3349    )]
3350    const _: () = {
3351        use alloy::sol_types as alloy_sol_types;
3352        {
3353            #[doc(hidden)]
3354            type UnderlyingSolTuple<'a> = ();
3355            #[doc(hidden)]
3356            type UnderlyingRustTuple<'a> = ();
3357            #[cfg(test)]
3358            #[allow(dead_code, unreachable_patterns)]
3359            fn _type_assertion(
3360                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3361            ) {
3362                match _t {
3363                    alloy_sol_types::private::AssertTypeEq::<
3364                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3365                    >(_) => {}
3366                }
3367            }
3368            #[automatically_derived]
3369            #[doc(hidden)]
3370            impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
3371                fn from(value: ownerCall) -> Self {
3372                    ()
3373                }
3374            }
3375            #[automatically_derived]
3376            #[doc(hidden)]
3377            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
3378                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3379                    Self {}
3380                }
3381            }
3382        }
3383        {
3384            #[doc(hidden)]
3385            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3386            #[doc(hidden)]
3387            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3388            #[cfg(test)]
3389            #[allow(dead_code, unreachable_patterns)]
3390            fn _type_assertion(
3391                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3392            ) {
3393                match _t {
3394                    alloy_sol_types::private::AssertTypeEq::<
3395                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3396                    >(_) => {}
3397                }
3398            }
3399            #[automatically_derived]
3400            #[doc(hidden)]
3401            impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
3402                fn from(value: ownerReturn) -> Self {
3403                    (value._0,)
3404                }
3405            }
3406            #[automatically_derived]
3407            #[doc(hidden)]
3408            impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
3409                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3410                    Self { _0: tuple.0 }
3411                }
3412            }
3413        }
3414        #[automatically_derived]
3415        impl alloy_sol_types::SolCall for ownerCall {
3416            type Parameters<'a> = ();
3417            type Token<'a> = <Self::Parameters<
3418                'a,
3419            > as alloy_sol_types::SolType>::Token<'a>;
3420            type Return = ownerReturn;
3421            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3422            type ReturnToken<'a> = <Self::ReturnTuple<
3423                'a,
3424            > as alloy_sol_types::SolType>::Token<'a>;
3425            const SIGNATURE: &'static str = "owner()";
3426            const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
3427            #[inline]
3428            fn new<'a>(
3429                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3430            ) -> Self {
3431                tuple.into()
3432            }
3433            #[inline]
3434            fn tokenize(&self) -> Self::Token<'_> {
3435                ()
3436            }
3437            #[inline]
3438            fn abi_decode_returns(
3439                data: &[u8],
3440                validate: bool,
3441            ) -> alloy_sol_types::Result<Self::Return> {
3442                <Self::ReturnTuple<
3443                    '_,
3444                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3445                    .map(Into::into)
3446            }
3447        }
3448    };
3449    /**Function with signature `paymentToken()` and selector `0x3013ce29`.
3450```solidity
3451function paymentToken() external view returns (address);
3452```*/
3453    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3454    #[derive(Clone)]
3455    pub struct paymentTokenCall {}
3456    ///Container type for the return parameters of the [`paymentToken()`](paymentTokenCall) function.
3457    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3458    #[derive(Clone)]
3459    pub struct paymentTokenReturn {
3460        #[allow(missing_docs)]
3461        pub _0: alloy::sol_types::private::Address,
3462    }
3463    #[allow(
3464        non_camel_case_types,
3465        non_snake_case,
3466        clippy::pub_underscore_fields,
3467        clippy::style
3468    )]
3469    const _: () = {
3470        use alloy::sol_types as alloy_sol_types;
3471        {
3472            #[doc(hidden)]
3473            type UnderlyingSolTuple<'a> = ();
3474            #[doc(hidden)]
3475            type UnderlyingRustTuple<'a> = ();
3476            #[cfg(test)]
3477            #[allow(dead_code, unreachable_patterns)]
3478            fn _type_assertion(
3479                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3480            ) {
3481                match _t {
3482                    alloy_sol_types::private::AssertTypeEq::<
3483                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3484                    >(_) => {}
3485                }
3486            }
3487            #[automatically_derived]
3488            #[doc(hidden)]
3489            impl ::core::convert::From<paymentTokenCall> for UnderlyingRustTuple<'_> {
3490                fn from(value: paymentTokenCall) -> Self {
3491                    ()
3492                }
3493            }
3494            #[automatically_derived]
3495            #[doc(hidden)]
3496            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paymentTokenCall {
3497                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3498                    Self {}
3499                }
3500            }
3501        }
3502        {
3503            #[doc(hidden)]
3504            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3505            #[doc(hidden)]
3506            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3507            #[cfg(test)]
3508            #[allow(dead_code, unreachable_patterns)]
3509            fn _type_assertion(
3510                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3511            ) {
3512                match _t {
3513                    alloy_sol_types::private::AssertTypeEq::<
3514                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3515                    >(_) => {}
3516                }
3517            }
3518            #[automatically_derived]
3519            #[doc(hidden)]
3520            impl ::core::convert::From<paymentTokenReturn> for UnderlyingRustTuple<'_> {
3521                fn from(value: paymentTokenReturn) -> Self {
3522                    (value._0,)
3523                }
3524            }
3525            #[automatically_derived]
3526            #[doc(hidden)]
3527            impl ::core::convert::From<UnderlyingRustTuple<'_>> for paymentTokenReturn {
3528                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3529                    Self { _0: tuple.0 }
3530                }
3531            }
3532        }
3533        #[automatically_derived]
3534        impl alloy_sol_types::SolCall for paymentTokenCall {
3535            type Parameters<'a> = ();
3536            type Token<'a> = <Self::Parameters<
3537                'a,
3538            > as alloy_sol_types::SolType>::Token<'a>;
3539            type Return = paymentTokenReturn;
3540            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
3541            type ReturnToken<'a> = <Self::ReturnTuple<
3542                'a,
3543            > as alloy_sol_types::SolType>::Token<'a>;
3544            const SIGNATURE: &'static str = "paymentToken()";
3545            const SELECTOR: [u8; 4] = [48u8, 19u8, 206u8, 41u8];
3546            #[inline]
3547            fn new<'a>(
3548                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3549            ) -> Self {
3550                tuple.into()
3551            }
3552            #[inline]
3553            fn tokenize(&self) -> Self::Token<'_> {
3554                ()
3555            }
3556            #[inline]
3557            fn abi_decode_returns(
3558                data: &[u8],
3559                validate: bool,
3560            ) -> alloy_sol_types::Result<Self::Return> {
3561                <Self::ReturnTuple<
3562                    '_,
3563                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3564                    .map(Into::into)
3565            }
3566        }
3567    };
3568    /**Function with signature `pricePerCuPerEpoch()` and selector `0x70220a9b`.
3569```solidity
3570function pricePerCuPerEpoch() external view returns (uint256);
3571```*/
3572    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3573    #[derive(Clone)]
3574    pub struct pricePerCuPerEpochCall {}
3575    ///Container type for the return parameters of the [`pricePerCuPerEpoch()`](pricePerCuPerEpochCall) function.
3576    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3577    #[derive(Clone)]
3578    pub struct pricePerCuPerEpochReturn {
3579        #[allow(missing_docs)]
3580        pub _0: alloy::sol_types::private::primitives::aliases::U256,
3581    }
3582    #[allow(
3583        non_camel_case_types,
3584        non_snake_case,
3585        clippy::pub_underscore_fields,
3586        clippy::style
3587    )]
3588    const _: () = {
3589        use alloy::sol_types as alloy_sol_types;
3590        {
3591            #[doc(hidden)]
3592            type UnderlyingSolTuple<'a> = ();
3593            #[doc(hidden)]
3594            type UnderlyingRustTuple<'a> = ();
3595            #[cfg(test)]
3596            #[allow(dead_code, unreachable_patterns)]
3597            fn _type_assertion(
3598                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3599            ) {
3600                match _t {
3601                    alloy_sol_types::private::AssertTypeEq::<
3602                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3603                    >(_) => {}
3604                }
3605            }
3606            #[automatically_derived]
3607            #[doc(hidden)]
3608            impl ::core::convert::From<pricePerCuPerEpochCall>
3609            for UnderlyingRustTuple<'_> {
3610                fn from(value: pricePerCuPerEpochCall) -> Self {
3611                    ()
3612                }
3613            }
3614            #[automatically_derived]
3615            #[doc(hidden)]
3616            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3617            for pricePerCuPerEpochCall {
3618                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3619                    Self {}
3620                }
3621            }
3622        }
3623        {
3624            #[doc(hidden)]
3625            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3626            #[doc(hidden)]
3627            type UnderlyingRustTuple<'a> = (
3628                alloy::sol_types::private::primitives::aliases::U256,
3629            );
3630            #[cfg(test)]
3631            #[allow(dead_code, unreachable_patterns)]
3632            fn _type_assertion(
3633                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3634            ) {
3635                match _t {
3636                    alloy_sol_types::private::AssertTypeEq::<
3637                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3638                    >(_) => {}
3639                }
3640            }
3641            #[automatically_derived]
3642            #[doc(hidden)]
3643            impl ::core::convert::From<pricePerCuPerEpochReturn>
3644            for UnderlyingRustTuple<'_> {
3645                fn from(value: pricePerCuPerEpochReturn) -> Self {
3646                    (value._0,)
3647                }
3648            }
3649            #[automatically_derived]
3650            #[doc(hidden)]
3651            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3652            for pricePerCuPerEpochReturn {
3653                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3654                    Self { _0: tuple.0 }
3655                }
3656            }
3657        }
3658        #[automatically_derived]
3659        impl alloy_sol_types::SolCall for pricePerCuPerEpochCall {
3660            type Parameters<'a> = ();
3661            type Token<'a> = <Self::Parameters<
3662                'a,
3663            > as alloy_sol_types::SolType>::Token<'a>;
3664            type Return = pricePerCuPerEpochReturn;
3665            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3666            type ReturnToken<'a> = <Self::ReturnTuple<
3667                'a,
3668            > as alloy_sol_types::SolType>::Token<'a>;
3669            const SIGNATURE: &'static str = "pricePerCuPerEpoch()";
3670            const SELECTOR: [u8; 4] = [112u8, 34u8, 10u8, 155u8];
3671            #[inline]
3672            fn new<'a>(
3673                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3674            ) -> Self {
3675                tuple.into()
3676            }
3677            #[inline]
3678            fn tokenize(&self) -> Self::Token<'_> {
3679                ()
3680            }
3681            #[inline]
3682            fn abi_decode_returns(
3683                data: &[u8],
3684                validate: bool,
3685            ) -> alloy_sol_types::Result<Self::Return> {
3686                <Self::ReturnTuple<
3687                    '_,
3688                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3689                    .map(Into::into)
3690            }
3691        }
3692    };
3693    /**Function with signature `providersAccessType()` and selector `0xd4773ff0`.
3694```solidity
3695function providersAccessType() external view returns (IConfig.AccessType);
3696```*/
3697    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3698    #[derive(Clone)]
3699    pub struct providersAccessTypeCall {}
3700    ///Container type for the return parameters of the [`providersAccessType()`](providersAccessTypeCall) function.
3701    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3702    #[derive(Clone)]
3703    pub struct providersAccessTypeReturn {
3704        #[allow(missing_docs)]
3705        pub _0: <IConfig::AccessType as alloy::sol_types::SolType>::RustType,
3706    }
3707    #[allow(
3708        non_camel_case_types,
3709        non_snake_case,
3710        clippy::pub_underscore_fields,
3711        clippy::style
3712    )]
3713    const _: () = {
3714        use alloy::sol_types as alloy_sol_types;
3715        {
3716            #[doc(hidden)]
3717            type UnderlyingSolTuple<'a> = ();
3718            #[doc(hidden)]
3719            type UnderlyingRustTuple<'a> = ();
3720            #[cfg(test)]
3721            #[allow(dead_code, unreachable_patterns)]
3722            fn _type_assertion(
3723                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3724            ) {
3725                match _t {
3726                    alloy_sol_types::private::AssertTypeEq::<
3727                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3728                    >(_) => {}
3729                }
3730            }
3731            #[automatically_derived]
3732            #[doc(hidden)]
3733            impl ::core::convert::From<providersAccessTypeCall>
3734            for UnderlyingRustTuple<'_> {
3735                fn from(value: providersAccessTypeCall) -> Self {
3736                    ()
3737                }
3738            }
3739            #[automatically_derived]
3740            #[doc(hidden)]
3741            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3742            for providersAccessTypeCall {
3743                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3744                    Self {}
3745                }
3746            }
3747        }
3748        {
3749            #[doc(hidden)]
3750            type UnderlyingSolTuple<'a> = (IConfig::AccessType,);
3751            #[doc(hidden)]
3752            type UnderlyingRustTuple<'a> = (
3753                <IConfig::AccessType as alloy::sol_types::SolType>::RustType,
3754            );
3755            #[cfg(test)]
3756            #[allow(dead_code, unreachable_patterns)]
3757            fn _type_assertion(
3758                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3759            ) {
3760                match _t {
3761                    alloy_sol_types::private::AssertTypeEq::<
3762                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3763                    >(_) => {}
3764                }
3765            }
3766            #[automatically_derived]
3767            #[doc(hidden)]
3768            impl ::core::convert::From<providersAccessTypeReturn>
3769            for UnderlyingRustTuple<'_> {
3770                fn from(value: providersAccessTypeReturn) -> Self {
3771                    (value._0,)
3772                }
3773            }
3774            #[automatically_derived]
3775            #[doc(hidden)]
3776            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3777            for providersAccessTypeReturn {
3778                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3779                    Self { _0: tuple.0 }
3780                }
3781            }
3782        }
3783        #[automatically_derived]
3784        impl alloy_sol_types::SolCall for providersAccessTypeCall {
3785            type Parameters<'a> = ();
3786            type Token<'a> = <Self::Parameters<
3787                'a,
3788            > as alloy_sol_types::SolType>::Token<'a>;
3789            type Return = providersAccessTypeReturn;
3790            type ReturnTuple<'a> = (IConfig::AccessType,);
3791            type ReturnToken<'a> = <Self::ReturnTuple<
3792                'a,
3793            > as alloy_sol_types::SolType>::Token<'a>;
3794            const SIGNATURE: &'static str = "providersAccessType()";
3795            const SELECTOR: [u8; 4] = [212u8, 119u8, 63u8, 240u8];
3796            #[inline]
3797            fn new<'a>(
3798                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3799            ) -> Self {
3800                tuple.into()
3801            }
3802            #[inline]
3803            fn tokenize(&self) -> Self::Token<'_> {
3804                ()
3805            }
3806            #[inline]
3807            fn abi_decode_returns(
3808                data: &[u8],
3809                validate: bool,
3810            ) -> alloy_sol_types::Result<Self::Return> {
3811                <Self::ReturnTuple<
3812                    '_,
3813                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3814                    .map(Into::into)
3815            }
3816        }
3817    };
3818    /**Function with signature `removeProviderFromAccessList(address)` and selector `0x444e6a5a`.
3819```solidity
3820function removeProviderFromAccessList(address provider) external;
3821```*/
3822    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3823    #[derive(Clone)]
3824    pub struct removeProviderFromAccessListCall {
3825        #[allow(missing_docs)]
3826        pub provider: alloy::sol_types::private::Address,
3827    }
3828    ///Container type for the return parameters of the [`removeProviderFromAccessList(address)`](removeProviderFromAccessListCall) function.
3829    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3830    #[derive(Clone)]
3831    pub struct removeProviderFromAccessListReturn {}
3832    #[allow(
3833        non_camel_case_types,
3834        non_snake_case,
3835        clippy::pub_underscore_fields,
3836        clippy::style
3837    )]
3838    const _: () = {
3839        use alloy::sol_types as alloy_sol_types;
3840        {
3841            #[doc(hidden)]
3842            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3843            #[doc(hidden)]
3844            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3845            #[cfg(test)]
3846            #[allow(dead_code, unreachable_patterns)]
3847            fn _type_assertion(
3848                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3849            ) {
3850                match _t {
3851                    alloy_sol_types::private::AssertTypeEq::<
3852                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3853                    >(_) => {}
3854                }
3855            }
3856            #[automatically_derived]
3857            #[doc(hidden)]
3858            impl ::core::convert::From<removeProviderFromAccessListCall>
3859            for UnderlyingRustTuple<'_> {
3860                fn from(value: removeProviderFromAccessListCall) -> Self {
3861                    (value.provider,)
3862                }
3863            }
3864            #[automatically_derived]
3865            #[doc(hidden)]
3866            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3867            for removeProviderFromAccessListCall {
3868                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3869                    Self { provider: tuple.0 }
3870                }
3871            }
3872        }
3873        {
3874            #[doc(hidden)]
3875            type UnderlyingSolTuple<'a> = ();
3876            #[doc(hidden)]
3877            type UnderlyingRustTuple<'a> = ();
3878            #[cfg(test)]
3879            #[allow(dead_code, unreachable_patterns)]
3880            fn _type_assertion(
3881                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3882            ) {
3883                match _t {
3884                    alloy_sol_types::private::AssertTypeEq::<
3885                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3886                    >(_) => {}
3887                }
3888            }
3889            #[automatically_derived]
3890            #[doc(hidden)]
3891            impl ::core::convert::From<removeProviderFromAccessListReturn>
3892            for UnderlyingRustTuple<'_> {
3893                fn from(value: removeProviderFromAccessListReturn) -> Self {
3894                    ()
3895                }
3896            }
3897            #[automatically_derived]
3898            #[doc(hidden)]
3899            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3900            for removeProviderFromAccessListReturn {
3901                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3902                    Self {}
3903                }
3904            }
3905        }
3906        #[automatically_derived]
3907        impl alloy_sol_types::SolCall for removeProviderFromAccessListCall {
3908            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3909            type Token<'a> = <Self::Parameters<
3910                'a,
3911            > as alloy_sol_types::SolType>::Token<'a>;
3912            type Return = removeProviderFromAccessListReturn;
3913            type ReturnTuple<'a> = ();
3914            type ReturnToken<'a> = <Self::ReturnTuple<
3915                'a,
3916            > as alloy_sol_types::SolType>::Token<'a>;
3917            const SIGNATURE: &'static str = "removeProviderFromAccessList(address)";
3918            const SELECTOR: [u8; 4] = [68u8, 78u8, 106u8, 90u8];
3919            #[inline]
3920            fn new<'a>(
3921                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3922            ) -> Self {
3923                tuple.into()
3924            }
3925            #[inline]
3926            fn tokenize(&self) -> Self::Token<'_> {
3927                (
3928                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3929                        &self.provider,
3930                    ),
3931                )
3932            }
3933            #[inline]
3934            fn abi_decode_returns(
3935                data: &[u8],
3936                validate: bool,
3937            ) -> alloy_sol_types::Result<Self::Return> {
3938                <Self::ReturnTuple<
3939                    '_,
3940                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
3941                    .map(Into::into)
3942            }
3943        }
3944    };
3945    /**Function with signature `renounceOwnership()` and selector `0x715018a6`.
3946```solidity
3947function renounceOwnership() external;
3948```*/
3949    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3950    #[derive(Clone)]
3951    pub struct renounceOwnershipCall {}
3952    ///Container type for the return parameters of the [`renounceOwnership()`](renounceOwnershipCall) function.
3953    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3954    #[derive(Clone)]
3955    pub struct renounceOwnershipReturn {}
3956    #[allow(
3957        non_camel_case_types,
3958        non_snake_case,
3959        clippy::pub_underscore_fields,
3960        clippy::style
3961    )]
3962    const _: () = {
3963        use alloy::sol_types as alloy_sol_types;
3964        {
3965            #[doc(hidden)]
3966            type UnderlyingSolTuple<'a> = ();
3967            #[doc(hidden)]
3968            type UnderlyingRustTuple<'a> = ();
3969            #[cfg(test)]
3970            #[allow(dead_code, unreachable_patterns)]
3971            fn _type_assertion(
3972                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3973            ) {
3974                match _t {
3975                    alloy_sol_types::private::AssertTypeEq::<
3976                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3977                    >(_) => {}
3978                }
3979            }
3980            #[automatically_derived]
3981            #[doc(hidden)]
3982            impl ::core::convert::From<renounceOwnershipCall>
3983            for UnderlyingRustTuple<'_> {
3984                fn from(value: renounceOwnershipCall) -> Self {
3985                    ()
3986                }
3987            }
3988            #[automatically_derived]
3989            #[doc(hidden)]
3990            impl ::core::convert::From<UnderlyingRustTuple<'_>>
3991            for renounceOwnershipCall {
3992                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3993                    Self {}
3994                }
3995            }
3996        }
3997        {
3998            #[doc(hidden)]
3999            type UnderlyingSolTuple<'a> = ();
4000            #[doc(hidden)]
4001            type UnderlyingRustTuple<'a> = ();
4002            #[cfg(test)]
4003            #[allow(dead_code, unreachable_patterns)]
4004            fn _type_assertion(
4005                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4006            ) {
4007                match _t {
4008                    alloy_sol_types::private::AssertTypeEq::<
4009                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4010                    >(_) => {}
4011                }
4012            }
4013            #[automatically_derived]
4014            #[doc(hidden)]
4015            impl ::core::convert::From<renounceOwnershipReturn>
4016            for UnderlyingRustTuple<'_> {
4017                fn from(value: renounceOwnershipReturn) -> Self {
4018                    ()
4019                }
4020            }
4021            #[automatically_derived]
4022            #[doc(hidden)]
4023            impl ::core::convert::From<UnderlyingRustTuple<'_>>
4024            for renounceOwnershipReturn {
4025                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4026                    Self {}
4027                }
4028            }
4029        }
4030        #[automatically_derived]
4031        impl alloy_sol_types::SolCall for renounceOwnershipCall {
4032            type Parameters<'a> = ();
4033            type Token<'a> = <Self::Parameters<
4034                'a,
4035            > as alloy_sol_types::SolType>::Token<'a>;
4036            type Return = renounceOwnershipReturn;
4037            type ReturnTuple<'a> = ();
4038            type ReturnToken<'a> = <Self::ReturnTuple<
4039                'a,
4040            > as alloy_sol_types::SolType>::Token<'a>;
4041            const SIGNATURE: &'static str = "renounceOwnership()";
4042            const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
4043            #[inline]
4044            fn new<'a>(
4045                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4046            ) -> Self {
4047                tuple.into()
4048            }
4049            #[inline]
4050            fn tokenize(&self) -> Self::Token<'_> {
4051                ()
4052            }
4053            #[inline]
4054            fn abi_decode_returns(
4055                data: &[u8],
4056                validate: bool,
4057            ) -> alloy_sol_types::Result<Self::Return> {
4058                <Self::ReturnTuple<
4059                    '_,
4060                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4061                    .map(Into::into)
4062            }
4063        }
4064    };
4065    /**Function with signature `setAppCID((bytes4,bytes32))` and selector `0x176474cf`.
4066```solidity
4067function setAppCID(Common.CIDV1 memory appCID_) external;
4068```*/
4069    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4070    #[derive(Clone)]
4071    pub struct setAppCIDCall {
4072        #[allow(missing_docs)]
4073        pub appCID_: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
4074    }
4075    ///Container type for the return parameters of the [`setAppCID((bytes4,bytes32))`](setAppCIDCall) function.
4076    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4077    #[derive(Clone)]
4078    pub struct setAppCIDReturn {}
4079    #[allow(
4080        non_camel_case_types,
4081        non_snake_case,
4082        clippy::pub_underscore_fields,
4083        clippy::style
4084    )]
4085    const _: () = {
4086        use alloy::sol_types as alloy_sol_types;
4087        {
4088            #[doc(hidden)]
4089            type UnderlyingSolTuple<'a> = (Common::CIDV1,);
4090            #[doc(hidden)]
4091            type UnderlyingRustTuple<'a> = (
4092                <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
4093            );
4094            #[cfg(test)]
4095            #[allow(dead_code, unreachable_patterns)]
4096            fn _type_assertion(
4097                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4098            ) {
4099                match _t {
4100                    alloy_sol_types::private::AssertTypeEq::<
4101                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4102                    >(_) => {}
4103                }
4104            }
4105            #[automatically_derived]
4106            #[doc(hidden)]
4107            impl ::core::convert::From<setAppCIDCall> for UnderlyingRustTuple<'_> {
4108                fn from(value: setAppCIDCall) -> Self {
4109                    (value.appCID_,)
4110                }
4111            }
4112            #[automatically_derived]
4113            #[doc(hidden)]
4114            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppCIDCall {
4115                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4116                    Self { appCID_: tuple.0 }
4117                }
4118            }
4119        }
4120        {
4121            #[doc(hidden)]
4122            type UnderlyingSolTuple<'a> = ();
4123            #[doc(hidden)]
4124            type UnderlyingRustTuple<'a> = ();
4125            #[cfg(test)]
4126            #[allow(dead_code, unreachable_patterns)]
4127            fn _type_assertion(
4128                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4129            ) {
4130                match _t {
4131                    alloy_sol_types::private::AssertTypeEq::<
4132                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4133                    >(_) => {}
4134                }
4135            }
4136            #[automatically_derived]
4137            #[doc(hidden)]
4138            impl ::core::convert::From<setAppCIDReturn> for UnderlyingRustTuple<'_> {
4139                fn from(value: setAppCIDReturn) -> Self {
4140                    ()
4141                }
4142            }
4143            #[automatically_derived]
4144            #[doc(hidden)]
4145            impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppCIDReturn {
4146                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4147                    Self {}
4148                }
4149            }
4150        }
4151        #[automatically_derived]
4152        impl alloy_sol_types::SolCall for setAppCIDCall {
4153            type Parameters<'a> = (Common::CIDV1,);
4154            type Token<'a> = <Self::Parameters<
4155                'a,
4156            > as alloy_sol_types::SolType>::Token<'a>;
4157            type Return = setAppCIDReturn;
4158            type ReturnTuple<'a> = ();
4159            type ReturnToken<'a> = <Self::ReturnTuple<
4160                'a,
4161            > as alloy_sol_types::SolType>::Token<'a>;
4162            const SIGNATURE: &'static str = "setAppCID((bytes4,bytes32))";
4163            const SELECTOR: [u8; 4] = [23u8, 100u8, 116u8, 207u8];
4164            #[inline]
4165            fn new<'a>(
4166                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4167            ) -> Self {
4168                tuple.into()
4169            }
4170            #[inline]
4171            fn tokenize(&self) -> Self::Token<'_> {
4172                (<Common::CIDV1 as alloy_sol_types::SolType>::tokenize(&self.appCID_),)
4173            }
4174            #[inline]
4175            fn abi_decode_returns(
4176                data: &[u8],
4177                validate: bool,
4178            ) -> alloy_sol_types::Result<Self::Return> {
4179                <Self::ReturnTuple<
4180                    '_,
4181                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4182                    .map(Into::into)
4183            }
4184        }
4185    };
4186    /**Function with signature `targetWorkers()` and selector `0x2943dcab`.
4187```solidity
4188function targetWorkers() external view returns (uint256);
4189```*/
4190    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4191    #[derive(Clone)]
4192    pub struct targetWorkersCall {}
4193    ///Container type for the return parameters of the [`targetWorkers()`](targetWorkersCall) function.
4194    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4195    #[derive(Clone)]
4196    pub struct targetWorkersReturn {
4197        #[allow(missing_docs)]
4198        pub _0: alloy::sol_types::private::primitives::aliases::U256,
4199    }
4200    #[allow(
4201        non_camel_case_types,
4202        non_snake_case,
4203        clippy::pub_underscore_fields,
4204        clippy::style
4205    )]
4206    const _: () = {
4207        use alloy::sol_types as alloy_sol_types;
4208        {
4209            #[doc(hidden)]
4210            type UnderlyingSolTuple<'a> = ();
4211            #[doc(hidden)]
4212            type UnderlyingRustTuple<'a> = ();
4213            #[cfg(test)]
4214            #[allow(dead_code, unreachable_patterns)]
4215            fn _type_assertion(
4216                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4217            ) {
4218                match _t {
4219                    alloy_sol_types::private::AssertTypeEq::<
4220                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4221                    >(_) => {}
4222                }
4223            }
4224            #[automatically_derived]
4225            #[doc(hidden)]
4226            impl ::core::convert::From<targetWorkersCall> for UnderlyingRustTuple<'_> {
4227                fn from(value: targetWorkersCall) -> Self {
4228                    ()
4229                }
4230            }
4231            #[automatically_derived]
4232            #[doc(hidden)]
4233            impl ::core::convert::From<UnderlyingRustTuple<'_>> for targetWorkersCall {
4234                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4235                    Self {}
4236                }
4237            }
4238        }
4239        {
4240            #[doc(hidden)]
4241            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4242            #[doc(hidden)]
4243            type UnderlyingRustTuple<'a> = (
4244                alloy::sol_types::private::primitives::aliases::U256,
4245            );
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<targetWorkersReturn> for UnderlyingRustTuple<'_> {
4260                fn from(value: targetWorkersReturn) -> Self {
4261                    (value._0,)
4262                }
4263            }
4264            #[automatically_derived]
4265            #[doc(hidden)]
4266            impl ::core::convert::From<UnderlyingRustTuple<'_>> for targetWorkersReturn {
4267                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4268                    Self { _0: tuple.0 }
4269                }
4270            }
4271        }
4272        #[automatically_derived]
4273        impl alloy_sol_types::SolCall for targetWorkersCall {
4274            type Parameters<'a> = ();
4275            type Token<'a> = <Self::Parameters<
4276                'a,
4277            > as alloy_sol_types::SolType>::Token<'a>;
4278            type Return = targetWorkersReturn;
4279            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
4280            type ReturnToken<'a> = <Self::ReturnTuple<
4281                'a,
4282            > as alloy_sol_types::SolType>::Token<'a>;
4283            const SIGNATURE: &'static str = "targetWorkers()";
4284            const SELECTOR: [u8; 4] = [41u8, 67u8, 220u8, 171u8];
4285            #[inline]
4286            fn new<'a>(
4287                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4288            ) -> Self {
4289                tuple.into()
4290            }
4291            #[inline]
4292            fn tokenize(&self) -> Self::Token<'_> {
4293                ()
4294            }
4295            #[inline]
4296            fn abi_decode_returns(
4297                data: &[u8],
4298                validate: bool,
4299            ) -> alloy_sol_types::Result<Self::Return> {
4300                <Self::ReturnTuple<
4301                    '_,
4302                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4303                    .map(Into::into)
4304            }
4305        }
4306    };
4307    /**Function with signature `transferOwnership(address)` and selector `0xf2fde38b`.
4308```solidity
4309function transferOwnership(address newOwner) external;
4310```*/
4311    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4312    #[derive(Clone)]
4313    pub struct transferOwnershipCall {
4314        #[allow(missing_docs)]
4315        pub newOwner: alloy::sol_types::private::Address,
4316    }
4317    ///Container type for the return parameters of the [`transferOwnership(address)`](transferOwnershipCall) function.
4318    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4319    #[derive(Clone)]
4320    pub struct transferOwnershipReturn {}
4321    #[allow(
4322        non_camel_case_types,
4323        non_snake_case,
4324        clippy::pub_underscore_fields,
4325        clippy::style
4326    )]
4327    const _: () = {
4328        use alloy::sol_types as alloy_sol_types;
4329        {
4330            #[doc(hidden)]
4331            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
4332            #[doc(hidden)]
4333            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
4334            #[cfg(test)]
4335            #[allow(dead_code, unreachable_patterns)]
4336            fn _type_assertion(
4337                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4338            ) {
4339                match _t {
4340                    alloy_sol_types::private::AssertTypeEq::<
4341                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4342                    >(_) => {}
4343                }
4344            }
4345            #[automatically_derived]
4346            #[doc(hidden)]
4347            impl ::core::convert::From<transferOwnershipCall>
4348            for UnderlyingRustTuple<'_> {
4349                fn from(value: transferOwnershipCall) -> Self {
4350                    (value.newOwner,)
4351                }
4352            }
4353            #[automatically_derived]
4354            #[doc(hidden)]
4355            impl ::core::convert::From<UnderlyingRustTuple<'_>>
4356            for transferOwnershipCall {
4357                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4358                    Self { newOwner: tuple.0 }
4359                }
4360            }
4361        }
4362        {
4363            #[doc(hidden)]
4364            type UnderlyingSolTuple<'a> = ();
4365            #[doc(hidden)]
4366            type UnderlyingRustTuple<'a> = ();
4367            #[cfg(test)]
4368            #[allow(dead_code, unreachable_patterns)]
4369            fn _type_assertion(
4370                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4371            ) {
4372                match _t {
4373                    alloy_sol_types::private::AssertTypeEq::<
4374                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4375                    >(_) => {}
4376                }
4377            }
4378            #[automatically_derived]
4379            #[doc(hidden)]
4380            impl ::core::convert::From<transferOwnershipReturn>
4381            for UnderlyingRustTuple<'_> {
4382                fn from(value: transferOwnershipReturn) -> Self {
4383                    ()
4384                }
4385            }
4386            #[automatically_derived]
4387            #[doc(hidden)]
4388            impl ::core::convert::From<UnderlyingRustTuple<'_>>
4389            for transferOwnershipReturn {
4390                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4391                    Self {}
4392                }
4393            }
4394        }
4395        #[automatically_derived]
4396        impl alloy_sol_types::SolCall for transferOwnershipCall {
4397            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
4398            type Token<'a> = <Self::Parameters<
4399                'a,
4400            > as alloy_sol_types::SolType>::Token<'a>;
4401            type Return = transferOwnershipReturn;
4402            type ReturnTuple<'a> = ();
4403            type ReturnToken<'a> = <Self::ReturnTuple<
4404                'a,
4405            > as alloy_sol_types::SolType>::Token<'a>;
4406            const SIGNATURE: &'static str = "transferOwnership(address)";
4407            const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
4408            #[inline]
4409            fn new<'a>(
4410                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4411            ) -> Self {
4412                tuple.into()
4413            }
4414            #[inline]
4415            fn tokenize(&self) -> Self::Token<'_> {
4416                (
4417                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4418                        &self.newOwner,
4419                    ),
4420                )
4421            }
4422            #[inline]
4423            fn abi_decode_returns(
4424                data: &[u8],
4425                validate: bool,
4426            ) -> alloy_sol_types::Result<Self::Return> {
4427                <Self::ReturnTuple<
4428                    '_,
4429                > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
4430                    .map(Into::into)
4431            }
4432        }
4433    };
4434    ///Container for all the [`Config`](self) function calls.
4435    pub enum ConfigCalls {
4436        #[allow(missing_docs)]
4437        addProviderToAccessList(addProviderToAccessListCall),
4438        #[allow(missing_docs)]
4439        appCID(appCIDCall),
4440        #[allow(missing_docs)]
4441        changeProvidersAccessType(changeProvidersAccessTypeCall),
4442        #[allow(missing_docs)]
4443        creationBlock(creationBlockCall),
4444        #[allow(missing_docs)]
4445        cuCountPerWorker(cuCountPerWorkerCall),
4446        #[allow(missing_docs)]
4447        effectors(effectorsCall),
4448        #[allow(missing_docs)]
4449        isProviderAllowed(isProviderAllowedCall),
4450        #[allow(missing_docs)]
4451        maxWorkersPerProvider(maxWorkersPerProviderCall),
4452        #[allow(missing_docs)]
4453        minWorkers(minWorkersCall),
4454        #[allow(missing_docs)]
4455        owner(ownerCall),
4456        #[allow(missing_docs)]
4457        paymentToken(paymentTokenCall),
4458        #[allow(missing_docs)]
4459        pricePerCuPerEpoch(pricePerCuPerEpochCall),
4460        #[allow(missing_docs)]
4461        providersAccessType(providersAccessTypeCall),
4462        #[allow(missing_docs)]
4463        removeProviderFromAccessList(removeProviderFromAccessListCall),
4464        #[allow(missing_docs)]
4465        renounceOwnership(renounceOwnershipCall),
4466        #[allow(missing_docs)]
4467        setAppCID(setAppCIDCall),
4468        #[allow(missing_docs)]
4469        targetWorkers(targetWorkersCall),
4470        #[allow(missing_docs)]
4471        transferOwnership(transferOwnershipCall),
4472    }
4473    #[automatically_derived]
4474    impl ConfigCalls {
4475        /// All the selectors of this enum.
4476        ///
4477        /// Note that the selectors might not be in the same order as the variants.
4478        /// No guarantees are made about the order of the selectors.
4479        ///
4480        /// Prefer using `SolInterface` methods instead.
4481        pub const SELECTORS: &'static [[u8; 4usize]] = &[
4482            [21u8, 160u8, 243u8, 26u8],
4483            [23u8, 99u8, 69u8, 20u8],
4484            [23u8, 100u8, 116u8, 207u8],
4485            [41u8, 67u8, 220u8, 171u8],
4486            [45u8, 179u8, 17u8, 147u8],
4487            [48u8, 19u8, 206u8, 41u8],
4488            [62u8, 138u8, 225u8, 174u8],
4489            [68u8, 78u8, 106u8, 90u8],
4490            [99u8, 111u8, 206u8, 251u8],
4491            [112u8, 34u8, 10u8, 155u8],
4492            [113u8, 80u8, 24u8, 166u8],
4493            [115u8, 19u8, 76u8, 21u8],
4494            [138u8, 12u8, 114u8, 91u8],
4495            [141u8, 165u8, 203u8, 91u8],
4496            [155u8, 198u8, 104u8, 104u8],
4497            [212u8, 119u8, 63u8, 240u8],
4498            [242u8, 253u8, 227u8, 139u8],
4499            [252u8, 30u8, 94u8, 42u8],
4500        ];
4501    }
4502    #[automatically_derived]
4503    impl alloy_sol_types::SolInterface for ConfigCalls {
4504        const NAME: &'static str = "ConfigCalls";
4505        const MIN_DATA_LENGTH: usize = 0usize;
4506        const COUNT: usize = 18usize;
4507        #[inline]
4508        fn selector(&self) -> [u8; 4] {
4509            match self {
4510                Self::addProviderToAccessList(_) => {
4511                    <addProviderToAccessListCall as alloy_sol_types::SolCall>::SELECTOR
4512                }
4513                Self::appCID(_) => <appCIDCall as alloy_sol_types::SolCall>::SELECTOR,
4514                Self::changeProvidersAccessType(_) => {
4515                    <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::SELECTOR
4516                }
4517                Self::creationBlock(_) => {
4518                    <creationBlockCall as alloy_sol_types::SolCall>::SELECTOR
4519                }
4520                Self::cuCountPerWorker(_) => {
4521                    <cuCountPerWorkerCall as alloy_sol_types::SolCall>::SELECTOR
4522                }
4523                Self::effectors(_) => {
4524                    <effectorsCall as alloy_sol_types::SolCall>::SELECTOR
4525                }
4526                Self::isProviderAllowed(_) => {
4527                    <isProviderAllowedCall as alloy_sol_types::SolCall>::SELECTOR
4528                }
4529                Self::maxWorkersPerProvider(_) => {
4530                    <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::SELECTOR
4531                }
4532                Self::minWorkers(_) => {
4533                    <minWorkersCall as alloy_sol_types::SolCall>::SELECTOR
4534                }
4535                Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
4536                Self::paymentToken(_) => {
4537                    <paymentTokenCall as alloy_sol_types::SolCall>::SELECTOR
4538                }
4539                Self::pricePerCuPerEpoch(_) => {
4540                    <pricePerCuPerEpochCall as alloy_sol_types::SolCall>::SELECTOR
4541                }
4542                Self::providersAccessType(_) => {
4543                    <providersAccessTypeCall as alloy_sol_types::SolCall>::SELECTOR
4544                }
4545                Self::removeProviderFromAccessList(_) => {
4546                    <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::SELECTOR
4547                }
4548                Self::renounceOwnership(_) => {
4549                    <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4550                }
4551                Self::setAppCID(_) => {
4552                    <setAppCIDCall as alloy_sol_types::SolCall>::SELECTOR
4553                }
4554                Self::targetWorkers(_) => {
4555                    <targetWorkersCall as alloy_sol_types::SolCall>::SELECTOR
4556                }
4557                Self::transferOwnership(_) => {
4558                    <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
4559                }
4560            }
4561        }
4562        #[inline]
4563        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4564            Self::SELECTORS.get(i).copied()
4565        }
4566        #[inline]
4567        fn valid_selector(selector: [u8; 4]) -> bool {
4568            Self::SELECTORS.binary_search(&selector).is_ok()
4569        }
4570        #[inline]
4571        #[allow(non_snake_case)]
4572        fn abi_decode_raw(
4573            selector: [u8; 4],
4574            data: &[u8],
4575            validate: bool,
4576        ) -> alloy_sol_types::Result<Self> {
4577            static DECODE_SHIMS: &[fn(
4578                &[u8],
4579                bool,
4580            ) -> alloy_sol_types::Result<ConfigCalls>] = &[
4581                {
4582                    fn cuCountPerWorker(
4583                        data: &[u8],
4584                        validate: bool,
4585                    ) -> alloy_sol_types::Result<ConfigCalls> {
4586                        <cuCountPerWorkerCall as alloy_sol_types::SolCall>::abi_decode_raw(
4587                                data,
4588                                validate,
4589                            )
4590                            .map(ConfigCalls::cuCountPerWorker)
4591                    }
4592                    cuCountPerWorker
4593                },
4594                {
4595                    fn creationBlock(
4596                        data: &[u8],
4597                        validate: bool,
4598                    ) -> alloy_sol_types::Result<ConfigCalls> {
4599                        <creationBlockCall as alloy_sol_types::SolCall>::abi_decode_raw(
4600                                data,
4601                                validate,
4602                            )
4603                            .map(ConfigCalls::creationBlock)
4604                    }
4605                    creationBlock
4606                },
4607                {
4608                    fn setAppCID(
4609                        data: &[u8],
4610                        validate: bool,
4611                    ) -> alloy_sol_types::Result<ConfigCalls> {
4612                        <setAppCIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
4613                                data,
4614                                validate,
4615                            )
4616                            .map(ConfigCalls::setAppCID)
4617                    }
4618                    setAppCID
4619                },
4620                {
4621                    fn targetWorkers(
4622                        data: &[u8],
4623                        validate: bool,
4624                    ) -> alloy_sol_types::Result<ConfigCalls> {
4625                        <targetWorkersCall as alloy_sol_types::SolCall>::abi_decode_raw(
4626                                data,
4627                                validate,
4628                            )
4629                            .map(ConfigCalls::targetWorkers)
4630                    }
4631                    targetWorkers
4632                },
4633                {
4634                    fn minWorkers(
4635                        data: &[u8],
4636                        validate: bool,
4637                    ) -> alloy_sol_types::Result<ConfigCalls> {
4638                        <minWorkersCall as alloy_sol_types::SolCall>::abi_decode_raw(
4639                                data,
4640                                validate,
4641                            )
4642                            .map(ConfigCalls::minWorkers)
4643                    }
4644                    minWorkers
4645                },
4646                {
4647                    fn paymentToken(
4648                        data: &[u8],
4649                        validate: bool,
4650                    ) -> alloy_sol_types::Result<ConfigCalls> {
4651                        <paymentTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
4652                                data,
4653                                validate,
4654                            )
4655                            .map(ConfigCalls::paymentToken)
4656                    }
4657                    paymentToken
4658                },
4659                {
4660                    fn isProviderAllowed(
4661                        data: &[u8],
4662                        validate: bool,
4663                    ) -> alloy_sol_types::Result<ConfigCalls> {
4664                        <isProviderAllowedCall as alloy_sol_types::SolCall>::abi_decode_raw(
4665                                data,
4666                                validate,
4667                            )
4668                            .map(ConfigCalls::isProviderAllowed)
4669                    }
4670                    isProviderAllowed
4671                },
4672                {
4673                    fn removeProviderFromAccessList(
4674                        data: &[u8],
4675                        validate: bool,
4676                    ) -> alloy_sol_types::Result<ConfigCalls> {
4677                        <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::abi_decode_raw(
4678                                data,
4679                                validate,
4680                            )
4681                            .map(ConfigCalls::removeProviderFromAccessList)
4682                    }
4683                    removeProviderFromAccessList
4684                },
4685                {
4686                    fn changeProvidersAccessType(
4687                        data: &[u8],
4688                        validate: bool,
4689                    ) -> alloy_sol_types::Result<ConfigCalls> {
4690                        <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4691                                data,
4692                                validate,
4693                            )
4694                            .map(ConfigCalls::changeProvidersAccessType)
4695                    }
4696                    changeProvidersAccessType
4697                },
4698                {
4699                    fn pricePerCuPerEpoch(
4700                        data: &[u8],
4701                        validate: bool,
4702                    ) -> alloy_sol_types::Result<ConfigCalls> {
4703                        <pricePerCuPerEpochCall as alloy_sol_types::SolCall>::abi_decode_raw(
4704                                data,
4705                                validate,
4706                            )
4707                            .map(ConfigCalls::pricePerCuPerEpoch)
4708                    }
4709                    pricePerCuPerEpoch
4710                },
4711                {
4712                    fn renounceOwnership(
4713                        data: &[u8],
4714                        validate: bool,
4715                    ) -> alloy_sol_types::Result<ConfigCalls> {
4716                        <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
4717                                data,
4718                                validate,
4719                            )
4720                            .map(ConfigCalls::renounceOwnership)
4721                    }
4722                    renounceOwnership
4723                },
4724                {
4725                    fn addProviderToAccessList(
4726                        data: &[u8],
4727                        validate: bool,
4728                    ) -> alloy_sol_types::Result<ConfigCalls> {
4729                        <addProviderToAccessListCall as alloy_sol_types::SolCall>::abi_decode_raw(
4730                                data,
4731                                validate,
4732                            )
4733                            .map(ConfigCalls::addProviderToAccessList)
4734                    }
4735                    addProviderToAccessList
4736                },
4737                {
4738                    fn maxWorkersPerProvider(
4739                        data: &[u8],
4740                        validate: bool,
4741                    ) -> alloy_sol_types::Result<ConfigCalls> {
4742                        <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::abi_decode_raw(
4743                                data,
4744                                validate,
4745                            )
4746                            .map(ConfigCalls::maxWorkersPerProvider)
4747                    }
4748                    maxWorkersPerProvider
4749                },
4750                {
4751                    fn owner(
4752                        data: &[u8],
4753                        validate: bool,
4754                    ) -> alloy_sol_types::Result<ConfigCalls> {
4755                        <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(
4756                                data,
4757                                validate,
4758                            )
4759                            .map(ConfigCalls::owner)
4760                    }
4761                    owner
4762                },
4763                {
4764                    fn appCID(
4765                        data: &[u8],
4766                        validate: bool,
4767                    ) -> alloy_sol_types::Result<ConfigCalls> {
4768                        <appCIDCall as alloy_sol_types::SolCall>::abi_decode_raw(
4769                                data,
4770                                validate,
4771                            )
4772                            .map(ConfigCalls::appCID)
4773                    }
4774                    appCID
4775                },
4776                {
4777                    fn providersAccessType(
4778                        data: &[u8],
4779                        validate: bool,
4780                    ) -> alloy_sol_types::Result<ConfigCalls> {
4781                        <providersAccessTypeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4782                                data,
4783                                validate,
4784                            )
4785                            .map(ConfigCalls::providersAccessType)
4786                    }
4787                    providersAccessType
4788                },
4789                {
4790                    fn transferOwnership(
4791                        data: &[u8],
4792                        validate: bool,
4793                    ) -> alloy_sol_types::Result<ConfigCalls> {
4794                        <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
4795                                data,
4796                                validate,
4797                            )
4798                            .map(ConfigCalls::transferOwnership)
4799                    }
4800                    transferOwnership
4801                },
4802                {
4803                    fn effectors(
4804                        data: &[u8],
4805                        validate: bool,
4806                    ) -> alloy_sol_types::Result<ConfigCalls> {
4807                        <effectorsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4808                                data,
4809                                validate,
4810                            )
4811                            .map(ConfigCalls::effectors)
4812                    }
4813                    effectors
4814                },
4815            ];
4816            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4817                return Err(
4818                    alloy_sol_types::Error::unknown_selector(
4819                        <Self as alloy_sol_types::SolInterface>::NAME,
4820                        selector,
4821                    ),
4822                );
4823            };
4824            DECODE_SHIMS[idx](data, validate)
4825        }
4826        #[inline]
4827        fn abi_encoded_size(&self) -> usize {
4828            match self {
4829                Self::addProviderToAccessList(inner) => {
4830                    <addProviderToAccessListCall as alloy_sol_types::SolCall>::abi_encoded_size(
4831                        inner,
4832                    )
4833                }
4834                Self::appCID(inner) => {
4835                    <appCIDCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4836                }
4837                Self::changeProvidersAccessType(inner) => {
4838                    <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::abi_encoded_size(
4839                        inner,
4840                    )
4841                }
4842                Self::creationBlock(inner) => {
4843                    <creationBlockCall as alloy_sol_types::SolCall>::abi_encoded_size(
4844                        inner,
4845                    )
4846                }
4847                Self::cuCountPerWorker(inner) => {
4848                    <cuCountPerWorkerCall as alloy_sol_types::SolCall>::abi_encoded_size(
4849                        inner,
4850                    )
4851                }
4852                Self::effectors(inner) => {
4853                    <effectorsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4854                }
4855                Self::isProviderAllowed(inner) => {
4856                    <isProviderAllowedCall as alloy_sol_types::SolCall>::abi_encoded_size(
4857                        inner,
4858                    )
4859                }
4860                Self::maxWorkersPerProvider(inner) => {
4861                    <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::abi_encoded_size(
4862                        inner,
4863                    )
4864                }
4865                Self::minWorkers(inner) => {
4866                    <minWorkersCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4867                }
4868                Self::owner(inner) => {
4869                    <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4870                }
4871                Self::paymentToken(inner) => {
4872                    <paymentTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
4873                        inner,
4874                    )
4875                }
4876                Self::pricePerCuPerEpoch(inner) => {
4877                    <pricePerCuPerEpochCall as alloy_sol_types::SolCall>::abi_encoded_size(
4878                        inner,
4879                    )
4880                }
4881                Self::providersAccessType(inner) => {
4882                    <providersAccessTypeCall as alloy_sol_types::SolCall>::abi_encoded_size(
4883                        inner,
4884                    )
4885                }
4886                Self::removeProviderFromAccessList(inner) => {
4887                    <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::abi_encoded_size(
4888                        inner,
4889                    )
4890                }
4891                Self::renounceOwnership(inner) => {
4892                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
4893                        inner,
4894                    )
4895                }
4896                Self::setAppCID(inner) => {
4897                    <setAppCIDCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
4898                }
4899                Self::targetWorkers(inner) => {
4900                    <targetWorkersCall as alloy_sol_types::SolCall>::abi_encoded_size(
4901                        inner,
4902                    )
4903                }
4904                Self::transferOwnership(inner) => {
4905                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
4906                        inner,
4907                    )
4908                }
4909            }
4910        }
4911        #[inline]
4912        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4913            match self {
4914                Self::addProviderToAccessList(inner) => {
4915                    <addProviderToAccessListCall as alloy_sol_types::SolCall>::abi_encode_raw(
4916                        inner,
4917                        out,
4918                    )
4919                }
4920                Self::appCID(inner) => {
4921                    <appCIDCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4922                }
4923                Self::changeProvidersAccessType(inner) => {
4924                    <changeProvidersAccessTypeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4925                        inner,
4926                        out,
4927                    )
4928                }
4929                Self::creationBlock(inner) => {
4930                    <creationBlockCall as alloy_sol_types::SolCall>::abi_encode_raw(
4931                        inner,
4932                        out,
4933                    )
4934                }
4935                Self::cuCountPerWorker(inner) => {
4936                    <cuCountPerWorkerCall as alloy_sol_types::SolCall>::abi_encode_raw(
4937                        inner,
4938                        out,
4939                    )
4940                }
4941                Self::effectors(inner) => {
4942                    <effectorsCall as alloy_sol_types::SolCall>::abi_encode_raw(
4943                        inner,
4944                        out,
4945                    )
4946                }
4947                Self::isProviderAllowed(inner) => {
4948                    <isProviderAllowedCall as alloy_sol_types::SolCall>::abi_encode_raw(
4949                        inner,
4950                        out,
4951                    )
4952                }
4953                Self::maxWorkersPerProvider(inner) => {
4954                    <maxWorkersPerProviderCall as alloy_sol_types::SolCall>::abi_encode_raw(
4955                        inner,
4956                        out,
4957                    )
4958                }
4959                Self::minWorkers(inner) => {
4960                    <minWorkersCall as alloy_sol_types::SolCall>::abi_encode_raw(
4961                        inner,
4962                        out,
4963                    )
4964                }
4965                Self::owner(inner) => {
4966                    <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
4967                }
4968                Self::paymentToken(inner) => {
4969                    <paymentTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
4970                        inner,
4971                        out,
4972                    )
4973                }
4974                Self::pricePerCuPerEpoch(inner) => {
4975                    <pricePerCuPerEpochCall as alloy_sol_types::SolCall>::abi_encode_raw(
4976                        inner,
4977                        out,
4978                    )
4979                }
4980                Self::providersAccessType(inner) => {
4981                    <providersAccessTypeCall as alloy_sol_types::SolCall>::abi_encode_raw(
4982                        inner,
4983                        out,
4984                    )
4985                }
4986                Self::removeProviderFromAccessList(inner) => {
4987                    <removeProviderFromAccessListCall as alloy_sol_types::SolCall>::abi_encode_raw(
4988                        inner,
4989                        out,
4990                    )
4991                }
4992                Self::renounceOwnership(inner) => {
4993                    <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
4994                        inner,
4995                        out,
4996                    )
4997                }
4998                Self::setAppCID(inner) => {
4999                    <setAppCIDCall as alloy_sol_types::SolCall>::abi_encode_raw(
5000                        inner,
5001                        out,
5002                    )
5003                }
5004                Self::targetWorkers(inner) => {
5005                    <targetWorkersCall as alloy_sol_types::SolCall>::abi_encode_raw(
5006                        inner,
5007                        out,
5008                    )
5009                }
5010                Self::transferOwnership(inner) => {
5011                    <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
5012                        inner,
5013                        out,
5014                    )
5015                }
5016            }
5017        }
5018    }
5019    ///Container for all the [`Config`](self) custom errors.
5020    pub enum ConfigErrors {
5021        #[allow(missing_docs)]
5022        InvalidInitialization(InvalidInitialization),
5023        #[allow(missing_docs)]
5024        NotInitializing(NotInitializing),
5025        #[allow(missing_docs)]
5026        OwnableInvalidOwner(OwnableInvalidOwner),
5027        #[allow(missing_docs)]
5028        OwnableUnauthorizedAccount(OwnableUnauthorizedAccount),
5029    }
5030    #[automatically_derived]
5031    impl ConfigErrors {
5032        /// All the selectors of this enum.
5033        ///
5034        /// Note that the selectors might not be in the same order as the variants.
5035        /// No guarantees are made about the order of the selectors.
5036        ///
5037        /// Prefer using `SolInterface` methods instead.
5038        pub const SELECTORS: &'static [[u8; 4usize]] = &[
5039            [17u8, 140u8, 218u8, 167u8],
5040            [30u8, 79u8, 189u8, 247u8],
5041            [215u8, 230u8, 188u8, 248u8],
5042            [249u8, 46u8, 232u8, 169u8],
5043        ];
5044    }
5045    #[automatically_derived]
5046    impl alloy_sol_types::SolInterface for ConfigErrors {
5047        const NAME: &'static str = "ConfigErrors";
5048        const MIN_DATA_LENGTH: usize = 0usize;
5049        const COUNT: usize = 4usize;
5050        #[inline]
5051        fn selector(&self) -> [u8; 4] {
5052            match self {
5053                Self::InvalidInitialization(_) => {
5054                    <InvalidInitialization as alloy_sol_types::SolError>::SELECTOR
5055                }
5056                Self::NotInitializing(_) => {
5057                    <NotInitializing as alloy_sol_types::SolError>::SELECTOR
5058                }
5059                Self::OwnableInvalidOwner(_) => {
5060                    <OwnableInvalidOwner as alloy_sol_types::SolError>::SELECTOR
5061                }
5062                Self::OwnableUnauthorizedAccount(_) => {
5063                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::SELECTOR
5064                }
5065            }
5066        }
5067        #[inline]
5068        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5069            Self::SELECTORS.get(i).copied()
5070        }
5071        #[inline]
5072        fn valid_selector(selector: [u8; 4]) -> bool {
5073            Self::SELECTORS.binary_search(&selector).is_ok()
5074        }
5075        #[inline]
5076        #[allow(non_snake_case)]
5077        fn abi_decode_raw(
5078            selector: [u8; 4],
5079            data: &[u8],
5080            validate: bool,
5081        ) -> alloy_sol_types::Result<Self> {
5082            static DECODE_SHIMS: &[fn(
5083                &[u8],
5084                bool,
5085            ) -> alloy_sol_types::Result<ConfigErrors>] = &[
5086                {
5087                    fn OwnableUnauthorizedAccount(
5088                        data: &[u8],
5089                        validate: bool,
5090                    ) -> alloy_sol_types::Result<ConfigErrors> {
5091                        <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_decode_raw(
5092                                data,
5093                                validate,
5094                            )
5095                            .map(ConfigErrors::OwnableUnauthorizedAccount)
5096                    }
5097                    OwnableUnauthorizedAccount
5098                },
5099                {
5100                    fn OwnableInvalidOwner(
5101                        data: &[u8],
5102                        validate: bool,
5103                    ) -> alloy_sol_types::Result<ConfigErrors> {
5104                        <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_decode_raw(
5105                                data,
5106                                validate,
5107                            )
5108                            .map(ConfigErrors::OwnableInvalidOwner)
5109                    }
5110                    OwnableInvalidOwner
5111                },
5112                {
5113                    fn NotInitializing(
5114                        data: &[u8],
5115                        validate: bool,
5116                    ) -> alloy_sol_types::Result<ConfigErrors> {
5117                        <NotInitializing as alloy_sol_types::SolError>::abi_decode_raw(
5118                                data,
5119                                validate,
5120                            )
5121                            .map(ConfigErrors::NotInitializing)
5122                    }
5123                    NotInitializing
5124                },
5125                {
5126                    fn InvalidInitialization(
5127                        data: &[u8],
5128                        validate: bool,
5129                    ) -> alloy_sol_types::Result<ConfigErrors> {
5130                        <InvalidInitialization as alloy_sol_types::SolError>::abi_decode_raw(
5131                                data,
5132                                validate,
5133                            )
5134                            .map(ConfigErrors::InvalidInitialization)
5135                    }
5136                    InvalidInitialization
5137                },
5138            ];
5139            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5140                return Err(
5141                    alloy_sol_types::Error::unknown_selector(
5142                        <Self as alloy_sol_types::SolInterface>::NAME,
5143                        selector,
5144                    ),
5145                );
5146            };
5147            DECODE_SHIMS[idx](data, validate)
5148        }
5149        #[inline]
5150        fn abi_encoded_size(&self) -> usize {
5151            match self {
5152                Self::InvalidInitialization(inner) => {
5153                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encoded_size(
5154                        inner,
5155                    )
5156                }
5157                Self::NotInitializing(inner) => {
5158                    <NotInitializing as alloy_sol_types::SolError>::abi_encoded_size(
5159                        inner,
5160                    )
5161                }
5162                Self::OwnableInvalidOwner(inner) => {
5163                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encoded_size(
5164                        inner,
5165                    )
5166                }
5167                Self::OwnableUnauthorizedAccount(inner) => {
5168                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encoded_size(
5169                        inner,
5170                    )
5171                }
5172            }
5173        }
5174        #[inline]
5175        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5176            match self {
5177                Self::InvalidInitialization(inner) => {
5178                    <InvalidInitialization as alloy_sol_types::SolError>::abi_encode_raw(
5179                        inner,
5180                        out,
5181                    )
5182                }
5183                Self::NotInitializing(inner) => {
5184                    <NotInitializing as alloy_sol_types::SolError>::abi_encode_raw(
5185                        inner,
5186                        out,
5187                    )
5188                }
5189                Self::OwnableInvalidOwner(inner) => {
5190                    <OwnableInvalidOwner as alloy_sol_types::SolError>::abi_encode_raw(
5191                        inner,
5192                        out,
5193                    )
5194                }
5195                Self::OwnableUnauthorizedAccount(inner) => {
5196                    <OwnableUnauthorizedAccount as alloy_sol_types::SolError>::abi_encode_raw(
5197                        inner,
5198                        out,
5199                    )
5200                }
5201            }
5202        }
5203    }
5204    ///Container for all the [`Config`](self) events.
5205    pub enum ConfigEvents {
5206        #[allow(missing_docs)]
5207        AppCIDChanged(AppCIDChanged),
5208        #[allow(missing_docs)]
5209        Initialized(Initialized),
5210        #[allow(missing_docs)]
5211        OwnershipTransferred(OwnershipTransferred),
5212        #[allow(missing_docs)]
5213        ProviderAddedToAccessList(ProviderAddedToAccessList),
5214        #[allow(missing_docs)]
5215        ProviderRemovedFromAccessList(ProviderRemovedFromAccessList),
5216        #[allow(missing_docs)]
5217        ProvidersAccessTypeChanged(ProvidersAccessTypeChanged),
5218    }
5219    #[automatically_derived]
5220    impl ConfigEvents {
5221        /// All the selectors of this enum.
5222        ///
5223        /// Note that the selectors might not be in the same order as the variants.
5224        /// No guarantees are made about the order of the selectors.
5225        ///
5226        /// Prefer using `SolInterface` methods instead.
5227        pub const SELECTORS: &'static [[u8; 32usize]] = &[
5228            [
5229                31u8,
5230                90u8,
5231                37u8,
5232                20u8,
5233                40u8,
5234                247u8,
5235                99u8,
5236                53u8,
5237                168u8,
5238                53u8,
5239                252u8,
5240                174u8,
5241                148u8,
5242                171u8,
5243                106u8,
5244                155u8,
5245                207u8,
5246                9u8,
5247                172u8,
5248                51u8,
5249                189u8,
5250                60u8,
5251                120u8,
5252                46u8,
5253                182u8,
5254                168u8,
5255                27u8,
5256                223u8,
5257                135u8,
5258                138u8,
5259                115u8,
5260                147u8,
5261            ],
5262            [
5263                56u8,
5264                251u8,
5265                8u8,
5266                26u8,
5267                11u8,
5268                72u8,
5269                68u8,
5270                6u8,
5271                151u8,
5272                123u8,
5273                217u8,
5274                79u8,
5275                248u8,
5276                237u8,
5277                183u8,
5278                155u8,
5279                228u8,
5280                75u8,
5281                92u8,
5282                165u8,
5283                20u8,
5284                19u8,
5285                3u8,
5286                97u8,
5287                24u8,
5288                37u8,
5289                22u8,
5290                179u8,
5291                158u8,
5292                44u8,
5293                69u8,
5294                40u8,
5295            ],
5296            [
5297                76u8,
5298                38u8,
5299                228u8,
5300                222u8,
5301                105u8,
5302                30u8,
5303                38u8,
5304                91u8,
5305                230u8,
5306                207u8,
5307                3u8,
5308                230u8,
5309                57u8,
5310                117u8,
5311                72u8,
5312                57u8,
5313                144u8,
5314                123u8,
5315                247u8,
5316                70u8,
5317                135u8,
5318                205u8,
5319                82u8,
5320                74u8,
5321                103u8,
5322                52u8,
5323                133u8,
5324                19u8,
5325                49u8,
5326                82u8,
5327                127u8,
5328                253u8,
5329            ],
5330            [
5331                139u8,
5332                224u8,
5333                7u8,
5334                156u8,
5335                83u8,
5336                22u8,
5337                89u8,
5338                20u8,
5339                19u8,
5340                68u8,
5341                205u8,
5342                31u8,
5343                208u8,
5344                164u8,
5345                242u8,
5346                132u8,
5347                25u8,
5348                73u8,
5349                127u8,
5350                151u8,
5351                34u8,
5352                163u8,
5353                218u8,
5354                175u8,
5355                227u8,
5356                180u8,
5357                24u8,
5358                111u8,
5359                107u8,
5360                100u8,
5361                87u8,
5362                224u8,
5363            ],
5364            [
5365                199u8,
5366                245u8,
5367                5u8,
5368                178u8,
5369                243u8,
5370                113u8,
5371                174u8,
5372                33u8,
5373                117u8,
5374                238u8,
5375                73u8,
5376                19u8,
5377                244u8,
5378                73u8,
5379                158u8,
5380                31u8,
5381                38u8,
5382                51u8,
5383                167u8,
5384                181u8,
5385                147u8,
5386                99u8,
5387                33u8,
5388                238u8,
5389                209u8,
5390                205u8,
5391                174u8,
5392                182u8,
5393                17u8,
5394                81u8,
5395                129u8,
5396                210u8,
5397            ],
5398            [
5399                200u8,
5400                32u8,
5401                166u8,
5402                109u8,
5403                59u8,
5404                221u8,
5405                80u8,
5406                164u8,
5407                92u8,
5408                241u8,
5409                44u8,
5410                218u8,
5411                109u8,
5412                200u8,
5413                236u8,
5414                158u8,
5415                148u8,
5416                251u8,
5417                81u8,
5418                35u8,
5419                237u8,
5420                215u8,
5421                218u8,
5422                115u8,
5423                110u8,
5424                234u8,
5425                24u8,
5426                49u8,
5427                111u8,
5428                133u8,
5429                35u8,
5430                160u8,
5431            ],
5432        ];
5433    }
5434    #[automatically_derived]
5435    impl alloy_sol_types::SolEventInterface for ConfigEvents {
5436        const NAME: &'static str = "ConfigEvents";
5437        const COUNT: usize = 6usize;
5438        fn decode_raw_log(
5439            topics: &[alloy_sol_types::Word],
5440            data: &[u8],
5441            validate: bool,
5442        ) -> alloy_sol_types::Result<Self> {
5443            match topics.first().copied() {
5444                Some(<AppCIDChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5445                    <AppCIDChanged as alloy_sol_types::SolEvent>::decode_raw_log(
5446                            topics,
5447                            data,
5448                            validate,
5449                        )
5450                        .map(Self::AppCIDChanged)
5451                }
5452                Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5453                    <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
5454                            topics,
5455                            data,
5456                            validate,
5457                        )
5458                        .map(Self::Initialized)
5459                }
5460                Some(
5461                    <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5462                ) => {
5463                    <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
5464                            topics,
5465                            data,
5466                            validate,
5467                        )
5468                        .map(Self::OwnershipTransferred)
5469                }
5470                Some(
5471                    <ProviderAddedToAccessList as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5472                ) => {
5473                    <ProviderAddedToAccessList as alloy_sol_types::SolEvent>::decode_raw_log(
5474                            topics,
5475                            data,
5476                            validate,
5477                        )
5478                        .map(Self::ProviderAddedToAccessList)
5479                }
5480                Some(
5481                    <ProviderRemovedFromAccessList as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5482                ) => {
5483                    <ProviderRemovedFromAccessList as alloy_sol_types::SolEvent>::decode_raw_log(
5484                            topics,
5485                            data,
5486                            validate,
5487                        )
5488                        .map(Self::ProviderRemovedFromAccessList)
5489                }
5490                Some(
5491                    <ProvidersAccessTypeChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5492                ) => {
5493                    <ProvidersAccessTypeChanged as alloy_sol_types::SolEvent>::decode_raw_log(
5494                            topics,
5495                            data,
5496                            validate,
5497                        )
5498                        .map(Self::ProvidersAccessTypeChanged)
5499                }
5500                _ => {
5501                    alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5502                        name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5503                        log: alloy_sol_types::private::Box::new(
5504                            alloy_sol_types::private::LogData::new_unchecked(
5505                                topics.to_vec(),
5506                                data.to_vec().into(),
5507                            ),
5508                        ),
5509                    })
5510                }
5511            }
5512        }
5513    }
5514    #[automatically_derived]
5515    impl alloy_sol_types::private::IntoLogData for ConfigEvents {
5516        fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5517            match self {
5518                Self::AppCIDChanged(inner) => {
5519                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
5520                }
5521                Self::Initialized(inner) => {
5522                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
5523                }
5524                Self::OwnershipTransferred(inner) => {
5525                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
5526                }
5527                Self::ProviderAddedToAccessList(inner) => {
5528                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
5529                }
5530                Self::ProviderRemovedFromAccessList(inner) => {
5531                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
5532                }
5533                Self::ProvidersAccessTypeChanged(inner) => {
5534                    alloy_sol_types::private::IntoLogData::to_log_data(inner)
5535                }
5536            }
5537        }
5538        fn into_log_data(self) -> alloy_sol_types::private::LogData {
5539            match self {
5540                Self::AppCIDChanged(inner) => {
5541                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
5542                }
5543                Self::Initialized(inner) => {
5544                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
5545                }
5546                Self::OwnershipTransferred(inner) => {
5547                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
5548                }
5549                Self::ProviderAddedToAccessList(inner) => {
5550                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
5551                }
5552                Self::ProviderRemovedFromAccessList(inner) => {
5553                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
5554                }
5555                Self::ProvidersAccessTypeChanged(inner) => {
5556                    alloy_sol_types::private::IntoLogData::into_log_data(inner)
5557                }
5558            }
5559        }
5560    }
5561    use alloy::contract as alloy_contract;
5562    /**Creates a new wrapper around an on-chain [`Config`](self) contract instance.
5563
5564See the [wrapper's documentation](`ConfigInstance`) for more details.*/
5565    #[inline]
5566    pub const fn new<
5567        T: alloy_contract::private::Transport + ::core::clone::Clone,
5568        P: alloy_contract::private::Provider<T, N>,
5569        N: alloy_contract::private::Network,
5570    >(
5571        address: alloy_sol_types::private::Address,
5572        provider: P,
5573    ) -> ConfigInstance<T, P, N> {
5574        ConfigInstance::<T, P, N>::new(address, provider)
5575    }
5576    /**Deploys this contract using the given `provider` and constructor arguments, if any.
5577
5578Returns a new instance of the contract, if the deployment was successful.
5579
5580For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
5581    #[inline]
5582    pub fn deploy<
5583        T: alloy_contract::private::Transport + ::core::clone::Clone,
5584        P: alloy_contract::private::Provider<T, N>,
5585        N: alloy_contract::private::Network,
5586    >(
5587        provider: P,
5588    ) -> impl ::core::future::Future<
5589        Output = alloy_contract::Result<ConfigInstance<T, P, N>>,
5590    > {
5591        ConfigInstance::<T, P, N>::deploy(provider)
5592    }
5593    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
5594and constructor arguments, if any.
5595
5596This is a simple wrapper around creating a `RawCallBuilder` with the data set to
5597the bytecode concatenated with the constructor's ABI-encoded arguments.*/
5598    #[inline]
5599    pub fn deploy_builder<
5600        T: alloy_contract::private::Transport + ::core::clone::Clone,
5601        P: alloy_contract::private::Provider<T, N>,
5602        N: alloy_contract::private::Network,
5603    >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
5604        ConfigInstance::<T, P, N>::deploy_builder(provider)
5605    }
5606    /**A [`Config`](self) instance.
5607
5608Contains type-safe methods for interacting with an on-chain instance of the
5609[`Config`](self) contract located at a given `address`, using a given
5610provider `P`.
5611
5612If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
5613documentation on how to provide it), the `deploy` and `deploy_builder` methods can
5614be used to deploy a new instance of the contract.
5615
5616See the [module-level documentation](self) for all the available methods.*/
5617    #[derive(Clone)]
5618    pub struct ConfigInstance<T, P, N = alloy_contract::private::Ethereum> {
5619        address: alloy_sol_types::private::Address,
5620        provider: P,
5621        _network_transport: ::core::marker::PhantomData<(N, T)>,
5622    }
5623    #[automatically_derived]
5624    impl<T, P, N> ::core::fmt::Debug for ConfigInstance<T, P, N> {
5625        #[inline]
5626        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5627            f.debug_tuple("ConfigInstance").field(&self.address).finish()
5628        }
5629    }
5630    /// Instantiation and getters/setters.
5631    #[automatically_derived]
5632    impl<
5633        T: alloy_contract::private::Transport + ::core::clone::Clone,
5634        P: alloy_contract::private::Provider<T, N>,
5635        N: alloy_contract::private::Network,
5636    > ConfigInstance<T, P, N> {
5637        /**Creates a new wrapper around an on-chain [`Config`](self) contract instance.
5638
5639See the [wrapper's documentation](`ConfigInstance`) for more details.*/
5640        #[inline]
5641        pub const fn new(
5642            address: alloy_sol_types::private::Address,
5643            provider: P,
5644        ) -> Self {
5645            Self {
5646                address,
5647                provider,
5648                _network_transport: ::core::marker::PhantomData,
5649            }
5650        }
5651        /**Deploys this contract using the given `provider` and constructor arguments, if any.
5652
5653Returns a new instance of the contract, if the deployment was successful.
5654
5655For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
5656        #[inline]
5657        pub async fn deploy(
5658            provider: P,
5659        ) -> alloy_contract::Result<ConfigInstance<T, P, N>> {
5660            let call_builder = Self::deploy_builder(provider);
5661            let contract_address = call_builder.deploy().await?;
5662            Ok(Self::new(contract_address, call_builder.provider))
5663        }
5664        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
5665and constructor arguments, if any.
5666
5667This is a simple wrapper around creating a `RawCallBuilder` with the data set to
5668the bytecode concatenated with the constructor's ABI-encoded arguments.*/
5669        #[inline]
5670        pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
5671            alloy_contract::RawCallBuilder::new_raw_deploy(
5672                provider,
5673                ::core::clone::Clone::clone(&BYTECODE),
5674            )
5675        }
5676        /// Returns a reference to the address.
5677        #[inline]
5678        pub const fn address(&self) -> &alloy_sol_types::private::Address {
5679            &self.address
5680        }
5681        /// Sets the address.
5682        #[inline]
5683        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5684            self.address = address;
5685        }
5686        /// Sets the address and returns `self`.
5687        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5688            self.set_address(address);
5689            self
5690        }
5691        /// Returns a reference to the provider.
5692        #[inline]
5693        pub const fn provider(&self) -> &P {
5694            &self.provider
5695        }
5696    }
5697    impl<T, P: ::core::clone::Clone, N> ConfigInstance<T, &P, N> {
5698        /// Clones the provider and returns a new instance with the cloned provider.
5699        #[inline]
5700        pub fn with_cloned_provider(self) -> ConfigInstance<T, P, N> {
5701            ConfigInstance {
5702                address: self.address,
5703                provider: ::core::clone::Clone::clone(&self.provider),
5704                _network_transport: ::core::marker::PhantomData,
5705            }
5706        }
5707    }
5708    /// Function calls.
5709    #[automatically_derived]
5710    impl<
5711        T: alloy_contract::private::Transport + ::core::clone::Clone,
5712        P: alloy_contract::private::Provider<T, N>,
5713        N: alloy_contract::private::Network,
5714    > ConfigInstance<T, P, N> {
5715        /// Creates a new call builder using this contract instance's provider and address.
5716        ///
5717        /// Note that the call can be any function call, not just those defined in this
5718        /// contract. Prefer using the other methods for building type-safe contract calls.
5719        pub fn call_builder<C: alloy_sol_types::SolCall>(
5720            &self,
5721            call: &C,
5722        ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
5723            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
5724        }
5725        ///Creates a new call builder for the [`addProviderToAccessList`] function.
5726        pub fn addProviderToAccessList(
5727            &self,
5728            provider: alloy::sol_types::private::Address,
5729        ) -> alloy_contract::SolCallBuilder<T, &P, addProviderToAccessListCall, N> {
5730            self.call_builder(
5731                &addProviderToAccessListCall {
5732                    provider,
5733                },
5734            )
5735        }
5736        ///Creates a new call builder for the [`appCID`] function.
5737        pub fn appCID(&self) -> alloy_contract::SolCallBuilder<T, &P, appCIDCall, N> {
5738            self.call_builder(&appCIDCall {})
5739        }
5740        ///Creates a new call builder for the [`changeProvidersAccessType`] function.
5741        pub fn changeProvidersAccessType(
5742            &self,
5743            accessType: <IConfig::AccessType as alloy::sol_types::SolType>::RustType,
5744        ) -> alloy_contract::SolCallBuilder<T, &P, changeProvidersAccessTypeCall, N> {
5745            self.call_builder(
5746                &changeProvidersAccessTypeCall {
5747                    accessType,
5748                },
5749            )
5750        }
5751        ///Creates a new call builder for the [`creationBlock`] function.
5752        pub fn creationBlock(
5753            &self,
5754        ) -> alloy_contract::SolCallBuilder<T, &P, creationBlockCall, N> {
5755            self.call_builder(&creationBlockCall {})
5756        }
5757        ///Creates a new call builder for the [`cuCountPerWorker`] function.
5758        pub fn cuCountPerWorker(
5759            &self,
5760        ) -> alloy_contract::SolCallBuilder<T, &P, cuCountPerWorkerCall, N> {
5761            self.call_builder(&cuCountPerWorkerCall {})
5762        }
5763        ///Creates a new call builder for the [`effectors`] function.
5764        pub fn effectors(
5765            &self,
5766        ) -> alloy_contract::SolCallBuilder<T, &P, effectorsCall, N> {
5767            self.call_builder(&effectorsCall {})
5768        }
5769        ///Creates a new call builder for the [`isProviderAllowed`] function.
5770        pub fn isProviderAllowed(
5771            &self,
5772            account: alloy::sol_types::private::Address,
5773        ) -> alloy_contract::SolCallBuilder<T, &P, isProviderAllowedCall, N> {
5774            self.call_builder(&isProviderAllowedCall { account })
5775        }
5776        ///Creates a new call builder for the [`maxWorkersPerProvider`] function.
5777        pub fn maxWorkersPerProvider(
5778            &self,
5779        ) -> alloy_contract::SolCallBuilder<T, &P, maxWorkersPerProviderCall, N> {
5780            self.call_builder(&maxWorkersPerProviderCall {})
5781        }
5782        ///Creates a new call builder for the [`minWorkers`] function.
5783        pub fn minWorkers(
5784            &self,
5785        ) -> alloy_contract::SolCallBuilder<T, &P, minWorkersCall, N> {
5786            self.call_builder(&minWorkersCall {})
5787        }
5788        ///Creates a new call builder for the [`owner`] function.
5789        pub fn owner(&self) -> alloy_contract::SolCallBuilder<T, &P, ownerCall, N> {
5790            self.call_builder(&ownerCall {})
5791        }
5792        ///Creates a new call builder for the [`paymentToken`] function.
5793        pub fn paymentToken(
5794            &self,
5795        ) -> alloy_contract::SolCallBuilder<T, &P, paymentTokenCall, N> {
5796            self.call_builder(&paymentTokenCall {})
5797        }
5798        ///Creates a new call builder for the [`pricePerCuPerEpoch`] function.
5799        pub fn pricePerCuPerEpoch(
5800            &self,
5801        ) -> alloy_contract::SolCallBuilder<T, &P, pricePerCuPerEpochCall, N> {
5802            self.call_builder(&pricePerCuPerEpochCall {})
5803        }
5804        ///Creates a new call builder for the [`providersAccessType`] function.
5805        pub fn providersAccessType(
5806            &self,
5807        ) -> alloy_contract::SolCallBuilder<T, &P, providersAccessTypeCall, N> {
5808            self.call_builder(&providersAccessTypeCall {})
5809        }
5810        ///Creates a new call builder for the [`removeProviderFromAccessList`] function.
5811        pub fn removeProviderFromAccessList(
5812            &self,
5813            provider: alloy::sol_types::private::Address,
5814        ) -> alloy_contract::SolCallBuilder<T, &P, removeProviderFromAccessListCall, N> {
5815            self.call_builder(
5816                &removeProviderFromAccessListCall {
5817                    provider,
5818                },
5819            )
5820        }
5821        ///Creates a new call builder for the [`renounceOwnership`] function.
5822        pub fn renounceOwnership(
5823            &self,
5824        ) -> alloy_contract::SolCallBuilder<T, &P, renounceOwnershipCall, N> {
5825            self.call_builder(&renounceOwnershipCall {})
5826        }
5827        ///Creates a new call builder for the [`setAppCID`] function.
5828        pub fn setAppCID(
5829            &self,
5830            appCID_: <Common::CIDV1 as alloy::sol_types::SolType>::RustType,
5831        ) -> alloy_contract::SolCallBuilder<T, &P, setAppCIDCall, N> {
5832            self.call_builder(&setAppCIDCall { appCID_ })
5833        }
5834        ///Creates a new call builder for the [`targetWorkers`] function.
5835        pub fn targetWorkers(
5836            &self,
5837        ) -> alloy_contract::SolCallBuilder<T, &P, targetWorkersCall, N> {
5838            self.call_builder(&targetWorkersCall {})
5839        }
5840        ///Creates a new call builder for the [`transferOwnership`] function.
5841        pub fn transferOwnership(
5842            &self,
5843            newOwner: alloy::sol_types::private::Address,
5844        ) -> alloy_contract::SolCallBuilder<T, &P, transferOwnershipCall, N> {
5845            self.call_builder(&transferOwnershipCall { newOwner })
5846        }
5847    }
5848    /// Event filters.
5849    #[automatically_derived]
5850    impl<
5851        T: alloy_contract::private::Transport + ::core::clone::Clone,
5852        P: alloy_contract::private::Provider<T, N>,
5853        N: alloy_contract::private::Network,
5854    > ConfigInstance<T, P, N> {
5855        /// Creates a new event filter using this contract instance's provider and address.
5856        ///
5857        /// Note that the type can be any event, not just those defined in this contract.
5858        /// Prefer using the other methods for building type-safe event filters.
5859        pub fn event_filter<E: alloy_sol_types::SolEvent>(
5860            &self,
5861        ) -> alloy_contract::Event<T, &P, E, N> {
5862            alloy_contract::Event::new_sol(&self.provider, &self.address)
5863        }
5864        ///Creates a new event filter for the [`AppCIDChanged`] event.
5865        pub fn AppCIDChanged_filter(
5866            &self,
5867        ) -> alloy_contract::Event<T, &P, AppCIDChanged, N> {
5868            self.event_filter::<AppCIDChanged>()
5869        }
5870        ///Creates a new event filter for the [`Initialized`] event.
5871        pub fn Initialized_filter(
5872            &self,
5873        ) -> alloy_contract::Event<T, &P, Initialized, N> {
5874            self.event_filter::<Initialized>()
5875        }
5876        ///Creates a new event filter for the [`OwnershipTransferred`] event.
5877        pub fn OwnershipTransferred_filter(
5878            &self,
5879        ) -> alloy_contract::Event<T, &P, OwnershipTransferred, N> {
5880            self.event_filter::<OwnershipTransferred>()
5881        }
5882        ///Creates a new event filter for the [`ProviderAddedToAccessList`] event.
5883        pub fn ProviderAddedToAccessList_filter(
5884            &self,
5885        ) -> alloy_contract::Event<T, &P, ProviderAddedToAccessList, N> {
5886            self.event_filter::<ProviderAddedToAccessList>()
5887        }
5888        ///Creates a new event filter for the [`ProviderRemovedFromAccessList`] event.
5889        pub fn ProviderRemovedFromAccessList_filter(
5890            &self,
5891        ) -> alloy_contract::Event<T, &P, ProviderRemovedFromAccessList, N> {
5892            self.event_filter::<ProviderRemovedFromAccessList>()
5893        }
5894        ///Creates a new event filter for the [`ProvidersAccessTypeChanged`] event.
5895        pub fn ProvidersAccessTypeChanged_filter(
5896            &self,
5897        ) -> alloy_contract::Event<T, &P, ProvidersAccessTypeChanged, N> {
5898            self.event_filter::<ProvidersAccessTypeChanged>()
5899        }
5900    }
5901}
fluence_marketplace_api_draft/config.rs

fluence_marketplace_api_draft/
config.rs
