1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use PermissionController::*;
3
4#[allow(
585 non_camel_case_types,
586 non_snake_case,
587 clippy::pub_underscore_fields,
588 clippy::style,
589 clippy::empty_structs_with_brackets
590)]
591pub mod PermissionController {
592 use super::*;
593 use alloy::sol_types as alloy_sol_types;
594 #[rustfmt::skip]
600 #[allow(clippy::all)]
601 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
602 b"`\xA0`@R4\x80\x15a\0\x0FW__\xFD[P`@Qa\x12\xE98\x03\x80a\x12\xE9\x839\x81\x01`@\x81\x90Ra\0.\x91a\x01~V[\x80a\08\x81a\0JV[`\x80RPa\0Da\0\x90V[Pa\x02\x83V[__\x82\x90P`\x1F\x81Q\x11\x15a\0}W\x82`@Qc0Z'\xA9`\xE0\x1B\x81R`\x04\x01a\0t\x91\x90a\x02+V[`@Q\x80\x91\x03\x90\xFD[\x80Qa\0\x88\x82a\x02]V[\x17\x93\x92PPPV[_Ta\x01\0\x90\x04`\xFF\x16\x15a\0\xF7W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`'`$\x82\x01R\x7FInitializable: contract is initi`D\x82\x01Rfalizing`\xC8\x1B`d\x82\x01R`\x84\x01a\0tV[_T`\xFF\x90\x81\x16\x14a\x01FW_\x80T`\xFF\x19\x16`\xFF\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\x7F&\xB8?\xF9n\x1F+jh/\x138R\xF6y\x8A\t\xC4e\xDA\x95\x92\x14`\xCE\xFB8G@$\x98\x90` \x01`@Q\x80\x91\x03\x90\xA1[V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[_[\x83\x81\x10\x15a\x01vW\x81\x81\x01Q\x83\x82\x01R` \x01a\x01^V[PP_\x91\x01RV[_` \x82\x84\x03\x12\x15a\x01\x8EW__\xFD[\x81Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xA3W__\xFD[\x82\x01`\x1F\x81\x01\x84\x13a\x01\xB3W__\xFD[\x80Q`\x01`\x01`@\x1B\x03\x81\x11\x15a\x01\xCCWa\x01\xCCa\x01HV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01`\x01`\x01`@\x1B\x03\x81\x11\x82\x82\x10\x17\x15a\x01\xFAWa\x01\xFAa\x01HV[`@R\x81\x81R\x82\x82\x01` \x01\x86\x10\x15a\x02\x11W__\xFD[a\x02\"\x82` \x83\x01` \x86\x01a\x01\\V[\x95\x94PPPPPV[` \x81R_\x82Q\x80` \x84\x01Ra\x02I\x81`@\x85\x01` \x87\x01a\x01\\V[`\x1F\x01`\x1F\x19\x16\x91\x90\x91\x01`@\x01\x92\x91PPV[\x80Q` \x80\x83\x01Q\x91\x90\x81\x10\x15a\x02}W_\x19\x81` \x03`\x03\x1B\x1B\x82\x16\x91P[P\x91\x90PV[`\x80Qa\x10Na\x02\x9B_9_a\x04\xD1\x01Ra\x10N_\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xE5W_5`\xE0\x1C\x80c\x91\0gE\x11a\0\x88W\x80c\xAD\x8A\xCAw\x11a\0cW\x80c\xAD\x8A\xCAw\x14a\x01\xDFW\x80c\xDFY\\\xB8\x14a\x01\xF2W\x80c\xEBZN\x87\x14a\x02\x05W\x80c\xFD\xDB\xDE\xFD\x14a\x02\x18W__\xFD[\x80c\x91\0gE\x14a\x01\x96W\x80c\x95\r\x80n\x14a\x01\xB9W\x80c\xAD_\"\x10\x14a\x01\xCCW__\xFD[\x80cT\xFDMP\x11a\0\xC3W\x80cT\xFDMP\x14a\x01$W\x80cb\x88\x06\xEF\x14a\x01BW\x80ck\xDD\xFA\x1F\x14a\x01UW\x80c\x88*;8\x14a\x01uW__\xFD[\x80c\x06d\x12\x01\x14a\0\xE9W\x80c&\x89Y\xE5\x14a\0\xFEW\x80cO\x90l\xF9\x14a\x01\x11W[__\xFD[a\0\xFCa\0\xF76`\x04a\r\xBDV[a\x02+V[\0[a\0\xFCa\x01\x0C6`\x04a\x0E\x0EV[a\x03LV[a\0\xFCa\x01\x1F6`\x04a\x0E\x0EV[a\x04'V[a\x01,a\x04\xCAV[`@Qa\x019\x91\x90a\x0E?V[`@Q\x80\x91\x03\x90\xF3[a\0\xFCa\x01P6`\x04a\x0E\x8AV[a\x04\xFAV[a\x01ha\x01c6`\x04a\x0E\x8AV[a\x05\x88V[`@Qa\x019\x91\x90a\x0E\xE6V[a\x01\x88a\x01\x836`\x04a\x0E\x0EV[a\x05\xB1V[`@Qa\x019\x92\x91\x90a\x0E\xF8V[a\x01\xA9a\x01\xA46`\x04a\x0E\x0EV[a\x07\x12V[`@Q\x90\x15\x15\x81R` \x01a\x019V[a\0\xFCa\x01\xC76`\x04a\r\xBDV[a\x07\x82V[a\x01ha\x01\xDA6`\x04a\x0E\x8AV[a\x08\x93V[a\x01\xA9a\x01\xED6`\x04a\x0E\x0EV[a\t9V[a\x01\xA9a\x02\x006`\x04a\r\xBDV[a\tZV[a\0\xFCa\x02\x136`\x04a\x0E\x0EV[a\t\xAFV[a\x01ha\x02&6`\x04a\x0FZV[a\n}V[\x83a\x026\x813a\x07\x12V[a\x02SW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x02u\x85\x85a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x02\x9B\x90\x82a\n\xE8V[a\x02\xB8W`@Qc&!\x18\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x02\xDB\x90\x82a\n\xFFV[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x02\xF5\x90\x87a\x0B\nV[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x18$#&\xB6\xB8b\x12ipg\x97Y\x16\x9F\x01\xF6F\xBDU\xEC[\xFC\xAB\x85\xBA\x9F3zt\xE0\xC6\x87\x87`@Qa\x03;\x92\x91\x90a\x0F\x9AV[`@Q\x80\x91\x03\x90\xA3PPPPPPPV[\x81a\x03W\x813a\x07\x12V[a\x03tW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` \x81\x90R`@\x90\x91 `\x02\x01\x90a\x03\x9B\x82a\x0B\x1EV[\x11a\x03\xB9W`@Qc\x10\xCE\x89+`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xC3\x81\x84a\x0B\nV[a\x03\xE0W`@Qc\x07\x16\xD8\x1B`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R\x85\x16\x90\x7F\xDB\x9D]12\r\xAF[\xC7\x18\x1DV[m\xA4\xD1.0\xF0\xF4\xD5\xAA2J\x99$&\xC1J\x1D\x19\xCE\x90` \x01[`@Q\x80\x91\x03\x90\xA2PPPPV[\x81a\x042\x813a\x07\x12V[a\x04OW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x04p\x81\x84a\x0B\nV[a\x04\x8DW`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R\x85\x16\x90\x7F\xD7\x06\xEDz\xE0D\xD7\x95\xB4\x9ET\xC9\xF5\x19\xF6c\x059Q\x01\x19\x85\xF6c\xA8b\xCD\x9E\xE7*\x9A\xC7\x90` \x01a\x04\x19V[``a\x04\xF5\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x0B'V[\x90P\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 a\x05\x1B\x813a\x0B\nV[a\x058W`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05E`\x02\x82\x013a\x0BdV[P`@Q3\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBF&^\x83&(Z'G\xE3>T\xD5\x94_q\x11\xF2\xB5\xED\xB8&\xEB\x8C\x08\xD4gwy\xB3\xFF\x97\x90` \x01`@Q\x80\x91\x03\x90\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x05\xAB\x90a\x0BxV[\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R`\x04\x90\x93\x01\x90R\x90\x81 ``\x91\x82\x91\x90a\x05\xEA\x82a\x0B\x1EV[\x90P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x06Wa\x06\x06a\x0F\xBDV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06/W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06LWa\x06La\x0F\xBDV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06uW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x07\x04Wa\x06\xA8a\x06\x8F\x86\x83a\x0B\x84V[``\x81\x90\x1C\x91`\xA0\x91\x90\x91\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x90V[\x84\x83\x81Q\x81\x10a\x06\xBAWa\x06\xBAa\x0F\xD1V[` \x02` \x01\x01\x84\x84\x81Q\x81\x10a\x06\xD3Wa\x06\xD3a\x0F\xD1V[`\x01`\x01`\xE0\x1B\x03\x19\x90\x93\x16` \x93\x84\x02\x91\x90\x91\x01\x90\x92\x01\x91\x90\x91R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90R`\x01\x01a\x06zV[P\x90\x97\x90\x96P\x94PPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x075\x90`\x02\x01a\x0B\x1EV[_\x03a\x07WW\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa\x05\xABV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x07{\x90`\x02\x01\x83a\x0B\x8FV[\x93\x92PPPV[\x83a\x07\x8D\x813a\x07\x12V[a\x07\xAAW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x07\xCC\x85\x85a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x07\xF2\x90\x82a\n\xE8V[\x15a\x08\x10W`@Qc\xAD\x8E\xFE\xB7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x083\x90\x82a\x0B\xB0V[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x08M\x90\x87a\x0BdV[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x03\x7F\x03\xA2\xADk\x96}\xF4\xA0\x17y\xB6\xD2\xB4\xC8YP\xDF\x83\x92]\x9E16+Q\x94\"\xFC\x01i\x87\x87`@Qa\x03;\x92\x91\x90a\x0F\x9AV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x08\xB9\x90`\x02\x01a\x0B\x1EV[_\x03a\t\x11W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x82\x81_\x81Q\x81\x10a\x08\xF3Wa\x08\xF3a\x0F\xD1V[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x90 a\x05\xAB\x90`\x02\x01a\x0BxV[\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x07{\x90\x83a\x0B\x8FV[_a\te\x85\x85a\x07\x12V[\x80a\t\xA6WPa\t\xA6a\tx\x84\x84a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x80\x88\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x8A\x16\x83R`\x04\x90\x93\x01\x90R \x90a\n\xE8V[\x95\x94PPPPPV[\x81a\t\xBA\x813a\x07\x12V[a\t\xD7W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\t\xFB`\x02\x82\x01\x84a\x0B\x8FV[\x15a\n\x19W`@Qc\x13\x01`\xE5`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\n#\x81\x84a\x0BdV[a\n@W`@Qc\x19\xAB\xED\xE3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R\x85\x16\x90\x7F\xB1K\x9A=D\x8C[\x04\xF0\xE5\xB0\x87\xB6\xF5\x193\x90\xDByUH*o\xFB\x84\x1E{;\xA6\x1AF\x0C\x90` \x01a\x04\x19V[``_a\n\x8A\x84\x84a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x84\x84R`\x05\x01\x90\x91R\x90 \x90\x91Pa\t\xA6\x90a\x0BxV[``\x91\x90\x91\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\xA0\x91\x90\x91\x1Ck\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\x16\x17\x90V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07{V[_a\x07{\x83\x83a\x0B\xBBV[_a\x07{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B\xBBV[_a\x05\xAB\x82T\x90V[``_a\x0B3\x83a\x0C\x9EV[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[_a\x07{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0C\xC5V[``_a\x07{\x83a\r\x11V[_a\x07{\x83\x83a\rjV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07{V[_a\x07{\x83\x83a\x0C\xC5V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x0C\x95W_a\x0B\xDD`\x01\x83a\x0F\xE5V[\x85T\x90\x91P_\x90a\x0B\xF0\x90`\x01\x90a\x0F\xE5V[\x90P\x81\x81\x14a\x0COW_\x86_\x01\x82\x81T\x81\x10a\x0C\x0EWa\x0C\x0Ea\x0F\xD1V[\x90_R` _ \x01T\x90P\x80\x87_\x01\x84\x81T\x81\x10a\x0C.Wa\x0C.a\x0F\xD1V[_\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x0C`Wa\x0C`a\x10\x04V[`\x01\x90\x03\x81\x81\x90_R` _ \x01_\x90U\x90U\x85`\x01\x01_\x86\x81R` \x01\x90\x81R` \x01_ _\x90U`\x01\x93PPPPa\x05\xABV[_\x91PPa\x05\xABV[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05\xABW`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81\x81R`\x01\x83\x01` R`@\x81 Ta\r\nWP\x81T`\x01\x81\x81\x01\x84U_\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x05\xABV[P_a\x05\xABV[``\x81_\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r^W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11a\rJW[PPPPP\x90P\x91\x90PV[_\x82_\x01\x82\x81T\x81\x10a\r\x7FWa\r\x7Fa\x0F\xD1V[\x90_R` _ \x01T\x90P\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\t4W__\xFD[\x805`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\t4W__\xFD[____`\x80\x85\x87\x03\x12\x15a\r\xD0W__\xFD[a\r\xD9\x85a\r\x90V[\x93Pa\r\xE7` \x86\x01a\r\x90V[\x92Pa\r\xF5`@\x86\x01a\r\x90V[\x91Pa\x0E\x03``\x86\x01a\r\xA6V[\x90P\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15a\x0E\x1FW__\xFD[a\x0E(\x83a\r\x90V[\x91Pa\x0E6` \x84\x01a\r\x90V[\x90P\x92P\x92\x90PV[` \x81R_\x82Q\x80` \x84\x01R_[\x81\x81\x10\x15a\x0EkW` \x81\x86\x01\x81\x01Q`@\x86\x84\x01\x01R\x01a\x0ENV[P_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x0E\x9AW__\xFD[a\x07{\x82a\r\x90V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0E\xDCW\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0E\xB5V[P\x93\x94\x93PPPPV[` \x81R_a\x07{` \x83\x01\x84a\x0E\xA3V[`@\x81R_a\x0F\n`@\x83\x01\x85a\x0E\xA3V[\x82\x81\x03` \x84\x01R\x80\x84Q\x80\x83R` \x83\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0FNW\x83Q`\x01`\x01`\xE0\x1B\x03\x19\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0F&V[P\x90\x96\x95PPPPPPV[___``\x84\x86\x03\x12\x15a\x0FlW__\xFD[a\x0Fu\x84a\r\x90V[\x92Pa\x0F\x83` \x85\x01a\r\x90V[\x91Pa\x0F\x91`@\x85\x01a\r\xA6V[\x90P\x92P\x92P\x92V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`@\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x05\xABWcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`1`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 0\xDD\x84\x80W\xA9\x90\x8A\x14\x13\xE3T\xBB\xBB\x87x\xF7\xA9\xA4\xE1\x91\x1D~\xBC7_EC?\xE1\xD1\x8AdsolcC\0\x08\x1B\x003",
603 );
604 #[rustfmt::skip]
610 #[allow(clippy::all)]
611 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
612 b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0\xE5W_5`\xE0\x1C\x80c\x91\0gE\x11a\0\x88W\x80c\xAD\x8A\xCAw\x11a\0cW\x80c\xAD\x8A\xCAw\x14a\x01\xDFW\x80c\xDFY\\\xB8\x14a\x01\xF2W\x80c\xEBZN\x87\x14a\x02\x05W\x80c\xFD\xDB\xDE\xFD\x14a\x02\x18W__\xFD[\x80c\x91\0gE\x14a\x01\x96W\x80c\x95\r\x80n\x14a\x01\xB9W\x80c\xAD_\"\x10\x14a\x01\xCCW__\xFD[\x80cT\xFDMP\x11a\0\xC3W\x80cT\xFDMP\x14a\x01$W\x80cb\x88\x06\xEF\x14a\x01BW\x80ck\xDD\xFA\x1F\x14a\x01UW\x80c\x88*;8\x14a\x01uW__\xFD[\x80c\x06d\x12\x01\x14a\0\xE9W\x80c&\x89Y\xE5\x14a\0\xFEW\x80cO\x90l\xF9\x14a\x01\x11W[__\xFD[a\0\xFCa\0\xF76`\x04a\r\xBDV[a\x02+V[\0[a\0\xFCa\x01\x0C6`\x04a\x0E\x0EV[a\x03LV[a\0\xFCa\x01\x1F6`\x04a\x0E\x0EV[a\x04'V[a\x01,a\x04\xCAV[`@Qa\x019\x91\x90a\x0E?V[`@Q\x80\x91\x03\x90\xF3[a\0\xFCa\x01P6`\x04a\x0E\x8AV[a\x04\xFAV[a\x01ha\x01c6`\x04a\x0E\x8AV[a\x05\x88V[`@Qa\x019\x91\x90a\x0E\xE6V[a\x01\x88a\x01\x836`\x04a\x0E\x0EV[a\x05\xB1V[`@Qa\x019\x92\x91\x90a\x0E\xF8V[a\x01\xA9a\x01\xA46`\x04a\x0E\x0EV[a\x07\x12V[`@Q\x90\x15\x15\x81R` \x01a\x019V[a\0\xFCa\x01\xC76`\x04a\r\xBDV[a\x07\x82V[a\x01ha\x01\xDA6`\x04a\x0E\x8AV[a\x08\x93V[a\x01\xA9a\x01\xED6`\x04a\x0E\x0EV[a\t9V[a\x01\xA9a\x02\x006`\x04a\r\xBDV[a\tZV[a\0\xFCa\x02\x136`\x04a\x0E\x0EV[a\t\xAFV[a\x01ha\x02&6`\x04a\x0FZV[a\n}V[\x83a\x026\x813a\x07\x12V[a\x02SW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x02u\x85\x85a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x02\x9B\x90\x82a\n\xE8V[a\x02\xB8W`@Qc&!\x18\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x02\xDB\x90\x82a\n\xFFV[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x02\xF5\x90\x87a\x0B\nV[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x18$#&\xB6\xB8b\x12ipg\x97Y\x16\x9F\x01\xF6F\xBDU\xEC[\xFC\xAB\x85\xBA\x9F3zt\xE0\xC6\x87\x87`@Qa\x03;\x92\x91\x90a\x0F\x9AV[`@Q\x80\x91\x03\x90\xA3PPPPPPPV[\x81a\x03W\x813a\x07\x12V[a\x03tW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` \x81\x90R`@\x90\x91 `\x02\x01\x90a\x03\x9B\x82a\x0B\x1EV[\x11a\x03\xB9W`@Qc\x10\xCE\x89+`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x03\xC3\x81\x84a\x0B\nV[a\x03\xE0W`@Qc\x07\x16\xD8\x1B`\xE5\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R\x85\x16\x90\x7F\xDB\x9D]12\r\xAF[\xC7\x18\x1DV[m\xA4\xD1.0\xF0\xF4\xD5\xAA2J\x99$&\xC1J\x1D\x19\xCE\x90` \x01[`@Q\x80\x91\x03\x90\xA2PPPPV[\x81a\x042\x813a\x07\x12V[a\x04OW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x04p\x81\x84a\x0B\nV[a\x04\x8DW`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R\x85\x16\x90\x7F\xD7\x06\xEDz\xE0D\xD7\x95\xB4\x9ET\xC9\xF5\x19\xF6c\x059Q\x01\x19\x85\xF6c\xA8b\xCD\x9E\xE7*\x9A\xC7\x90` \x01a\x04\x19V[``a\x04\xF5\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\x0B'V[\x90P\x90V[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 a\x05\x1B\x813a\x0B\nV[a\x058W`@Qc\xBE\xD8)_`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x05E`\x02\x82\x013a\x0BdV[P`@Q3\x81R`\x01`\x01`\xA0\x1B\x03\x83\x16\x90\x7F\xBF&^\x83&(Z'G\xE3>T\xD5\x94_q\x11\xF2\xB5\xED\xB8&\xEB\x8C\x08\xD4gwy\xB3\xFF\x97\x90` \x01`@Q\x80\x91\x03\x90\xA2PPV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x05\xAB\x90a\x0BxV[\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x80\x83\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x85\x16\x83R`\x04\x90\x93\x01\x90R\x90\x81 ``\x91\x82\x91\x90a\x05\xEA\x82a\x0B\x1EV[\x90P_\x81g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06\x06Wa\x06\x06a\x0F\xBDV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06/W\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_\x82g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x06LWa\x06La\x0F\xBDV[`@Q\x90\x80\x82R\x80` \x02` \x01\x82\x01`@R\x80\x15a\x06uW\x81` \x01` \x82\x02\x806\x837\x01\x90P[P\x90P_[\x83\x81\x10\x15a\x07\x04Wa\x06\xA8a\x06\x8F\x86\x83a\x0B\x84V[``\x81\x90\x1C\x91`\xA0\x91\x90\x91\x1B`\x01`\x01`\xE0\x1B\x03\x19\x16\x90V[\x84\x83\x81Q\x81\x10a\x06\xBAWa\x06\xBAa\x0F\xD1V[` \x02` \x01\x01\x84\x84\x81Q\x81\x10a\x06\xD3Wa\x06\xD3a\x0F\xD1V[`\x01`\x01`\xE0\x1B\x03\x19\x90\x93\x16` \x93\x84\x02\x91\x90\x91\x01\x90\x92\x01\x91\x90\x91R`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x90R`\x01\x01a\x06zV[P\x90\x97\x90\x96P\x94PPPPPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x075\x90`\x02\x01a\x0B\x1EV[_\x03a\x07WW\x81`\x01`\x01`\xA0\x1B\x03\x16\x83`\x01`\x01`\xA0\x1B\x03\x16\x14\x90Pa\x05\xABV[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\x07{\x90`\x02\x01\x83a\x0B\x8FV[\x93\x92PPPV[\x83a\x07\x8D\x813a\x07\x12V[a\x07\xAAW`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x85\x16_\x90\x81R`\x01` R`@\x81 \x90a\x07\xCC\x85\x85a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x87\x16_\x90\x81R`\x04\x84\x01` R`@\x90 \x90\x91Pa\x07\xF2\x90\x82a\n\xE8V[\x15a\x08\x10W`@Qc\xAD\x8E\xFE\xB7`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x04\x83\x01` R`@\x90 a\x083\x90\x82a\x0B\xB0V[P_\x81\x81R`\x05\x83\x01` R`@\x90 a\x08M\x90\x87a\x0BdV[P\x85`\x01`\x01`\xA0\x1B\x03\x16\x87`\x01`\x01`\xA0\x1B\x03\x16\x7F\x03\x7F\x03\xA2\xADk\x96}\xF4\xA0\x17y\xB6\xD2\xB4\xC8YP\xDF\x83\x92]\x9E16+Q\x94\"\xFC\x01i\x87\x87`@Qa\x03;\x92\x91\x90a\x0F\x9AV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01` R`@\x90 ``\x90a\x08\xB9\x90`\x02\x01a\x0B\x1EV[_\x03a\t\x11W`@\x80Q`\x01\x80\x82R\x81\x83\x01\x90\x92R_\x91` \x80\x83\x01\x90\x806\x837\x01\x90PP\x90P\x82\x81_\x81Q\x81\x10a\x08\xF3Wa\x08\xF3a\x0F\xD1V[`\x01`\x01`\xA0\x1B\x03\x90\x92\x16` \x92\x83\x02\x91\x90\x91\x01\x90\x91\x01R\x92\x91PPV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x90 a\x05\xAB\x90`\x02\x01a\x0BxV[\x91\x90PV[`\x01`\x01`\xA0\x1B\x03\x82\x16_\x90\x81R`\x01` R`@\x81 a\x07{\x90\x83a\x0B\x8FV[_a\te\x85\x85a\x07\x12V[\x80a\t\xA6WPa\t\xA6a\tx\x84\x84a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x80\x88\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x93\x8A\x16\x83R`\x04\x90\x93\x01\x90R \x90a\n\xE8V[\x95\x94PPPPPV[\x81a\t\xBA\x813a\x07\x12V[a\t\xD7W`@Qc{\xFAK\x9F`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01`\x01`\xA0\x1B\x03\x83\x16_\x90\x81R`\x01` R`@\x90 a\t\xFB`\x02\x82\x01\x84a\x0B\x8FV[\x15a\n\x19W`@Qc\x13\x01`\xE5`\xE3\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\n#\x81\x84a\x0BdV[a\n@W`@Qc\x19\xAB\xED\xE3`\xE1\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`@Q`\x01`\x01`\xA0\x1B\x03\x84\x81\x16\x82R\x85\x16\x90\x7F\xB1K\x9A=D\x8C[\x04\xF0\xE5\xB0\x87\xB6\xF5\x193\x90\xDByUH*o\xFB\x84\x1E{;\xA6\x1AF\x0C\x90` \x01a\x04\x19V[``_a\n\x8A\x84\x84a\n\xBBV[`\x01`\x01`\xA0\x1B\x03\x86\x16_\x90\x81R`\x01` \x90\x81R`@\x80\x83 \x84\x84R`\x05\x01\x90\x91R\x90 \x90\x91Pa\t\xA6\x90a\x0BxV[``\x91\x90\x91\x1Bk\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x19\x16`\xA0\x91\x90\x91\x1Ck\xFF\xFF\xFF\xFF\0\0\0\0\0\0\0\0\x16\x17\x90V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07{V[_a\x07{\x83\x83a\x0B\xBBV[_a\x07{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0B\xBBV[_a\x05\xAB\x82T\x90V[``_a\x0B3\x83a\x0C\x9EV[`@\x80Q` \x80\x82R\x81\x83\x01\x90\x92R\x91\x92P_\x91\x90` \x82\x01\x81\x806\x837PPP\x91\x82RP` \x81\x01\x92\x90\x92RP\x90V[_a\x07{\x83`\x01`\x01`\xA0\x1B\x03\x84\x16a\x0C\xC5V[``_a\x07{\x83a\r\x11V[_a\x07{\x83\x83a\rjV[`\x01`\x01`\xA0\x1B\x03\x81\x16_\x90\x81R`\x01\x83\x01` R`@\x81 T\x15\x15a\x07{V[_a\x07{\x83\x83a\x0C\xC5V[_\x81\x81R`\x01\x83\x01` R`@\x81 T\x80\x15a\x0C\x95W_a\x0B\xDD`\x01\x83a\x0F\xE5V[\x85T\x90\x91P_\x90a\x0B\xF0\x90`\x01\x90a\x0F\xE5V[\x90P\x81\x81\x14a\x0COW_\x86_\x01\x82\x81T\x81\x10a\x0C\x0EWa\x0C\x0Ea\x0F\xD1V[\x90_R` _ \x01T\x90P\x80\x87_\x01\x84\x81T\x81\x10a\x0C.Wa\x0C.a\x0F\xD1V[_\x91\x82R` \x80\x83 \x90\x91\x01\x92\x90\x92U\x91\x82R`\x01\x88\x01\x90R`@\x90 \x83\x90U[\x85T\x86\x90\x80a\x0C`Wa\x0C`a\x10\x04V[`\x01\x90\x03\x81\x81\x90_R` _ \x01_\x90U\x90U\x85`\x01\x01_\x86\x81R` \x01\x90\x81R` \x01_ _\x90U`\x01\x93PPPPa\x05\xABV[_\x91PPa\x05\xABV[_`\xFF\x82\x16`\x1F\x81\x11\x15a\x05\xABW`@Qc,\xD4J\xC3`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x81\x81R`\x01\x83\x01` R`@\x81 Ta\r\nWP\x81T`\x01\x81\x81\x01\x84U_\x84\x81R` \x80\x82 \x90\x93\x01\x84\x90U\x84T\x84\x82R\x82\x86\x01\x90\x93R`@\x90 \x91\x90\x91Ua\x05\xABV[P_a\x05\xABV[``\x81_\x01\x80T\x80` \x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80T\x80\x15a\r^W` \x02\x82\x01\x91\x90_R` _ \x90[\x81T\x81R` \x01\x90`\x01\x01\x90\x80\x83\x11a\rJW[PPPPP\x90P\x91\x90PV[_\x82_\x01\x82\x81T\x81\x10a\r\x7FWa\r\x7Fa\x0F\xD1V[\x90_R` _ \x01T\x90P\x92\x91PPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\t4W__\xFD[\x805`\x01`\x01`\xE0\x1B\x03\x19\x81\x16\x81\x14a\t4W__\xFD[____`\x80\x85\x87\x03\x12\x15a\r\xD0W__\xFD[a\r\xD9\x85a\r\x90V[\x93Pa\r\xE7` \x86\x01a\r\x90V[\x92Pa\r\xF5`@\x86\x01a\r\x90V[\x91Pa\x0E\x03``\x86\x01a\r\xA6V[\x90P\x92\x95\x91\x94P\x92PV[__`@\x83\x85\x03\x12\x15a\x0E\x1FW__\xFD[a\x0E(\x83a\r\x90V[\x91Pa\x0E6` \x84\x01a\r\x90V[\x90P\x92P\x92\x90PV[` \x81R_\x82Q\x80` \x84\x01R_[\x81\x81\x10\x15a\x0EkW` \x81\x86\x01\x81\x01Q`@\x86\x84\x01\x01R\x01a\x0ENV[P_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[_` \x82\x84\x03\x12\x15a\x0E\x9AW__\xFD[a\x07{\x82a\r\x90V[_\x81Q\x80\x84R` \x84\x01\x93P` \x83\x01_[\x82\x81\x10\x15a\x0E\xDCW\x81Q`\x01`\x01`\xA0\x1B\x03\x16\x86R` \x95\x86\x01\x95\x90\x91\x01\x90`\x01\x01a\x0E\xB5V[P\x93\x94\x93PPPPV[` \x81R_a\x07{` \x83\x01\x84a\x0E\xA3V[`@\x81R_a\x0F\n`@\x83\x01\x85a\x0E\xA3V[\x82\x81\x03` \x84\x01R\x80\x84Q\x80\x83R` \x83\x01\x91P` \x86\x01\x92P_[\x81\x81\x10\x15a\x0FNW\x83Q`\x01`\x01`\xE0\x1B\x03\x19\x16\x83R` \x93\x84\x01\x93\x90\x92\x01\x91`\x01\x01a\x0F&V[P\x90\x96\x95PPPPPPV[___``\x84\x86\x03\x12\x15a\x0FlW__\xFD[a\x0Fu\x84a\r\x90V[\x92Pa\x0F\x83` \x85\x01a\r\x90V[\x91Pa\x0F\x91`@\x85\x01a\r\xA6V[\x90P\x92P\x92P\x92V[`\x01`\x01`\xA0\x1B\x03\x92\x90\x92\x16\x82R`\x01`\x01`\xE0\x1B\x03\x19\x16` \x82\x01R`@\x01\x90V[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`2`\x04R`$_\xFD[\x81\x81\x03\x81\x81\x11\x15a\x05\xABWcNH{q`\xE0\x1B_R`\x11`\x04R`$_\xFD[cNH{q`\xE0\x1B_R`1`\x04R`$_\xFD\xFE\xA2dipfsX\"\x12 0\xDD\x84\x80W\xA9\x90\x8A\x14\x13\xE3T\xBB\xBB\x87x\xF7\xA9\xA4\xE1\x91\x1D~\xBC7_EC?\xE1\xD1\x8AdsolcC\0\x08\x1B\x003",
613 );
614 #[derive(serde::Serialize, serde::Deserialize)]
615 #[derive(Default, Debug, PartialEq, Eq, Hash)]
616 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
621 #[derive(Clone)]
622 pub struct AdminAlreadyPending;
623 #[allow(
624 non_camel_case_types,
625 non_snake_case,
626 clippy::pub_underscore_fields,
627 clippy::style
628 )]
629 const _: () = {
630 use alloy::sol_types as alloy_sol_types;
631 #[doc(hidden)]
632 type UnderlyingSolTuple<'a> = ();
633 #[doc(hidden)]
634 type UnderlyingRustTuple<'a> = ();
635 #[cfg(test)]
636 #[allow(dead_code, unreachable_patterns)]
637 fn _type_assertion(
638 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
639 ) {
640 match _t {
641 alloy_sol_types::private::AssertTypeEq::<
642 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
643 >(_) => {}
644 }
645 }
646 #[automatically_derived]
647 #[doc(hidden)]
648 impl ::core::convert::From<AdminAlreadyPending> for UnderlyingRustTuple<'_> {
649 fn from(value: AdminAlreadyPending) -> Self {
650 ()
651 }
652 }
653 #[automatically_derived]
654 #[doc(hidden)]
655 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminAlreadyPending {
656 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
657 Self
658 }
659 }
660 #[automatically_derived]
661 impl alloy_sol_types::SolError for AdminAlreadyPending {
662 type Parameters<'a> = UnderlyingSolTuple<'a>;
663 type Token<'a> = <Self::Parameters<
664 'a,
665 > as alloy_sol_types::SolType>::Token<'a>;
666 const SIGNATURE: &'static str = "AdminAlreadyPending()";
667 const SELECTOR: [u8; 4] = [51u8, 87u8, 219u8, 198u8];
668 #[inline]
669 fn new<'a>(
670 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
671 ) -> Self {
672 tuple.into()
673 }
674 #[inline]
675 fn tokenize(&self) -> Self::Token<'_> {
676 ()
677 }
678 #[inline]
679 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
680 <Self::Parameters<
681 '_,
682 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
683 .map(Self::new)
684 }
685 }
686 };
687 #[derive(serde::Serialize, serde::Deserialize)]
688 #[derive(Default, Debug, PartialEq, Eq, Hash)]
689 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
694 #[derive(Clone)]
695 pub struct AdminAlreadySet;
696 #[allow(
697 non_camel_case_types,
698 non_snake_case,
699 clippy::pub_underscore_fields,
700 clippy::style
701 )]
702 const _: () = {
703 use alloy::sol_types as alloy_sol_types;
704 #[doc(hidden)]
705 type UnderlyingSolTuple<'a> = ();
706 #[doc(hidden)]
707 type UnderlyingRustTuple<'a> = ();
708 #[cfg(test)]
709 #[allow(dead_code, unreachable_patterns)]
710 fn _type_assertion(
711 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
712 ) {
713 match _t {
714 alloy_sol_types::private::AssertTypeEq::<
715 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
716 >(_) => {}
717 }
718 }
719 #[automatically_derived]
720 #[doc(hidden)]
721 impl ::core::convert::From<AdminAlreadySet> for UnderlyingRustTuple<'_> {
722 fn from(value: AdminAlreadySet) -> Self {
723 ()
724 }
725 }
726 #[automatically_derived]
727 #[doc(hidden)]
728 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminAlreadySet {
729 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
730 Self
731 }
732 }
733 #[automatically_derived]
734 impl alloy_sol_types::SolError for AdminAlreadySet {
735 type Parameters<'a> = UnderlyingSolTuple<'a>;
736 type Token<'a> = <Self::Parameters<
737 'a,
738 > as alloy_sol_types::SolType>::Token<'a>;
739 const SIGNATURE: &'static str = "AdminAlreadySet()";
740 const SELECTOR: [u8; 4] = [152u8, 11u8, 7u8, 40u8];
741 #[inline]
742 fn new<'a>(
743 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
744 ) -> Self {
745 tuple.into()
746 }
747 #[inline]
748 fn tokenize(&self) -> Self::Token<'_> {
749 ()
750 }
751 #[inline]
752 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
753 <Self::Parameters<
754 '_,
755 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
756 .map(Self::new)
757 }
758 }
759 };
760 #[derive(serde::Serialize, serde::Deserialize)]
761 #[derive(Default, Debug, PartialEq, Eq, Hash)]
762 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
767 #[derive(Clone)]
768 pub struct AdminNotPending;
769 #[allow(
770 non_camel_case_types,
771 non_snake_case,
772 clippy::pub_underscore_fields,
773 clippy::style
774 )]
775 const _: () = {
776 use alloy::sol_types as alloy_sol_types;
777 #[doc(hidden)]
778 type UnderlyingSolTuple<'a> = ();
779 #[doc(hidden)]
780 type UnderlyingRustTuple<'a> = ();
781 #[cfg(test)]
782 #[allow(dead_code, unreachable_patterns)]
783 fn _type_assertion(
784 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
785 ) {
786 match _t {
787 alloy_sol_types::private::AssertTypeEq::<
788 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
789 >(_) => {}
790 }
791 }
792 #[automatically_derived]
793 #[doc(hidden)]
794 impl ::core::convert::From<AdminNotPending> for UnderlyingRustTuple<'_> {
795 fn from(value: AdminNotPending) -> Self {
796 ()
797 }
798 }
799 #[automatically_derived]
800 #[doc(hidden)]
801 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminNotPending {
802 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
803 Self
804 }
805 }
806 #[automatically_derived]
807 impl alloy_sol_types::SolError for AdminNotPending {
808 type Parameters<'a> = UnderlyingSolTuple<'a>;
809 type Token<'a> = <Self::Parameters<
810 'a,
811 > as alloy_sol_types::SolType>::Token<'a>;
812 const SIGNATURE: &'static str = "AdminNotPending()";
813 const SELECTOR: [u8; 4] = [190u8, 216u8, 41u8, 95u8];
814 #[inline]
815 fn new<'a>(
816 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
817 ) -> Self {
818 tuple.into()
819 }
820 #[inline]
821 fn tokenize(&self) -> Self::Token<'_> {
822 ()
823 }
824 #[inline]
825 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
826 <Self::Parameters<
827 '_,
828 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
829 .map(Self::new)
830 }
831 }
832 };
833 #[derive(serde::Serialize, serde::Deserialize)]
834 #[derive(Default, Debug, PartialEq, Eq, Hash)]
835 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
840 #[derive(Clone)]
841 pub struct AdminNotSet;
842 #[allow(
843 non_camel_case_types,
844 non_snake_case,
845 clippy::pub_underscore_fields,
846 clippy::style
847 )]
848 const _: () = {
849 use alloy::sol_types as alloy_sol_types;
850 #[doc(hidden)]
851 type UnderlyingSolTuple<'a> = ();
852 #[doc(hidden)]
853 type UnderlyingRustTuple<'a> = ();
854 #[cfg(test)]
855 #[allow(dead_code, unreachable_patterns)]
856 fn _type_assertion(
857 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
858 ) {
859 match _t {
860 alloy_sol_types::private::AssertTypeEq::<
861 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
862 >(_) => {}
863 }
864 }
865 #[automatically_derived]
866 #[doc(hidden)]
867 impl ::core::convert::From<AdminNotSet> for UnderlyingRustTuple<'_> {
868 fn from(value: AdminNotSet) -> Self {
869 ()
870 }
871 }
872 #[automatically_derived]
873 #[doc(hidden)]
874 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AdminNotSet {
875 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
876 Self
877 }
878 }
879 #[automatically_derived]
880 impl alloy_sol_types::SolError for AdminNotSet {
881 type Parameters<'a> = UnderlyingSolTuple<'a>;
882 type Token<'a> = <Self::Parameters<
883 'a,
884 > as alloy_sol_types::SolType>::Token<'a>;
885 const SIGNATURE: &'static str = "AdminNotSet()";
886 const SELECTOR: [u8; 4] = [226u8, 219u8, 3u8, 96u8];
887 #[inline]
888 fn new<'a>(
889 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
890 ) -> Self {
891 tuple.into()
892 }
893 #[inline]
894 fn tokenize(&self) -> Self::Token<'_> {
895 ()
896 }
897 #[inline]
898 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
899 <Self::Parameters<
900 '_,
901 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
902 .map(Self::new)
903 }
904 }
905 };
906 #[derive(serde::Serialize, serde::Deserialize)]
907 #[derive(Default, Debug, PartialEq, Eq, Hash)]
908 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
913 #[derive(Clone)]
914 pub struct AppointeeAlreadySet;
915 #[allow(
916 non_camel_case_types,
917 non_snake_case,
918 clippy::pub_underscore_fields,
919 clippy::style
920 )]
921 const _: () = {
922 use alloy::sol_types as alloy_sol_types;
923 #[doc(hidden)]
924 type UnderlyingSolTuple<'a> = ();
925 #[doc(hidden)]
926 type UnderlyingRustTuple<'a> = ();
927 #[cfg(test)]
928 #[allow(dead_code, unreachable_patterns)]
929 fn _type_assertion(
930 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
931 ) {
932 match _t {
933 alloy_sol_types::private::AssertTypeEq::<
934 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
935 >(_) => {}
936 }
937 }
938 #[automatically_derived]
939 #[doc(hidden)]
940 impl ::core::convert::From<AppointeeAlreadySet> for UnderlyingRustTuple<'_> {
941 fn from(value: AppointeeAlreadySet) -> Self {
942 ()
943 }
944 }
945 #[automatically_derived]
946 #[doc(hidden)]
947 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AppointeeAlreadySet {
948 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
949 Self
950 }
951 }
952 #[automatically_derived]
953 impl alloy_sol_types::SolError for AppointeeAlreadySet {
954 type Parameters<'a> = UnderlyingSolTuple<'a>;
955 type Token<'a> = <Self::Parameters<
956 'a,
957 > as alloy_sol_types::SolType>::Token<'a>;
958 const SIGNATURE: &'static str = "AppointeeAlreadySet()";
959 const SELECTOR: [u8; 4] = [173u8, 142u8, 254u8, 183u8];
960 #[inline]
961 fn new<'a>(
962 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
963 ) -> Self {
964 tuple.into()
965 }
966 #[inline]
967 fn tokenize(&self) -> Self::Token<'_> {
968 ()
969 }
970 #[inline]
971 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
972 <Self::Parameters<
973 '_,
974 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
975 .map(Self::new)
976 }
977 }
978 };
979 #[derive(serde::Serialize, serde::Deserialize)]
980 #[derive(Default, Debug, PartialEq, Eq, Hash)]
981 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
986 #[derive(Clone)]
987 pub struct AppointeeNotSet;
988 #[allow(
989 non_camel_case_types,
990 non_snake_case,
991 clippy::pub_underscore_fields,
992 clippy::style
993 )]
994 const _: () = {
995 use alloy::sol_types as alloy_sol_types;
996 #[doc(hidden)]
997 type UnderlyingSolTuple<'a> = ();
998 #[doc(hidden)]
999 type UnderlyingRustTuple<'a> = ();
1000 #[cfg(test)]
1001 #[allow(dead_code, unreachable_patterns)]
1002 fn _type_assertion(
1003 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1004 ) {
1005 match _t {
1006 alloy_sol_types::private::AssertTypeEq::<
1007 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1008 >(_) => {}
1009 }
1010 }
1011 #[automatically_derived]
1012 #[doc(hidden)]
1013 impl ::core::convert::From<AppointeeNotSet> for UnderlyingRustTuple<'_> {
1014 fn from(value: AppointeeNotSet) -> Self {
1015 ()
1016 }
1017 }
1018 #[automatically_derived]
1019 #[doc(hidden)]
1020 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AppointeeNotSet {
1021 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1022 Self
1023 }
1024 }
1025 #[automatically_derived]
1026 impl alloy_sol_types::SolError for AppointeeNotSet {
1027 type Parameters<'a> = UnderlyingSolTuple<'a>;
1028 type Token<'a> = <Self::Parameters<
1029 'a,
1030 > as alloy_sol_types::SolType>::Token<'a>;
1031 const SIGNATURE: &'static str = "AppointeeNotSet()";
1032 const SELECTOR: [u8; 4] = [38u8, 33u8, 24u8, 205u8];
1033 #[inline]
1034 fn new<'a>(
1035 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1036 ) -> Self {
1037 tuple.into()
1038 }
1039 #[inline]
1040 fn tokenize(&self) -> Self::Token<'_> {
1041 ()
1042 }
1043 #[inline]
1044 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1045 <Self::Parameters<
1046 '_,
1047 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1048 .map(Self::new)
1049 }
1050 }
1051 };
1052 #[derive(serde::Serialize, serde::Deserialize)]
1053 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1054 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1059 #[derive(Clone)]
1060 pub struct CannotHaveZeroAdmins;
1061 #[allow(
1062 non_camel_case_types,
1063 non_snake_case,
1064 clippy::pub_underscore_fields,
1065 clippy::style
1066 )]
1067 const _: () = {
1068 use alloy::sol_types as alloy_sol_types;
1069 #[doc(hidden)]
1070 type UnderlyingSolTuple<'a> = ();
1071 #[doc(hidden)]
1072 type UnderlyingRustTuple<'a> = ();
1073 #[cfg(test)]
1074 #[allow(dead_code, unreachable_patterns)]
1075 fn _type_assertion(
1076 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1077 ) {
1078 match _t {
1079 alloy_sol_types::private::AssertTypeEq::<
1080 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1081 >(_) => {}
1082 }
1083 }
1084 #[automatically_derived]
1085 #[doc(hidden)]
1086 impl ::core::convert::From<CannotHaveZeroAdmins> for UnderlyingRustTuple<'_> {
1087 fn from(value: CannotHaveZeroAdmins) -> Self {
1088 ()
1089 }
1090 }
1091 #[automatically_derived]
1092 #[doc(hidden)]
1093 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CannotHaveZeroAdmins {
1094 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1095 Self
1096 }
1097 }
1098 #[automatically_derived]
1099 impl alloy_sol_types::SolError for CannotHaveZeroAdmins {
1100 type Parameters<'a> = UnderlyingSolTuple<'a>;
1101 type Token<'a> = <Self::Parameters<
1102 'a,
1103 > as alloy_sol_types::SolType>::Token<'a>;
1104 const SIGNATURE: &'static str = "CannotHaveZeroAdmins()";
1105 const SELECTOR: [u8; 4] = [134u8, 116u8, 73u8, 88u8];
1106 #[inline]
1107 fn new<'a>(
1108 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1109 ) -> Self {
1110 tuple.into()
1111 }
1112 #[inline]
1113 fn tokenize(&self) -> Self::Token<'_> {
1114 ()
1115 }
1116 #[inline]
1117 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1118 <Self::Parameters<
1119 '_,
1120 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1121 .map(Self::new)
1122 }
1123 }
1124 };
1125 #[derive(serde::Serialize, serde::Deserialize)]
1126 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1127 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1132 #[derive(Clone)]
1133 pub struct InvalidShortString;
1134 #[allow(
1135 non_camel_case_types,
1136 non_snake_case,
1137 clippy::pub_underscore_fields,
1138 clippy::style
1139 )]
1140 const _: () = {
1141 use alloy::sol_types as alloy_sol_types;
1142 #[doc(hidden)]
1143 type UnderlyingSolTuple<'a> = ();
1144 #[doc(hidden)]
1145 type UnderlyingRustTuple<'a> = ();
1146 #[cfg(test)]
1147 #[allow(dead_code, unreachable_patterns)]
1148 fn _type_assertion(
1149 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1150 ) {
1151 match _t {
1152 alloy_sol_types::private::AssertTypeEq::<
1153 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1154 >(_) => {}
1155 }
1156 }
1157 #[automatically_derived]
1158 #[doc(hidden)]
1159 impl ::core::convert::From<InvalidShortString> for UnderlyingRustTuple<'_> {
1160 fn from(value: InvalidShortString) -> Self {
1161 ()
1162 }
1163 }
1164 #[automatically_derived]
1165 #[doc(hidden)]
1166 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InvalidShortString {
1167 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1168 Self
1169 }
1170 }
1171 #[automatically_derived]
1172 impl alloy_sol_types::SolError for InvalidShortString {
1173 type Parameters<'a> = UnderlyingSolTuple<'a>;
1174 type Token<'a> = <Self::Parameters<
1175 'a,
1176 > as alloy_sol_types::SolType>::Token<'a>;
1177 const SIGNATURE: &'static str = "InvalidShortString()";
1178 const SELECTOR: [u8; 4] = [179u8, 81u8, 43u8, 12u8];
1179 #[inline]
1180 fn new<'a>(
1181 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1182 ) -> Self {
1183 tuple.into()
1184 }
1185 #[inline]
1186 fn tokenize(&self) -> Self::Token<'_> {
1187 ()
1188 }
1189 #[inline]
1190 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1191 <Self::Parameters<
1192 '_,
1193 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1194 .map(Self::new)
1195 }
1196 }
1197 };
1198 #[derive(serde::Serialize, serde::Deserialize)]
1199 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1200 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1205 #[derive(Clone)]
1206 pub struct NotAdmin;
1207 #[allow(
1208 non_camel_case_types,
1209 non_snake_case,
1210 clippy::pub_underscore_fields,
1211 clippy::style
1212 )]
1213 const _: () = {
1214 use alloy::sol_types as alloy_sol_types;
1215 #[doc(hidden)]
1216 type UnderlyingSolTuple<'a> = ();
1217 #[doc(hidden)]
1218 type UnderlyingRustTuple<'a> = ();
1219 #[cfg(test)]
1220 #[allow(dead_code, unreachable_patterns)]
1221 fn _type_assertion(
1222 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1223 ) {
1224 match _t {
1225 alloy_sol_types::private::AssertTypeEq::<
1226 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1227 >(_) => {}
1228 }
1229 }
1230 #[automatically_derived]
1231 #[doc(hidden)]
1232 impl ::core::convert::From<NotAdmin> for UnderlyingRustTuple<'_> {
1233 fn from(value: NotAdmin) -> Self {
1234 ()
1235 }
1236 }
1237 #[automatically_derived]
1238 #[doc(hidden)]
1239 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NotAdmin {
1240 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1241 Self
1242 }
1243 }
1244 #[automatically_derived]
1245 impl alloy_sol_types::SolError for NotAdmin {
1246 type Parameters<'a> = UnderlyingSolTuple<'a>;
1247 type Token<'a> = <Self::Parameters<
1248 'a,
1249 > as alloy_sol_types::SolType>::Token<'a>;
1250 const SIGNATURE: &'static str = "NotAdmin()";
1251 const SELECTOR: [u8; 4] = [123u8, 250u8, 75u8, 159u8];
1252 #[inline]
1253 fn new<'a>(
1254 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1255 ) -> Self {
1256 tuple.into()
1257 }
1258 #[inline]
1259 fn tokenize(&self) -> Self::Token<'_> {
1260 ()
1261 }
1262 #[inline]
1263 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1264 <Self::Parameters<
1265 '_,
1266 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1267 .map(Self::new)
1268 }
1269 }
1270 };
1271 #[derive(serde::Serialize, serde::Deserialize)]
1272 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1273 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1278 #[derive(Clone)]
1279 pub struct StringTooLong {
1280 #[allow(missing_docs)]
1281 pub str: alloy::sol_types::private::String,
1282 }
1283 #[allow(
1284 non_camel_case_types,
1285 non_snake_case,
1286 clippy::pub_underscore_fields,
1287 clippy::style
1288 )]
1289 const _: () = {
1290 use alloy::sol_types as alloy_sol_types;
1291 #[doc(hidden)]
1292 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1293 #[doc(hidden)]
1294 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1295 #[cfg(test)]
1296 #[allow(dead_code, unreachable_patterns)]
1297 fn _type_assertion(
1298 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1299 ) {
1300 match _t {
1301 alloy_sol_types::private::AssertTypeEq::<
1302 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1303 >(_) => {}
1304 }
1305 }
1306 #[automatically_derived]
1307 #[doc(hidden)]
1308 impl ::core::convert::From<StringTooLong> for UnderlyingRustTuple<'_> {
1309 fn from(value: StringTooLong) -> Self {
1310 (value.str,)
1311 }
1312 }
1313 #[automatically_derived]
1314 #[doc(hidden)]
1315 impl ::core::convert::From<UnderlyingRustTuple<'_>> for StringTooLong {
1316 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1317 Self { str: tuple.0 }
1318 }
1319 }
1320 #[automatically_derived]
1321 impl alloy_sol_types::SolError for StringTooLong {
1322 type Parameters<'a> = UnderlyingSolTuple<'a>;
1323 type Token<'a> = <Self::Parameters<
1324 'a,
1325 > as alloy_sol_types::SolType>::Token<'a>;
1326 const SIGNATURE: &'static str = "StringTooLong(string)";
1327 const SELECTOR: [u8; 4] = [48u8, 90u8, 39u8, 169u8];
1328 #[inline]
1329 fn new<'a>(
1330 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1331 ) -> Self {
1332 tuple.into()
1333 }
1334 #[inline]
1335 fn tokenize(&self) -> Self::Token<'_> {
1336 (
1337 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
1338 &self.str,
1339 ),
1340 )
1341 }
1342 #[inline]
1343 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1344 <Self::Parameters<
1345 '_,
1346 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1347 .map(Self::new)
1348 }
1349 }
1350 };
1351 #[derive(serde::Serialize, serde::Deserialize)]
1352 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1353 #[allow(
1358 non_camel_case_types,
1359 non_snake_case,
1360 clippy::pub_underscore_fields,
1361 clippy::style
1362 )]
1363 #[derive(Clone)]
1364 pub struct AdminRemoved {
1365 #[allow(missing_docs)]
1366 pub account: alloy::sol_types::private::Address,
1367 #[allow(missing_docs)]
1368 pub admin: alloy::sol_types::private::Address,
1369 }
1370 #[allow(
1371 non_camel_case_types,
1372 non_snake_case,
1373 clippy::pub_underscore_fields,
1374 clippy::style
1375 )]
1376 const _: () = {
1377 use alloy::sol_types as alloy_sol_types;
1378 #[automatically_derived]
1379 impl alloy_sol_types::SolEvent for AdminRemoved {
1380 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1381 type DataToken<'a> = <Self::DataTuple<
1382 'a,
1383 > as alloy_sol_types::SolType>::Token<'a>;
1384 type TopicList = (
1385 alloy_sol_types::sol_data::FixedBytes<32>,
1386 alloy::sol_types::sol_data::Address,
1387 );
1388 const SIGNATURE: &'static str = "AdminRemoved(address,address)";
1389 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1390 219u8, 157u8, 93u8, 49u8, 50u8, 13u8, 175u8, 91u8, 199u8, 24u8, 29u8,
1391 86u8, 91u8, 109u8, 164u8, 209u8, 46u8, 48u8, 240u8, 244u8, 213u8, 170u8,
1392 50u8, 74u8, 153u8, 36u8, 38u8, 193u8, 74u8, 29u8, 25u8, 206u8,
1393 ]);
1394 const ANONYMOUS: bool = false;
1395 #[allow(unused_variables)]
1396 #[inline]
1397 fn new(
1398 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1399 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1400 ) -> Self {
1401 Self {
1402 account: topics.1,
1403 admin: data.0,
1404 }
1405 }
1406 #[inline]
1407 fn check_signature(
1408 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1409 ) -> alloy_sol_types::Result<()> {
1410 if topics.0 != Self::SIGNATURE_HASH {
1411 return Err(
1412 alloy_sol_types::Error::invalid_event_signature_hash(
1413 Self::SIGNATURE,
1414 topics.0,
1415 Self::SIGNATURE_HASH,
1416 ),
1417 );
1418 }
1419 Ok(())
1420 }
1421 #[inline]
1422 fn tokenize_body(&self) -> Self::DataToken<'_> {
1423 (
1424 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1425 &self.admin,
1426 ),
1427 )
1428 }
1429 #[inline]
1430 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1431 (Self::SIGNATURE_HASH.into(), self.account.clone())
1432 }
1433 #[inline]
1434 fn encode_topics_raw(
1435 &self,
1436 out: &mut [alloy_sol_types::abi::token::WordToken],
1437 ) -> alloy_sol_types::Result<()> {
1438 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1439 return Err(alloy_sol_types::Error::Overrun);
1440 }
1441 out[0usize] = alloy_sol_types::abi::token::WordToken(
1442 Self::SIGNATURE_HASH,
1443 );
1444 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1445 &self.account,
1446 );
1447 Ok(())
1448 }
1449 }
1450 #[automatically_derived]
1451 impl alloy_sol_types::private::IntoLogData for AdminRemoved {
1452 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1453 From::from(self)
1454 }
1455 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1456 From::from(&self)
1457 }
1458 }
1459 #[automatically_derived]
1460 impl From<&AdminRemoved> for alloy_sol_types::private::LogData {
1461 #[inline]
1462 fn from(this: &AdminRemoved) -> alloy_sol_types::private::LogData {
1463 alloy_sol_types::SolEvent::encode_log_data(this)
1464 }
1465 }
1466 };
1467 #[derive(serde::Serialize, serde::Deserialize)]
1468 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1469 #[allow(
1474 non_camel_case_types,
1475 non_snake_case,
1476 clippy::pub_underscore_fields,
1477 clippy::style
1478 )]
1479 #[derive(Clone)]
1480 pub struct AdminSet {
1481 #[allow(missing_docs)]
1482 pub account: alloy::sol_types::private::Address,
1483 #[allow(missing_docs)]
1484 pub admin: alloy::sol_types::private::Address,
1485 }
1486 #[allow(
1487 non_camel_case_types,
1488 non_snake_case,
1489 clippy::pub_underscore_fields,
1490 clippy::style
1491 )]
1492 const _: () = {
1493 use alloy::sol_types as alloy_sol_types;
1494 #[automatically_derived]
1495 impl alloy_sol_types::SolEvent for AdminSet {
1496 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1497 type DataToken<'a> = <Self::DataTuple<
1498 'a,
1499 > as alloy_sol_types::SolType>::Token<'a>;
1500 type TopicList = (
1501 alloy_sol_types::sol_data::FixedBytes<32>,
1502 alloy::sol_types::sol_data::Address,
1503 );
1504 const SIGNATURE: &'static str = "AdminSet(address,address)";
1505 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1506 191u8, 38u8, 94u8, 131u8, 38u8, 40u8, 90u8, 39u8, 71u8, 227u8, 62u8,
1507 84u8, 213u8, 148u8, 95u8, 113u8, 17u8, 242u8, 181u8, 237u8, 184u8, 38u8,
1508 235u8, 140u8, 8u8, 212u8, 103u8, 119u8, 121u8, 179u8, 255u8, 151u8,
1509 ]);
1510 const ANONYMOUS: bool = false;
1511 #[allow(unused_variables)]
1512 #[inline]
1513 fn new(
1514 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1515 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1516 ) -> Self {
1517 Self {
1518 account: topics.1,
1519 admin: data.0,
1520 }
1521 }
1522 #[inline]
1523 fn check_signature(
1524 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1525 ) -> alloy_sol_types::Result<()> {
1526 if topics.0 != Self::SIGNATURE_HASH {
1527 return Err(
1528 alloy_sol_types::Error::invalid_event_signature_hash(
1529 Self::SIGNATURE,
1530 topics.0,
1531 Self::SIGNATURE_HASH,
1532 ),
1533 );
1534 }
1535 Ok(())
1536 }
1537 #[inline]
1538 fn tokenize_body(&self) -> Self::DataToken<'_> {
1539 (
1540 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1541 &self.admin,
1542 ),
1543 )
1544 }
1545 #[inline]
1546 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1547 (Self::SIGNATURE_HASH.into(), self.account.clone())
1548 }
1549 #[inline]
1550 fn encode_topics_raw(
1551 &self,
1552 out: &mut [alloy_sol_types::abi::token::WordToken],
1553 ) -> alloy_sol_types::Result<()> {
1554 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1555 return Err(alloy_sol_types::Error::Overrun);
1556 }
1557 out[0usize] = alloy_sol_types::abi::token::WordToken(
1558 Self::SIGNATURE_HASH,
1559 );
1560 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1561 &self.account,
1562 );
1563 Ok(())
1564 }
1565 }
1566 #[automatically_derived]
1567 impl alloy_sol_types::private::IntoLogData for AdminSet {
1568 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1569 From::from(self)
1570 }
1571 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1572 From::from(&self)
1573 }
1574 }
1575 #[automatically_derived]
1576 impl From<&AdminSet> for alloy_sol_types::private::LogData {
1577 #[inline]
1578 fn from(this: &AdminSet) -> alloy_sol_types::private::LogData {
1579 alloy_sol_types::SolEvent::encode_log_data(this)
1580 }
1581 }
1582 };
1583 #[derive(serde::Serialize, serde::Deserialize)]
1584 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1585 #[allow(
1590 non_camel_case_types,
1591 non_snake_case,
1592 clippy::pub_underscore_fields,
1593 clippy::style
1594 )]
1595 #[derive(Clone)]
1596 pub struct AppointeeRemoved {
1597 #[allow(missing_docs)]
1598 pub account: alloy::sol_types::private::Address,
1599 #[allow(missing_docs)]
1600 pub appointee: alloy::sol_types::private::Address,
1601 #[allow(missing_docs)]
1602 pub target: alloy::sol_types::private::Address,
1603 #[allow(missing_docs)]
1604 pub selector: alloy::sol_types::private::FixedBytes<4>,
1605 }
1606 #[allow(
1607 non_camel_case_types,
1608 non_snake_case,
1609 clippy::pub_underscore_fields,
1610 clippy::style
1611 )]
1612 const _: () = {
1613 use alloy::sol_types as alloy_sol_types;
1614 #[automatically_derived]
1615 impl alloy_sol_types::SolEvent for AppointeeRemoved {
1616 type DataTuple<'a> = (
1617 alloy::sol_types::sol_data::Address,
1618 alloy::sol_types::sol_data::FixedBytes<4>,
1619 );
1620 type DataToken<'a> = <Self::DataTuple<
1621 'a,
1622 > as alloy_sol_types::SolType>::Token<'a>;
1623 type TopicList = (
1624 alloy_sol_types::sol_data::FixedBytes<32>,
1625 alloy::sol_types::sol_data::Address,
1626 alloy::sol_types::sol_data::Address,
1627 );
1628 const SIGNATURE: &'static str = "AppointeeRemoved(address,address,address,bytes4)";
1629 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1630 24u8, 36u8, 35u8, 38u8, 182u8, 184u8, 98u8, 18u8, 105u8, 112u8, 103u8,
1631 151u8, 89u8, 22u8, 159u8, 1u8, 246u8, 70u8, 189u8, 85u8, 236u8, 91u8,
1632 252u8, 171u8, 133u8, 186u8, 159u8, 51u8, 122u8, 116u8, 224u8, 198u8,
1633 ]);
1634 const ANONYMOUS: bool = false;
1635 #[allow(unused_variables)]
1636 #[inline]
1637 fn new(
1638 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1639 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1640 ) -> Self {
1641 Self {
1642 account: topics.1,
1643 appointee: topics.2,
1644 target: data.0,
1645 selector: data.1,
1646 }
1647 }
1648 #[inline]
1649 fn check_signature(
1650 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1651 ) -> alloy_sol_types::Result<()> {
1652 if topics.0 != Self::SIGNATURE_HASH {
1653 return Err(
1654 alloy_sol_types::Error::invalid_event_signature_hash(
1655 Self::SIGNATURE,
1656 topics.0,
1657 Self::SIGNATURE_HASH,
1658 ),
1659 );
1660 }
1661 Ok(())
1662 }
1663 #[inline]
1664 fn tokenize_body(&self) -> Self::DataToken<'_> {
1665 (
1666 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1667 &self.target,
1668 ),
1669 <alloy::sol_types::sol_data::FixedBytes<
1670 4,
1671 > as alloy_sol_types::SolType>::tokenize(&self.selector),
1672 )
1673 }
1674 #[inline]
1675 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1676 (
1677 Self::SIGNATURE_HASH.into(),
1678 self.account.clone(),
1679 self.appointee.clone(),
1680 )
1681 }
1682 #[inline]
1683 fn encode_topics_raw(
1684 &self,
1685 out: &mut [alloy_sol_types::abi::token::WordToken],
1686 ) -> alloy_sol_types::Result<()> {
1687 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1688 return Err(alloy_sol_types::Error::Overrun);
1689 }
1690 out[0usize] = alloy_sol_types::abi::token::WordToken(
1691 Self::SIGNATURE_HASH,
1692 );
1693 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1694 &self.account,
1695 );
1696 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1697 &self.appointee,
1698 );
1699 Ok(())
1700 }
1701 }
1702 #[automatically_derived]
1703 impl alloy_sol_types::private::IntoLogData for AppointeeRemoved {
1704 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1705 From::from(self)
1706 }
1707 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1708 From::from(&self)
1709 }
1710 }
1711 #[automatically_derived]
1712 impl From<&AppointeeRemoved> for alloy_sol_types::private::LogData {
1713 #[inline]
1714 fn from(this: &AppointeeRemoved) -> alloy_sol_types::private::LogData {
1715 alloy_sol_types::SolEvent::encode_log_data(this)
1716 }
1717 }
1718 };
1719 #[derive(serde::Serialize, serde::Deserialize)]
1720 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1721 #[allow(
1726 non_camel_case_types,
1727 non_snake_case,
1728 clippy::pub_underscore_fields,
1729 clippy::style
1730 )]
1731 #[derive(Clone)]
1732 pub struct AppointeeSet {
1733 #[allow(missing_docs)]
1734 pub account: alloy::sol_types::private::Address,
1735 #[allow(missing_docs)]
1736 pub appointee: alloy::sol_types::private::Address,
1737 #[allow(missing_docs)]
1738 pub target: alloy::sol_types::private::Address,
1739 #[allow(missing_docs)]
1740 pub selector: alloy::sol_types::private::FixedBytes<4>,
1741 }
1742 #[allow(
1743 non_camel_case_types,
1744 non_snake_case,
1745 clippy::pub_underscore_fields,
1746 clippy::style
1747 )]
1748 const _: () = {
1749 use alloy::sol_types as alloy_sol_types;
1750 #[automatically_derived]
1751 impl alloy_sol_types::SolEvent for AppointeeSet {
1752 type DataTuple<'a> = (
1753 alloy::sol_types::sol_data::Address,
1754 alloy::sol_types::sol_data::FixedBytes<4>,
1755 );
1756 type DataToken<'a> = <Self::DataTuple<
1757 'a,
1758 > as alloy_sol_types::SolType>::Token<'a>;
1759 type TopicList = (
1760 alloy_sol_types::sol_data::FixedBytes<32>,
1761 alloy::sol_types::sol_data::Address,
1762 alloy::sol_types::sol_data::Address,
1763 );
1764 const SIGNATURE: &'static str = "AppointeeSet(address,address,address,bytes4)";
1765 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1766 3u8, 127u8, 3u8, 162u8, 173u8, 107u8, 150u8, 125u8, 244u8, 160u8, 23u8,
1767 121u8, 182u8, 210u8, 180u8, 200u8, 89u8, 80u8, 223u8, 131u8, 146u8, 93u8,
1768 158u8, 49u8, 54u8, 43u8, 81u8, 148u8, 34u8, 252u8, 1u8, 105u8,
1769 ]);
1770 const ANONYMOUS: bool = false;
1771 #[allow(unused_variables)]
1772 #[inline]
1773 fn new(
1774 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1775 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1776 ) -> Self {
1777 Self {
1778 account: topics.1,
1779 appointee: topics.2,
1780 target: data.0,
1781 selector: data.1,
1782 }
1783 }
1784 #[inline]
1785 fn check_signature(
1786 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1787 ) -> alloy_sol_types::Result<()> {
1788 if topics.0 != Self::SIGNATURE_HASH {
1789 return Err(
1790 alloy_sol_types::Error::invalid_event_signature_hash(
1791 Self::SIGNATURE,
1792 topics.0,
1793 Self::SIGNATURE_HASH,
1794 ),
1795 );
1796 }
1797 Ok(())
1798 }
1799 #[inline]
1800 fn tokenize_body(&self) -> Self::DataToken<'_> {
1801 (
1802 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1803 &self.target,
1804 ),
1805 <alloy::sol_types::sol_data::FixedBytes<
1806 4,
1807 > as alloy_sol_types::SolType>::tokenize(&self.selector),
1808 )
1809 }
1810 #[inline]
1811 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1812 (
1813 Self::SIGNATURE_HASH.into(),
1814 self.account.clone(),
1815 self.appointee.clone(),
1816 )
1817 }
1818 #[inline]
1819 fn encode_topics_raw(
1820 &self,
1821 out: &mut [alloy_sol_types::abi::token::WordToken],
1822 ) -> alloy_sol_types::Result<()> {
1823 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1824 return Err(alloy_sol_types::Error::Overrun);
1825 }
1826 out[0usize] = alloy_sol_types::abi::token::WordToken(
1827 Self::SIGNATURE_HASH,
1828 );
1829 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1830 &self.account,
1831 );
1832 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
1833 &self.appointee,
1834 );
1835 Ok(())
1836 }
1837 }
1838 #[automatically_derived]
1839 impl alloy_sol_types::private::IntoLogData for AppointeeSet {
1840 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1841 From::from(self)
1842 }
1843 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1844 From::from(&self)
1845 }
1846 }
1847 #[automatically_derived]
1848 impl From<&AppointeeSet> for alloy_sol_types::private::LogData {
1849 #[inline]
1850 fn from(this: &AppointeeSet) -> alloy_sol_types::private::LogData {
1851 alloy_sol_types::SolEvent::encode_log_data(this)
1852 }
1853 }
1854 };
1855 #[derive(serde::Serialize, serde::Deserialize)]
1856 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1857 #[allow(
1862 non_camel_case_types,
1863 non_snake_case,
1864 clippy::pub_underscore_fields,
1865 clippy::style
1866 )]
1867 #[derive(Clone)]
1868 pub struct Initialized {
1869 #[allow(missing_docs)]
1870 pub version: u8,
1871 }
1872 #[allow(
1873 non_camel_case_types,
1874 non_snake_case,
1875 clippy::pub_underscore_fields,
1876 clippy::style
1877 )]
1878 const _: () = {
1879 use alloy::sol_types as alloy_sol_types;
1880 #[automatically_derived]
1881 impl alloy_sol_types::SolEvent for Initialized {
1882 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<8>,);
1883 type DataToken<'a> = <Self::DataTuple<
1884 'a,
1885 > as alloy_sol_types::SolType>::Token<'a>;
1886 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1887 const SIGNATURE: &'static str = "Initialized(uint8)";
1888 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1889 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
1890 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
1891 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
1892 ]);
1893 const ANONYMOUS: bool = false;
1894 #[allow(unused_variables)]
1895 #[inline]
1896 fn new(
1897 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1898 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1899 ) -> Self {
1900 Self { version: data.0 }
1901 }
1902 #[inline]
1903 fn check_signature(
1904 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1905 ) -> alloy_sol_types::Result<()> {
1906 if topics.0 != Self::SIGNATURE_HASH {
1907 return Err(
1908 alloy_sol_types::Error::invalid_event_signature_hash(
1909 Self::SIGNATURE,
1910 topics.0,
1911 Self::SIGNATURE_HASH,
1912 ),
1913 );
1914 }
1915 Ok(())
1916 }
1917 #[inline]
1918 fn tokenize_body(&self) -> Self::DataToken<'_> {
1919 (
1920 <alloy::sol_types::sol_data::Uint<
1921 8,
1922 > as alloy_sol_types::SolType>::tokenize(&self.version),
1923 )
1924 }
1925 #[inline]
1926 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1927 (Self::SIGNATURE_HASH.into(),)
1928 }
1929 #[inline]
1930 fn encode_topics_raw(
1931 &self,
1932 out: &mut [alloy_sol_types::abi::token::WordToken],
1933 ) -> alloy_sol_types::Result<()> {
1934 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1935 return Err(alloy_sol_types::Error::Overrun);
1936 }
1937 out[0usize] = alloy_sol_types::abi::token::WordToken(
1938 Self::SIGNATURE_HASH,
1939 );
1940 Ok(())
1941 }
1942 }
1943 #[automatically_derived]
1944 impl alloy_sol_types::private::IntoLogData for Initialized {
1945 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1946 From::from(self)
1947 }
1948 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1949 From::from(&self)
1950 }
1951 }
1952 #[automatically_derived]
1953 impl From<&Initialized> for alloy_sol_types::private::LogData {
1954 #[inline]
1955 fn from(this: &Initialized) -> alloy_sol_types::private::LogData {
1956 alloy_sol_types::SolEvent::encode_log_data(this)
1957 }
1958 }
1959 };
1960 #[derive(serde::Serialize, serde::Deserialize)]
1961 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1962 #[allow(
1967 non_camel_case_types,
1968 non_snake_case,
1969 clippy::pub_underscore_fields,
1970 clippy::style
1971 )]
1972 #[derive(Clone)]
1973 pub struct PendingAdminAdded {
1974 #[allow(missing_docs)]
1975 pub account: alloy::sol_types::private::Address,
1976 #[allow(missing_docs)]
1977 pub admin: alloy::sol_types::private::Address,
1978 }
1979 #[allow(
1980 non_camel_case_types,
1981 non_snake_case,
1982 clippy::pub_underscore_fields,
1983 clippy::style
1984 )]
1985 const _: () = {
1986 use alloy::sol_types as alloy_sol_types;
1987 #[automatically_derived]
1988 impl alloy_sol_types::SolEvent for PendingAdminAdded {
1989 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1990 type DataToken<'a> = <Self::DataTuple<
1991 'a,
1992 > as alloy_sol_types::SolType>::Token<'a>;
1993 type TopicList = (
1994 alloy_sol_types::sol_data::FixedBytes<32>,
1995 alloy::sol_types::sol_data::Address,
1996 );
1997 const SIGNATURE: &'static str = "PendingAdminAdded(address,address)";
1998 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1999 177u8, 75u8, 154u8, 61u8, 68u8, 140u8, 91u8, 4u8, 240u8, 229u8, 176u8,
2000 135u8, 182u8, 245u8, 25u8, 51u8, 144u8, 219u8, 121u8, 85u8, 72u8, 42u8,
2001 111u8, 251u8, 132u8, 30u8, 123u8, 59u8, 166u8, 26u8, 70u8, 12u8,
2002 ]);
2003 const ANONYMOUS: bool = false;
2004 #[allow(unused_variables)]
2005 #[inline]
2006 fn new(
2007 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2008 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2009 ) -> Self {
2010 Self {
2011 account: topics.1,
2012 admin: data.0,
2013 }
2014 }
2015 #[inline]
2016 fn check_signature(
2017 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2018 ) -> alloy_sol_types::Result<()> {
2019 if topics.0 != Self::SIGNATURE_HASH {
2020 return Err(
2021 alloy_sol_types::Error::invalid_event_signature_hash(
2022 Self::SIGNATURE,
2023 topics.0,
2024 Self::SIGNATURE_HASH,
2025 ),
2026 );
2027 }
2028 Ok(())
2029 }
2030 #[inline]
2031 fn tokenize_body(&self) -> Self::DataToken<'_> {
2032 (
2033 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2034 &self.admin,
2035 ),
2036 )
2037 }
2038 #[inline]
2039 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2040 (Self::SIGNATURE_HASH.into(), self.account.clone())
2041 }
2042 #[inline]
2043 fn encode_topics_raw(
2044 &self,
2045 out: &mut [alloy_sol_types::abi::token::WordToken],
2046 ) -> alloy_sol_types::Result<()> {
2047 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2048 return Err(alloy_sol_types::Error::Overrun);
2049 }
2050 out[0usize] = alloy_sol_types::abi::token::WordToken(
2051 Self::SIGNATURE_HASH,
2052 );
2053 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2054 &self.account,
2055 );
2056 Ok(())
2057 }
2058 }
2059 #[automatically_derived]
2060 impl alloy_sol_types::private::IntoLogData for PendingAdminAdded {
2061 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2062 From::from(self)
2063 }
2064 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2065 From::from(&self)
2066 }
2067 }
2068 #[automatically_derived]
2069 impl From<&PendingAdminAdded> for alloy_sol_types::private::LogData {
2070 #[inline]
2071 fn from(this: &PendingAdminAdded) -> alloy_sol_types::private::LogData {
2072 alloy_sol_types::SolEvent::encode_log_data(this)
2073 }
2074 }
2075 };
2076 #[derive(serde::Serialize, serde::Deserialize)]
2077 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2078 #[allow(
2083 non_camel_case_types,
2084 non_snake_case,
2085 clippy::pub_underscore_fields,
2086 clippy::style
2087 )]
2088 #[derive(Clone)]
2089 pub struct PendingAdminRemoved {
2090 #[allow(missing_docs)]
2091 pub account: alloy::sol_types::private::Address,
2092 #[allow(missing_docs)]
2093 pub admin: alloy::sol_types::private::Address,
2094 }
2095 #[allow(
2096 non_camel_case_types,
2097 non_snake_case,
2098 clippy::pub_underscore_fields,
2099 clippy::style
2100 )]
2101 const _: () = {
2102 use alloy::sol_types as alloy_sol_types;
2103 #[automatically_derived]
2104 impl alloy_sol_types::SolEvent for PendingAdminRemoved {
2105 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
2106 type DataToken<'a> = <Self::DataTuple<
2107 'a,
2108 > as alloy_sol_types::SolType>::Token<'a>;
2109 type TopicList = (
2110 alloy_sol_types::sol_data::FixedBytes<32>,
2111 alloy::sol_types::sol_data::Address,
2112 );
2113 const SIGNATURE: &'static str = "PendingAdminRemoved(address,address)";
2114 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2115 215u8, 6u8, 237u8, 122u8, 224u8, 68u8, 215u8, 149u8, 180u8, 158u8, 84u8,
2116 201u8, 245u8, 25u8, 246u8, 99u8, 5u8, 57u8, 81u8, 1u8, 25u8, 133u8,
2117 246u8, 99u8, 168u8, 98u8, 205u8, 158u8, 231u8, 42u8, 154u8, 199u8,
2118 ]);
2119 const ANONYMOUS: bool = false;
2120 #[allow(unused_variables)]
2121 #[inline]
2122 fn new(
2123 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2124 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2125 ) -> Self {
2126 Self {
2127 account: topics.1,
2128 admin: data.0,
2129 }
2130 }
2131 #[inline]
2132 fn check_signature(
2133 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2134 ) -> alloy_sol_types::Result<()> {
2135 if topics.0 != Self::SIGNATURE_HASH {
2136 return Err(
2137 alloy_sol_types::Error::invalid_event_signature_hash(
2138 Self::SIGNATURE,
2139 topics.0,
2140 Self::SIGNATURE_HASH,
2141 ),
2142 );
2143 }
2144 Ok(())
2145 }
2146 #[inline]
2147 fn tokenize_body(&self) -> Self::DataToken<'_> {
2148 (
2149 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2150 &self.admin,
2151 ),
2152 )
2153 }
2154 #[inline]
2155 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2156 (Self::SIGNATURE_HASH.into(), self.account.clone())
2157 }
2158 #[inline]
2159 fn encode_topics_raw(
2160 &self,
2161 out: &mut [alloy_sol_types::abi::token::WordToken],
2162 ) -> alloy_sol_types::Result<()> {
2163 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2164 return Err(alloy_sol_types::Error::Overrun);
2165 }
2166 out[0usize] = alloy_sol_types::abi::token::WordToken(
2167 Self::SIGNATURE_HASH,
2168 );
2169 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2170 &self.account,
2171 );
2172 Ok(())
2173 }
2174 }
2175 #[automatically_derived]
2176 impl alloy_sol_types::private::IntoLogData for PendingAdminRemoved {
2177 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2178 From::from(self)
2179 }
2180 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2181 From::from(&self)
2182 }
2183 }
2184 #[automatically_derived]
2185 impl From<&PendingAdminRemoved> for alloy_sol_types::private::LogData {
2186 #[inline]
2187 fn from(this: &PendingAdminRemoved) -> alloy_sol_types::private::LogData {
2188 alloy_sol_types::SolEvent::encode_log_data(this)
2189 }
2190 }
2191 };
2192 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2197 #[derive(Clone)]
2198 pub struct constructorCall {
2199 #[allow(missing_docs)]
2200 pub _version: alloy::sol_types::private::String,
2201 }
2202 const _: () = {
2203 use alloy::sol_types as alloy_sol_types;
2204 {
2205 #[doc(hidden)]
2206 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2207 #[doc(hidden)]
2208 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2209 #[cfg(test)]
2210 #[allow(dead_code, unreachable_patterns)]
2211 fn _type_assertion(
2212 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2213 ) {
2214 match _t {
2215 alloy_sol_types::private::AssertTypeEq::<
2216 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2217 >(_) => {}
2218 }
2219 }
2220 #[automatically_derived]
2221 #[doc(hidden)]
2222 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
2223 fn from(value: constructorCall) -> Self {
2224 (value._version,)
2225 }
2226 }
2227 #[automatically_derived]
2228 #[doc(hidden)]
2229 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
2230 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2231 Self { _version: tuple.0 }
2232 }
2233 }
2234 }
2235 #[automatically_derived]
2236 impl alloy_sol_types::SolConstructor for constructorCall {
2237 type Parameters<'a> = (alloy::sol_types::sol_data::String,);
2238 type Token<'a> = <Self::Parameters<
2239 'a,
2240 > as alloy_sol_types::SolType>::Token<'a>;
2241 #[inline]
2242 fn new<'a>(
2243 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2244 ) -> Self {
2245 tuple.into()
2246 }
2247 #[inline]
2248 fn tokenize(&self) -> Self::Token<'_> {
2249 (
2250 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
2251 &self._version,
2252 ),
2253 )
2254 }
2255 }
2256 };
2257 #[derive(serde::Serialize, serde::Deserialize)]
2258 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2259 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2264 #[derive(Clone)]
2265 pub struct acceptAdminCall {
2266 #[allow(missing_docs)]
2267 pub account: alloy::sol_types::private::Address,
2268 }
2269 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2271 #[derive(Clone)]
2272 pub struct acceptAdminReturn {}
2273 #[allow(
2274 non_camel_case_types,
2275 non_snake_case,
2276 clippy::pub_underscore_fields,
2277 clippy::style
2278 )]
2279 const _: () = {
2280 use alloy::sol_types as alloy_sol_types;
2281 {
2282 #[doc(hidden)]
2283 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2284 #[doc(hidden)]
2285 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2286 #[cfg(test)]
2287 #[allow(dead_code, unreachable_patterns)]
2288 fn _type_assertion(
2289 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2290 ) {
2291 match _t {
2292 alloy_sol_types::private::AssertTypeEq::<
2293 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2294 >(_) => {}
2295 }
2296 }
2297 #[automatically_derived]
2298 #[doc(hidden)]
2299 impl ::core::convert::From<acceptAdminCall> for UnderlyingRustTuple<'_> {
2300 fn from(value: acceptAdminCall) -> Self {
2301 (value.account,)
2302 }
2303 }
2304 #[automatically_derived]
2305 #[doc(hidden)]
2306 impl ::core::convert::From<UnderlyingRustTuple<'_>> for acceptAdminCall {
2307 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2308 Self { account: tuple.0 }
2309 }
2310 }
2311 }
2312 {
2313 #[doc(hidden)]
2314 type UnderlyingSolTuple<'a> = ();
2315 #[doc(hidden)]
2316 type UnderlyingRustTuple<'a> = ();
2317 #[cfg(test)]
2318 #[allow(dead_code, unreachable_patterns)]
2319 fn _type_assertion(
2320 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2321 ) {
2322 match _t {
2323 alloy_sol_types::private::AssertTypeEq::<
2324 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2325 >(_) => {}
2326 }
2327 }
2328 #[automatically_derived]
2329 #[doc(hidden)]
2330 impl ::core::convert::From<acceptAdminReturn> for UnderlyingRustTuple<'_> {
2331 fn from(value: acceptAdminReturn) -> Self {
2332 ()
2333 }
2334 }
2335 #[automatically_derived]
2336 #[doc(hidden)]
2337 impl ::core::convert::From<UnderlyingRustTuple<'_>> for acceptAdminReturn {
2338 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2339 Self {}
2340 }
2341 }
2342 }
2343 impl acceptAdminReturn {
2344 fn _tokenize(
2345 &self,
2346 ) -> <acceptAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2347 ()
2348 }
2349 }
2350 #[automatically_derived]
2351 impl alloy_sol_types::SolCall for acceptAdminCall {
2352 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2353 type Token<'a> = <Self::Parameters<
2354 'a,
2355 > as alloy_sol_types::SolType>::Token<'a>;
2356 type Return = acceptAdminReturn;
2357 type ReturnTuple<'a> = ();
2358 type ReturnToken<'a> = <Self::ReturnTuple<
2359 'a,
2360 > as alloy_sol_types::SolType>::Token<'a>;
2361 const SIGNATURE: &'static str = "acceptAdmin(address)";
2362 const SELECTOR: [u8; 4] = [98u8, 136u8, 6u8, 239u8];
2363 #[inline]
2364 fn new<'a>(
2365 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2366 ) -> Self {
2367 tuple.into()
2368 }
2369 #[inline]
2370 fn tokenize(&self) -> Self::Token<'_> {
2371 (
2372 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2373 &self.account,
2374 ),
2375 )
2376 }
2377 #[inline]
2378 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2379 acceptAdminReturn::_tokenize(ret)
2380 }
2381 #[inline]
2382 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2383 <Self::ReturnTuple<
2384 '_,
2385 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2386 .map(Into::into)
2387 }
2388 #[inline]
2389 fn abi_decode_returns_validate(
2390 data: &[u8],
2391 ) -> alloy_sol_types::Result<Self::Return> {
2392 <Self::ReturnTuple<
2393 '_,
2394 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2395 .map(Into::into)
2396 }
2397 }
2398 };
2399 #[derive(serde::Serialize, serde::Deserialize)]
2400 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2401 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2406 #[derive(Clone)]
2407 pub struct addPendingAdminCall {
2408 #[allow(missing_docs)]
2409 pub account: alloy::sol_types::private::Address,
2410 #[allow(missing_docs)]
2411 pub admin: alloy::sol_types::private::Address,
2412 }
2413 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2415 #[derive(Clone)]
2416 pub struct addPendingAdminReturn {}
2417 #[allow(
2418 non_camel_case_types,
2419 non_snake_case,
2420 clippy::pub_underscore_fields,
2421 clippy::style
2422 )]
2423 const _: () = {
2424 use alloy::sol_types as alloy_sol_types;
2425 {
2426 #[doc(hidden)]
2427 type UnderlyingSolTuple<'a> = (
2428 alloy::sol_types::sol_data::Address,
2429 alloy::sol_types::sol_data::Address,
2430 );
2431 #[doc(hidden)]
2432 type UnderlyingRustTuple<'a> = (
2433 alloy::sol_types::private::Address,
2434 alloy::sol_types::private::Address,
2435 );
2436 #[cfg(test)]
2437 #[allow(dead_code, unreachable_patterns)]
2438 fn _type_assertion(
2439 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2440 ) {
2441 match _t {
2442 alloy_sol_types::private::AssertTypeEq::<
2443 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2444 >(_) => {}
2445 }
2446 }
2447 #[automatically_derived]
2448 #[doc(hidden)]
2449 impl ::core::convert::From<addPendingAdminCall> for UnderlyingRustTuple<'_> {
2450 fn from(value: addPendingAdminCall) -> Self {
2451 (value.account, value.admin)
2452 }
2453 }
2454 #[automatically_derived]
2455 #[doc(hidden)]
2456 impl ::core::convert::From<UnderlyingRustTuple<'_>> for addPendingAdminCall {
2457 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2458 Self {
2459 account: tuple.0,
2460 admin: tuple.1,
2461 }
2462 }
2463 }
2464 }
2465 {
2466 #[doc(hidden)]
2467 type UnderlyingSolTuple<'a> = ();
2468 #[doc(hidden)]
2469 type UnderlyingRustTuple<'a> = ();
2470 #[cfg(test)]
2471 #[allow(dead_code, unreachable_patterns)]
2472 fn _type_assertion(
2473 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2474 ) {
2475 match _t {
2476 alloy_sol_types::private::AssertTypeEq::<
2477 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2478 >(_) => {}
2479 }
2480 }
2481 #[automatically_derived]
2482 #[doc(hidden)]
2483 impl ::core::convert::From<addPendingAdminReturn>
2484 for UnderlyingRustTuple<'_> {
2485 fn from(value: addPendingAdminReturn) -> Self {
2486 ()
2487 }
2488 }
2489 #[automatically_derived]
2490 #[doc(hidden)]
2491 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2492 for addPendingAdminReturn {
2493 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2494 Self {}
2495 }
2496 }
2497 }
2498 impl addPendingAdminReturn {
2499 fn _tokenize(
2500 &self,
2501 ) -> <addPendingAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2502 ()
2503 }
2504 }
2505 #[automatically_derived]
2506 impl alloy_sol_types::SolCall for addPendingAdminCall {
2507 type Parameters<'a> = (
2508 alloy::sol_types::sol_data::Address,
2509 alloy::sol_types::sol_data::Address,
2510 );
2511 type Token<'a> = <Self::Parameters<
2512 'a,
2513 > as alloy_sol_types::SolType>::Token<'a>;
2514 type Return = addPendingAdminReturn;
2515 type ReturnTuple<'a> = ();
2516 type ReturnToken<'a> = <Self::ReturnTuple<
2517 'a,
2518 > as alloy_sol_types::SolType>::Token<'a>;
2519 const SIGNATURE: &'static str = "addPendingAdmin(address,address)";
2520 const SELECTOR: [u8; 4] = [235u8, 90u8, 78u8, 135u8];
2521 #[inline]
2522 fn new<'a>(
2523 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2524 ) -> Self {
2525 tuple.into()
2526 }
2527 #[inline]
2528 fn tokenize(&self) -> Self::Token<'_> {
2529 (
2530 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2531 &self.account,
2532 ),
2533 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2534 &self.admin,
2535 ),
2536 )
2537 }
2538 #[inline]
2539 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2540 addPendingAdminReturn::_tokenize(ret)
2541 }
2542 #[inline]
2543 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2544 <Self::ReturnTuple<
2545 '_,
2546 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2547 .map(Into::into)
2548 }
2549 #[inline]
2550 fn abi_decode_returns_validate(
2551 data: &[u8],
2552 ) -> alloy_sol_types::Result<Self::Return> {
2553 <Self::ReturnTuple<
2554 '_,
2555 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2556 .map(Into::into)
2557 }
2558 }
2559 };
2560 #[derive(serde::Serialize, serde::Deserialize)]
2561 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2562 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2567 #[derive(Clone)]
2568 pub struct canCallCall {
2569 #[allow(missing_docs)]
2570 pub account: alloy::sol_types::private::Address,
2571 #[allow(missing_docs)]
2572 pub caller: alloy::sol_types::private::Address,
2573 #[allow(missing_docs)]
2574 pub target: alloy::sol_types::private::Address,
2575 #[allow(missing_docs)]
2576 pub selector: alloy::sol_types::private::FixedBytes<4>,
2577 }
2578 #[derive(serde::Serialize, serde::Deserialize)]
2579 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2580 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2582 #[derive(Clone)]
2583 pub struct canCallReturn {
2584 #[allow(missing_docs)]
2585 pub _0: bool,
2586 }
2587 #[allow(
2588 non_camel_case_types,
2589 non_snake_case,
2590 clippy::pub_underscore_fields,
2591 clippy::style
2592 )]
2593 const _: () = {
2594 use alloy::sol_types as alloy_sol_types;
2595 {
2596 #[doc(hidden)]
2597 type UnderlyingSolTuple<'a> = (
2598 alloy::sol_types::sol_data::Address,
2599 alloy::sol_types::sol_data::Address,
2600 alloy::sol_types::sol_data::Address,
2601 alloy::sol_types::sol_data::FixedBytes<4>,
2602 );
2603 #[doc(hidden)]
2604 type UnderlyingRustTuple<'a> = (
2605 alloy::sol_types::private::Address,
2606 alloy::sol_types::private::Address,
2607 alloy::sol_types::private::Address,
2608 alloy::sol_types::private::FixedBytes<4>,
2609 );
2610 #[cfg(test)]
2611 #[allow(dead_code, unreachable_patterns)]
2612 fn _type_assertion(
2613 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2614 ) {
2615 match _t {
2616 alloy_sol_types::private::AssertTypeEq::<
2617 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2618 >(_) => {}
2619 }
2620 }
2621 #[automatically_derived]
2622 #[doc(hidden)]
2623 impl ::core::convert::From<canCallCall> for UnderlyingRustTuple<'_> {
2624 fn from(value: canCallCall) -> Self {
2625 (value.account, value.caller, value.target, value.selector)
2626 }
2627 }
2628 #[automatically_derived]
2629 #[doc(hidden)]
2630 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canCallCall {
2631 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2632 Self {
2633 account: tuple.0,
2634 caller: tuple.1,
2635 target: tuple.2,
2636 selector: tuple.3,
2637 }
2638 }
2639 }
2640 }
2641 {
2642 #[doc(hidden)]
2643 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2644 #[doc(hidden)]
2645 type UnderlyingRustTuple<'a> = (bool,);
2646 #[cfg(test)]
2647 #[allow(dead_code, unreachable_patterns)]
2648 fn _type_assertion(
2649 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2650 ) {
2651 match _t {
2652 alloy_sol_types::private::AssertTypeEq::<
2653 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2654 >(_) => {}
2655 }
2656 }
2657 #[automatically_derived]
2658 #[doc(hidden)]
2659 impl ::core::convert::From<canCallReturn> for UnderlyingRustTuple<'_> {
2660 fn from(value: canCallReturn) -> Self {
2661 (value._0,)
2662 }
2663 }
2664 #[automatically_derived]
2665 #[doc(hidden)]
2666 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canCallReturn {
2667 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2668 Self { _0: tuple.0 }
2669 }
2670 }
2671 }
2672 #[automatically_derived]
2673 impl alloy_sol_types::SolCall for canCallCall {
2674 type Parameters<'a> = (
2675 alloy::sol_types::sol_data::Address,
2676 alloy::sol_types::sol_data::Address,
2677 alloy::sol_types::sol_data::Address,
2678 alloy::sol_types::sol_data::FixedBytes<4>,
2679 );
2680 type Token<'a> = <Self::Parameters<
2681 'a,
2682 > as alloy_sol_types::SolType>::Token<'a>;
2683 type Return = bool;
2684 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2685 type ReturnToken<'a> = <Self::ReturnTuple<
2686 'a,
2687 > as alloy_sol_types::SolType>::Token<'a>;
2688 const SIGNATURE: &'static str = "canCall(address,address,address,bytes4)";
2689 const SELECTOR: [u8; 4] = [223u8, 89u8, 92u8, 184u8];
2690 #[inline]
2691 fn new<'a>(
2692 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2693 ) -> Self {
2694 tuple.into()
2695 }
2696 #[inline]
2697 fn tokenize(&self) -> Self::Token<'_> {
2698 (
2699 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2700 &self.account,
2701 ),
2702 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2703 &self.caller,
2704 ),
2705 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2706 &self.target,
2707 ),
2708 <alloy::sol_types::sol_data::FixedBytes<
2709 4,
2710 > as alloy_sol_types::SolType>::tokenize(&self.selector),
2711 )
2712 }
2713 #[inline]
2714 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2715 (
2716 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
2717 ret,
2718 ),
2719 )
2720 }
2721 #[inline]
2722 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2723 <Self::ReturnTuple<
2724 '_,
2725 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2726 .map(|r| {
2727 let r: canCallReturn = r.into();
2728 r._0
2729 })
2730 }
2731 #[inline]
2732 fn abi_decode_returns_validate(
2733 data: &[u8],
2734 ) -> alloy_sol_types::Result<Self::Return> {
2735 <Self::ReturnTuple<
2736 '_,
2737 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2738 .map(|r| {
2739 let r: canCallReturn = r.into();
2740 r._0
2741 })
2742 }
2743 }
2744 };
2745 #[derive(serde::Serialize, serde::Deserialize)]
2746 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2747 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2752 #[derive(Clone)]
2753 pub struct getAdminsCall {
2754 #[allow(missing_docs)]
2755 pub account: alloy::sol_types::private::Address,
2756 }
2757 #[derive(serde::Serialize, serde::Deserialize)]
2758 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2759 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2761 #[derive(Clone)]
2762 pub struct getAdminsReturn {
2763 #[allow(missing_docs)]
2764 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2765 }
2766 #[allow(
2767 non_camel_case_types,
2768 non_snake_case,
2769 clippy::pub_underscore_fields,
2770 clippy::style
2771 )]
2772 const _: () = {
2773 use alloy::sol_types as alloy_sol_types;
2774 {
2775 #[doc(hidden)]
2776 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2777 #[doc(hidden)]
2778 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2779 #[cfg(test)]
2780 #[allow(dead_code, unreachable_patterns)]
2781 fn _type_assertion(
2782 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2783 ) {
2784 match _t {
2785 alloy_sol_types::private::AssertTypeEq::<
2786 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2787 >(_) => {}
2788 }
2789 }
2790 #[automatically_derived]
2791 #[doc(hidden)]
2792 impl ::core::convert::From<getAdminsCall> for UnderlyingRustTuple<'_> {
2793 fn from(value: getAdminsCall) -> Self {
2794 (value.account,)
2795 }
2796 }
2797 #[automatically_derived]
2798 #[doc(hidden)]
2799 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAdminsCall {
2800 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2801 Self { account: tuple.0 }
2802 }
2803 }
2804 }
2805 {
2806 #[doc(hidden)]
2807 type UnderlyingSolTuple<'a> = (
2808 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2809 );
2810 #[doc(hidden)]
2811 type UnderlyingRustTuple<'a> = (
2812 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2813 );
2814 #[cfg(test)]
2815 #[allow(dead_code, unreachable_patterns)]
2816 fn _type_assertion(
2817 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2818 ) {
2819 match _t {
2820 alloy_sol_types::private::AssertTypeEq::<
2821 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2822 >(_) => {}
2823 }
2824 }
2825 #[automatically_derived]
2826 #[doc(hidden)]
2827 impl ::core::convert::From<getAdminsReturn> for UnderlyingRustTuple<'_> {
2828 fn from(value: getAdminsReturn) -> Self {
2829 (value._0,)
2830 }
2831 }
2832 #[automatically_derived]
2833 #[doc(hidden)]
2834 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAdminsReturn {
2835 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2836 Self { _0: tuple.0 }
2837 }
2838 }
2839 }
2840 #[automatically_derived]
2841 impl alloy_sol_types::SolCall for getAdminsCall {
2842 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2843 type Token<'a> = <Self::Parameters<
2844 'a,
2845 > as alloy_sol_types::SolType>::Token<'a>;
2846 type Return = alloy::sol_types::private::Vec<
2847 alloy::sol_types::private::Address,
2848 >;
2849 type ReturnTuple<'a> = (
2850 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2851 );
2852 type ReturnToken<'a> = <Self::ReturnTuple<
2853 'a,
2854 > as alloy_sol_types::SolType>::Token<'a>;
2855 const SIGNATURE: &'static str = "getAdmins(address)";
2856 const SELECTOR: [u8; 4] = [173u8, 95u8, 34u8, 16u8];
2857 #[inline]
2858 fn new<'a>(
2859 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2860 ) -> Self {
2861 tuple.into()
2862 }
2863 #[inline]
2864 fn tokenize(&self) -> Self::Token<'_> {
2865 (
2866 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2867 &self.account,
2868 ),
2869 )
2870 }
2871 #[inline]
2872 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2873 (
2874 <alloy::sol_types::sol_data::Array<
2875 alloy::sol_types::sol_data::Address,
2876 > as alloy_sol_types::SolType>::tokenize(ret),
2877 )
2878 }
2879 #[inline]
2880 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2881 <Self::ReturnTuple<
2882 '_,
2883 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2884 .map(|r| {
2885 let r: getAdminsReturn = r.into();
2886 r._0
2887 })
2888 }
2889 #[inline]
2890 fn abi_decode_returns_validate(
2891 data: &[u8],
2892 ) -> alloy_sol_types::Result<Self::Return> {
2893 <Self::ReturnTuple<
2894 '_,
2895 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2896 .map(|r| {
2897 let r: getAdminsReturn = r.into();
2898 r._0
2899 })
2900 }
2901 }
2902 };
2903 #[derive(serde::Serialize, serde::Deserialize)]
2904 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2905 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2910 #[derive(Clone)]
2911 pub struct getAppointeePermissionsCall {
2912 #[allow(missing_docs)]
2913 pub account: alloy::sol_types::private::Address,
2914 #[allow(missing_docs)]
2915 pub appointee: alloy::sol_types::private::Address,
2916 }
2917 #[derive(serde::Serialize, serde::Deserialize)]
2918 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2919 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2921 #[derive(Clone)]
2922 pub struct getAppointeePermissionsReturn {
2923 #[allow(missing_docs)]
2924 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2925 #[allow(missing_docs)]
2926 pub _1: alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<4>>,
2927 }
2928 #[allow(
2929 non_camel_case_types,
2930 non_snake_case,
2931 clippy::pub_underscore_fields,
2932 clippy::style
2933 )]
2934 const _: () = {
2935 use alloy::sol_types as alloy_sol_types;
2936 {
2937 #[doc(hidden)]
2938 type UnderlyingSolTuple<'a> = (
2939 alloy::sol_types::sol_data::Address,
2940 alloy::sol_types::sol_data::Address,
2941 );
2942 #[doc(hidden)]
2943 type UnderlyingRustTuple<'a> = (
2944 alloy::sol_types::private::Address,
2945 alloy::sol_types::private::Address,
2946 );
2947 #[cfg(test)]
2948 #[allow(dead_code, unreachable_patterns)]
2949 fn _type_assertion(
2950 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2951 ) {
2952 match _t {
2953 alloy_sol_types::private::AssertTypeEq::<
2954 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2955 >(_) => {}
2956 }
2957 }
2958 #[automatically_derived]
2959 #[doc(hidden)]
2960 impl ::core::convert::From<getAppointeePermissionsCall>
2961 for UnderlyingRustTuple<'_> {
2962 fn from(value: getAppointeePermissionsCall) -> Self {
2963 (value.account, value.appointee)
2964 }
2965 }
2966 #[automatically_derived]
2967 #[doc(hidden)]
2968 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2969 for getAppointeePermissionsCall {
2970 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2971 Self {
2972 account: tuple.0,
2973 appointee: tuple.1,
2974 }
2975 }
2976 }
2977 }
2978 {
2979 #[doc(hidden)]
2980 type UnderlyingSolTuple<'a> = (
2981 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
2982 alloy::sol_types::sol_data::Array<
2983 alloy::sol_types::sol_data::FixedBytes<4>,
2984 >,
2985 );
2986 #[doc(hidden)]
2987 type UnderlyingRustTuple<'a> = (
2988 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
2989 alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<4>>,
2990 );
2991 #[cfg(test)]
2992 #[allow(dead_code, unreachable_patterns)]
2993 fn _type_assertion(
2994 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2995 ) {
2996 match _t {
2997 alloy_sol_types::private::AssertTypeEq::<
2998 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2999 >(_) => {}
3000 }
3001 }
3002 #[automatically_derived]
3003 #[doc(hidden)]
3004 impl ::core::convert::From<getAppointeePermissionsReturn>
3005 for UnderlyingRustTuple<'_> {
3006 fn from(value: getAppointeePermissionsReturn) -> Self {
3007 (value._0, value._1)
3008 }
3009 }
3010 #[automatically_derived]
3011 #[doc(hidden)]
3012 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3013 for getAppointeePermissionsReturn {
3014 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3015 Self { _0: tuple.0, _1: tuple.1 }
3016 }
3017 }
3018 }
3019 impl getAppointeePermissionsReturn {
3020 fn _tokenize(
3021 &self,
3022 ) -> <getAppointeePermissionsCall as alloy_sol_types::SolCall>::ReturnToken<
3023 '_,
3024 > {
3025 (
3026 <alloy::sol_types::sol_data::Array<
3027 alloy::sol_types::sol_data::Address,
3028 > as alloy_sol_types::SolType>::tokenize(&self._0),
3029 <alloy::sol_types::sol_data::Array<
3030 alloy::sol_types::sol_data::FixedBytes<4>,
3031 > as alloy_sol_types::SolType>::tokenize(&self._1),
3032 )
3033 }
3034 }
3035 #[automatically_derived]
3036 impl alloy_sol_types::SolCall for getAppointeePermissionsCall {
3037 type Parameters<'a> = (
3038 alloy::sol_types::sol_data::Address,
3039 alloy::sol_types::sol_data::Address,
3040 );
3041 type Token<'a> = <Self::Parameters<
3042 'a,
3043 > as alloy_sol_types::SolType>::Token<'a>;
3044 type Return = getAppointeePermissionsReturn;
3045 type ReturnTuple<'a> = (
3046 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3047 alloy::sol_types::sol_data::Array<
3048 alloy::sol_types::sol_data::FixedBytes<4>,
3049 >,
3050 );
3051 type ReturnToken<'a> = <Self::ReturnTuple<
3052 'a,
3053 > as alloy_sol_types::SolType>::Token<'a>;
3054 const SIGNATURE: &'static str = "getAppointeePermissions(address,address)";
3055 const SELECTOR: [u8; 4] = [136u8, 42u8, 59u8, 56u8];
3056 #[inline]
3057 fn new<'a>(
3058 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3059 ) -> Self {
3060 tuple.into()
3061 }
3062 #[inline]
3063 fn tokenize(&self) -> Self::Token<'_> {
3064 (
3065 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3066 &self.account,
3067 ),
3068 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3069 &self.appointee,
3070 ),
3071 )
3072 }
3073 #[inline]
3074 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3075 getAppointeePermissionsReturn::_tokenize(ret)
3076 }
3077 #[inline]
3078 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3079 <Self::ReturnTuple<
3080 '_,
3081 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3082 .map(Into::into)
3083 }
3084 #[inline]
3085 fn abi_decode_returns_validate(
3086 data: &[u8],
3087 ) -> alloy_sol_types::Result<Self::Return> {
3088 <Self::ReturnTuple<
3089 '_,
3090 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3091 .map(Into::into)
3092 }
3093 }
3094 };
3095 #[derive(serde::Serialize, serde::Deserialize)]
3096 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3097 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3102 #[derive(Clone)]
3103 pub struct getAppointeesCall {
3104 #[allow(missing_docs)]
3105 pub account: alloy::sol_types::private::Address,
3106 #[allow(missing_docs)]
3107 pub target: alloy::sol_types::private::Address,
3108 #[allow(missing_docs)]
3109 pub selector: alloy::sol_types::private::FixedBytes<4>,
3110 }
3111 #[derive(serde::Serialize, serde::Deserialize)]
3112 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3113 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3115 #[derive(Clone)]
3116 pub struct getAppointeesReturn {
3117 #[allow(missing_docs)]
3118 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3119 }
3120 #[allow(
3121 non_camel_case_types,
3122 non_snake_case,
3123 clippy::pub_underscore_fields,
3124 clippy::style
3125 )]
3126 const _: () = {
3127 use alloy::sol_types as alloy_sol_types;
3128 {
3129 #[doc(hidden)]
3130 type UnderlyingSolTuple<'a> = (
3131 alloy::sol_types::sol_data::Address,
3132 alloy::sol_types::sol_data::Address,
3133 alloy::sol_types::sol_data::FixedBytes<4>,
3134 );
3135 #[doc(hidden)]
3136 type UnderlyingRustTuple<'a> = (
3137 alloy::sol_types::private::Address,
3138 alloy::sol_types::private::Address,
3139 alloy::sol_types::private::FixedBytes<4>,
3140 );
3141 #[cfg(test)]
3142 #[allow(dead_code, unreachable_patterns)]
3143 fn _type_assertion(
3144 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3145 ) {
3146 match _t {
3147 alloy_sol_types::private::AssertTypeEq::<
3148 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3149 >(_) => {}
3150 }
3151 }
3152 #[automatically_derived]
3153 #[doc(hidden)]
3154 impl ::core::convert::From<getAppointeesCall> for UnderlyingRustTuple<'_> {
3155 fn from(value: getAppointeesCall) -> Self {
3156 (value.account, value.target, value.selector)
3157 }
3158 }
3159 #[automatically_derived]
3160 #[doc(hidden)]
3161 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAppointeesCall {
3162 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3163 Self {
3164 account: tuple.0,
3165 target: tuple.1,
3166 selector: tuple.2,
3167 }
3168 }
3169 }
3170 }
3171 {
3172 #[doc(hidden)]
3173 type UnderlyingSolTuple<'a> = (
3174 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3175 );
3176 #[doc(hidden)]
3177 type UnderlyingRustTuple<'a> = (
3178 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3179 );
3180 #[cfg(test)]
3181 #[allow(dead_code, unreachable_patterns)]
3182 fn _type_assertion(
3183 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3184 ) {
3185 match _t {
3186 alloy_sol_types::private::AssertTypeEq::<
3187 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3188 >(_) => {}
3189 }
3190 }
3191 #[automatically_derived]
3192 #[doc(hidden)]
3193 impl ::core::convert::From<getAppointeesReturn> for UnderlyingRustTuple<'_> {
3194 fn from(value: getAppointeesReturn) -> Self {
3195 (value._0,)
3196 }
3197 }
3198 #[automatically_derived]
3199 #[doc(hidden)]
3200 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getAppointeesReturn {
3201 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3202 Self { _0: tuple.0 }
3203 }
3204 }
3205 }
3206 #[automatically_derived]
3207 impl alloy_sol_types::SolCall for getAppointeesCall {
3208 type Parameters<'a> = (
3209 alloy::sol_types::sol_data::Address,
3210 alloy::sol_types::sol_data::Address,
3211 alloy::sol_types::sol_data::FixedBytes<4>,
3212 );
3213 type Token<'a> = <Self::Parameters<
3214 'a,
3215 > as alloy_sol_types::SolType>::Token<'a>;
3216 type Return = alloy::sol_types::private::Vec<
3217 alloy::sol_types::private::Address,
3218 >;
3219 type ReturnTuple<'a> = (
3220 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3221 );
3222 type ReturnToken<'a> = <Self::ReturnTuple<
3223 'a,
3224 > as alloy_sol_types::SolType>::Token<'a>;
3225 const SIGNATURE: &'static str = "getAppointees(address,address,bytes4)";
3226 const SELECTOR: [u8; 4] = [253u8, 219u8, 222u8, 253u8];
3227 #[inline]
3228 fn new<'a>(
3229 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3230 ) -> Self {
3231 tuple.into()
3232 }
3233 #[inline]
3234 fn tokenize(&self) -> Self::Token<'_> {
3235 (
3236 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3237 &self.account,
3238 ),
3239 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3240 &self.target,
3241 ),
3242 <alloy::sol_types::sol_data::FixedBytes<
3243 4,
3244 > as alloy_sol_types::SolType>::tokenize(&self.selector),
3245 )
3246 }
3247 #[inline]
3248 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3249 (
3250 <alloy::sol_types::sol_data::Array<
3251 alloy::sol_types::sol_data::Address,
3252 > as alloy_sol_types::SolType>::tokenize(ret),
3253 )
3254 }
3255 #[inline]
3256 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3257 <Self::ReturnTuple<
3258 '_,
3259 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3260 .map(|r| {
3261 let r: getAppointeesReturn = r.into();
3262 r._0
3263 })
3264 }
3265 #[inline]
3266 fn abi_decode_returns_validate(
3267 data: &[u8],
3268 ) -> alloy_sol_types::Result<Self::Return> {
3269 <Self::ReturnTuple<
3270 '_,
3271 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3272 .map(|r| {
3273 let r: getAppointeesReturn = r.into();
3274 r._0
3275 })
3276 }
3277 }
3278 };
3279 #[derive(serde::Serialize, serde::Deserialize)]
3280 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3281 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3286 #[derive(Clone)]
3287 pub struct getPendingAdminsCall {
3288 #[allow(missing_docs)]
3289 pub account: alloy::sol_types::private::Address,
3290 }
3291 #[derive(serde::Serialize, serde::Deserialize)]
3292 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3293 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3295 #[derive(Clone)]
3296 pub struct getPendingAdminsReturn {
3297 #[allow(missing_docs)]
3298 pub _0: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3299 }
3300 #[allow(
3301 non_camel_case_types,
3302 non_snake_case,
3303 clippy::pub_underscore_fields,
3304 clippy::style
3305 )]
3306 const _: () = {
3307 use alloy::sol_types as alloy_sol_types;
3308 {
3309 #[doc(hidden)]
3310 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
3311 #[doc(hidden)]
3312 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
3313 #[cfg(test)]
3314 #[allow(dead_code, unreachable_patterns)]
3315 fn _type_assertion(
3316 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3317 ) {
3318 match _t {
3319 alloy_sol_types::private::AssertTypeEq::<
3320 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3321 >(_) => {}
3322 }
3323 }
3324 #[automatically_derived]
3325 #[doc(hidden)]
3326 impl ::core::convert::From<getPendingAdminsCall>
3327 for UnderlyingRustTuple<'_> {
3328 fn from(value: getPendingAdminsCall) -> Self {
3329 (value.account,)
3330 }
3331 }
3332 #[automatically_derived]
3333 #[doc(hidden)]
3334 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3335 for getPendingAdminsCall {
3336 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3337 Self { account: tuple.0 }
3338 }
3339 }
3340 }
3341 {
3342 #[doc(hidden)]
3343 type UnderlyingSolTuple<'a> = (
3344 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3345 );
3346 #[doc(hidden)]
3347 type UnderlyingRustTuple<'a> = (
3348 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3349 );
3350 #[cfg(test)]
3351 #[allow(dead_code, unreachable_patterns)]
3352 fn _type_assertion(
3353 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3354 ) {
3355 match _t {
3356 alloy_sol_types::private::AssertTypeEq::<
3357 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3358 >(_) => {}
3359 }
3360 }
3361 #[automatically_derived]
3362 #[doc(hidden)]
3363 impl ::core::convert::From<getPendingAdminsReturn>
3364 for UnderlyingRustTuple<'_> {
3365 fn from(value: getPendingAdminsReturn) -> Self {
3366 (value._0,)
3367 }
3368 }
3369 #[automatically_derived]
3370 #[doc(hidden)]
3371 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3372 for getPendingAdminsReturn {
3373 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3374 Self { _0: tuple.0 }
3375 }
3376 }
3377 }
3378 #[automatically_derived]
3379 impl alloy_sol_types::SolCall for getPendingAdminsCall {
3380 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
3381 type Token<'a> = <Self::Parameters<
3382 'a,
3383 > as alloy_sol_types::SolType>::Token<'a>;
3384 type Return = alloy::sol_types::private::Vec<
3385 alloy::sol_types::private::Address,
3386 >;
3387 type ReturnTuple<'a> = (
3388 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
3389 );
3390 type ReturnToken<'a> = <Self::ReturnTuple<
3391 'a,
3392 > as alloy_sol_types::SolType>::Token<'a>;
3393 const SIGNATURE: &'static str = "getPendingAdmins(address)";
3394 const SELECTOR: [u8; 4] = [107u8, 221u8, 250u8, 31u8];
3395 #[inline]
3396 fn new<'a>(
3397 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3398 ) -> Self {
3399 tuple.into()
3400 }
3401 #[inline]
3402 fn tokenize(&self) -> Self::Token<'_> {
3403 (
3404 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3405 &self.account,
3406 ),
3407 )
3408 }
3409 #[inline]
3410 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3411 (
3412 <alloy::sol_types::sol_data::Array<
3413 alloy::sol_types::sol_data::Address,
3414 > as alloy_sol_types::SolType>::tokenize(ret),
3415 )
3416 }
3417 #[inline]
3418 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3419 <Self::ReturnTuple<
3420 '_,
3421 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3422 .map(|r| {
3423 let r: getPendingAdminsReturn = r.into();
3424 r._0
3425 })
3426 }
3427 #[inline]
3428 fn abi_decode_returns_validate(
3429 data: &[u8],
3430 ) -> alloy_sol_types::Result<Self::Return> {
3431 <Self::ReturnTuple<
3432 '_,
3433 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3434 .map(|r| {
3435 let r: getPendingAdminsReturn = r.into();
3436 r._0
3437 })
3438 }
3439 }
3440 };
3441 #[derive(serde::Serialize, serde::Deserialize)]
3442 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3443 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3448 #[derive(Clone)]
3449 pub struct isAdminCall {
3450 #[allow(missing_docs)]
3451 pub account: alloy::sol_types::private::Address,
3452 #[allow(missing_docs)]
3453 pub caller: alloy::sol_types::private::Address,
3454 }
3455 #[derive(serde::Serialize, serde::Deserialize)]
3456 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3457 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3459 #[derive(Clone)]
3460 pub struct isAdminReturn {
3461 #[allow(missing_docs)]
3462 pub _0: bool,
3463 }
3464 #[allow(
3465 non_camel_case_types,
3466 non_snake_case,
3467 clippy::pub_underscore_fields,
3468 clippy::style
3469 )]
3470 const _: () = {
3471 use alloy::sol_types as alloy_sol_types;
3472 {
3473 #[doc(hidden)]
3474 type UnderlyingSolTuple<'a> = (
3475 alloy::sol_types::sol_data::Address,
3476 alloy::sol_types::sol_data::Address,
3477 );
3478 #[doc(hidden)]
3479 type UnderlyingRustTuple<'a> = (
3480 alloy::sol_types::private::Address,
3481 alloy::sol_types::private::Address,
3482 );
3483 #[cfg(test)]
3484 #[allow(dead_code, unreachable_patterns)]
3485 fn _type_assertion(
3486 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3487 ) {
3488 match _t {
3489 alloy_sol_types::private::AssertTypeEq::<
3490 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3491 >(_) => {}
3492 }
3493 }
3494 #[automatically_derived]
3495 #[doc(hidden)]
3496 impl ::core::convert::From<isAdminCall> for UnderlyingRustTuple<'_> {
3497 fn from(value: isAdminCall) -> Self {
3498 (value.account, value.caller)
3499 }
3500 }
3501 #[automatically_derived]
3502 #[doc(hidden)]
3503 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isAdminCall {
3504 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3505 Self {
3506 account: tuple.0,
3507 caller: tuple.1,
3508 }
3509 }
3510 }
3511 }
3512 {
3513 #[doc(hidden)]
3514 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3515 #[doc(hidden)]
3516 type UnderlyingRustTuple<'a> = (bool,);
3517 #[cfg(test)]
3518 #[allow(dead_code, unreachable_patterns)]
3519 fn _type_assertion(
3520 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3521 ) {
3522 match _t {
3523 alloy_sol_types::private::AssertTypeEq::<
3524 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3525 >(_) => {}
3526 }
3527 }
3528 #[automatically_derived]
3529 #[doc(hidden)]
3530 impl ::core::convert::From<isAdminReturn> for UnderlyingRustTuple<'_> {
3531 fn from(value: isAdminReturn) -> Self {
3532 (value._0,)
3533 }
3534 }
3535 #[automatically_derived]
3536 #[doc(hidden)]
3537 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isAdminReturn {
3538 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3539 Self { _0: tuple.0 }
3540 }
3541 }
3542 }
3543 #[automatically_derived]
3544 impl alloy_sol_types::SolCall for isAdminCall {
3545 type Parameters<'a> = (
3546 alloy::sol_types::sol_data::Address,
3547 alloy::sol_types::sol_data::Address,
3548 );
3549 type Token<'a> = <Self::Parameters<
3550 'a,
3551 > as alloy_sol_types::SolType>::Token<'a>;
3552 type Return = bool;
3553 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3554 type ReturnToken<'a> = <Self::ReturnTuple<
3555 'a,
3556 > as alloy_sol_types::SolType>::Token<'a>;
3557 const SIGNATURE: &'static str = "isAdmin(address,address)";
3558 const SELECTOR: [u8; 4] = [145u8, 0u8, 103u8, 69u8];
3559 #[inline]
3560 fn new<'a>(
3561 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3562 ) -> Self {
3563 tuple.into()
3564 }
3565 #[inline]
3566 fn tokenize(&self) -> Self::Token<'_> {
3567 (
3568 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3569 &self.account,
3570 ),
3571 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3572 &self.caller,
3573 ),
3574 )
3575 }
3576 #[inline]
3577 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3578 (
3579 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3580 ret,
3581 ),
3582 )
3583 }
3584 #[inline]
3585 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3586 <Self::ReturnTuple<
3587 '_,
3588 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3589 .map(|r| {
3590 let r: isAdminReturn = r.into();
3591 r._0
3592 })
3593 }
3594 #[inline]
3595 fn abi_decode_returns_validate(
3596 data: &[u8],
3597 ) -> alloy_sol_types::Result<Self::Return> {
3598 <Self::ReturnTuple<
3599 '_,
3600 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3601 .map(|r| {
3602 let r: isAdminReturn = r.into();
3603 r._0
3604 })
3605 }
3606 }
3607 };
3608 #[derive(serde::Serialize, serde::Deserialize)]
3609 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3610 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3615 #[derive(Clone)]
3616 pub struct isPendingAdminCall {
3617 #[allow(missing_docs)]
3618 pub account: alloy::sol_types::private::Address,
3619 #[allow(missing_docs)]
3620 pub pendingAdmin: alloy::sol_types::private::Address,
3621 }
3622 #[derive(serde::Serialize, serde::Deserialize)]
3623 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3624 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3626 #[derive(Clone)]
3627 pub struct isPendingAdminReturn {
3628 #[allow(missing_docs)]
3629 pub _0: bool,
3630 }
3631 #[allow(
3632 non_camel_case_types,
3633 non_snake_case,
3634 clippy::pub_underscore_fields,
3635 clippy::style
3636 )]
3637 const _: () = {
3638 use alloy::sol_types as alloy_sol_types;
3639 {
3640 #[doc(hidden)]
3641 type UnderlyingSolTuple<'a> = (
3642 alloy::sol_types::sol_data::Address,
3643 alloy::sol_types::sol_data::Address,
3644 );
3645 #[doc(hidden)]
3646 type UnderlyingRustTuple<'a> = (
3647 alloy::sol_types::private::Address,
3648 alloy::sol_types::private::Address,
3649 );
3650 #[cfg(test)]
3651 #[allow(dead_code, unreachable_patterns)]
3652 fn _type_assertion(
3653 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3654 ) {
3655 match _t {
3656 alloy_sol_types::private::AssertTypeEq::<
3657 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3658 >(_) => {}
3659 }
3660 }
3661 #[automatically_derived]
3662 #[doc(hidden)]
3663 impl ::core::convert::From<isPendingAdminCall> for UnderlyingRustTuple<'_> {
3664 fn from(value: isPendingAdminCall) -> Self {
3665 (value.account, value.pendingAdmin)
3666 }
3667 }
3668 #[automatically_derived]
3669 #[doc(hidden)]
3670 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isPendingAdminCall {
3671 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3672 Self {
3673 account: tuple.0,
3674 pendingAdmin: tuple.1,
3675 }
3676 }
3677 }
3678 }
3679 {
3680 #[doc(hidden)]
3681 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3682 #[doc(hidden)]
3683 type UnderlyingRustTuple<'a> = (bool,);
3684 #[cfg(test)]
3685 #[allow(dead_code, unreachable_patterns)]
3686 fn _type_assertion(
3687 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3688 ) {
3689 match _t {
3690 alloy_sol_types::private::AssertTypeEq::<
3691 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3692 >(_) => {}
3693 }
3694 }
3695 #[automatically_derived]
3696 #[doc(hidden)]
3697 impl ::core::convert::From<isPendingAdminReturn>
3698 for UnderlyingRustTuple<'_> {
3699 fn from(value: isPendingAdminReturn) -> Self {
3700 (value._0,)
3701 }
3702 }
3703 #[automatically_derived]
3704 #[doc(hidden)]
3705 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3706 for isPendingAdminReturn {
3707 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3708 Self { _0: tuple.0 }
3709 }
3710 }
3711 }
3712 #[automatically_derived]
3713 impl alloy_sol_types::SolCall for isPendingAdminCall {
3714 type Parameters<'a> = (
3715 alloy::sol_types::sol_data::Address,
3716 alloy::sol_types::sol_data::Address,
3717 );
3718 type Token<'a> = <Self::Parameters<
3719 'a,
3720 > as alloy_sol_types::SolType>::Token<'a>;
3721 type Return = bool;
3722 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3723 type ReturnToken<'a> = <Self::ReturnTuple<
3724 'a,
3725 > as alloy_sol_types::SolType>::Token<'a>;
3726 const SIGNATURE: &'static str = "isPendingAdmin(address,address)";
3727 const SELECTOR: [u8; 4] = [173u8, 138u8, 202u8, 119u8];
3728 #[inline]
3729 fn new<'a>(
3730 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3731 ) -> Self {
3732 tuple.into()
3733 }
3734 #[inline]
3735 fn tokenize(&self) -> Self::Token<'_> {
3736 (
3737 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3738 &self.account,
3739 ),
3740 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3741 &self.pendingAdmin,
3742 ),
3743 )
3744 }
3745 #[inline]
3746 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3747 (
3748 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3749 ret,
3750 ),
3751 )
3752 }
3753 #[inline]
3754 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3755 <Self::ReturnTuple<
3756 '_,
3757 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3758 .map(|r| {
3759 let r: isPendingAdminReturn = r.into();
3760 r._0
3761 })
3762 }
3763 #[inline]
3764 fn abi_decode_returns_validate(
3765 data: &[u8],
3766 ) -> alloy_sol_types::Result<Self::Return> {
3767 <Self::ReturnTuple<
3768 '_,
3769 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3770 .map(|r| {
3771 let r: isPendingAdminReturn = r.into();
3772 r._0
3773 })
3774 }
3775 }
3776 };
3777 #[derive(serde::Serialize, serde::Deserialize)]
3778 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3779 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3784 #[derive(Clone)]
3785 pub struct removeAdminCall {
3786 #[allow(missing_docs)]
3787 pub account: alloy::sol_types::private::Address,
3788 #[allow(missing_docs)]
3789 pub admin: alloy::sol_types::private::Address,
3790 }
3791 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3793 #[derive(Clone)]
3794 pub struct removeAdminReturn {}
3795 #[allow(
3796 non_camel_case_types,
3797 non_snake_case,
3798 clippy::pub_underscore_fields,
3799 clippy::style
3800 )]
3801 const _: () = {
3802 use alloy::sol_types as alloy_sol_types;
3803 {
3804 #[doc(hidden)]
3805 type UnderlyingSolTuple<'a> = (
3806 alloy::sol_types::sol_data::Address,
3807 alloy::sol_types::sol_data::Address,
3808 );
3809 #[doc(hidden)]
3810 type UnderlyingRustTuple<'a> = (
3811 alloy::sol_types::private::Address,
3812 alloy::sol_types::private::Address,
3813 );
3814 #[cfg(test)]
3815 #[allow(dead_code, unreachable_patterns)]
3816 fn _type_assertion(
3817 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3818 ) {
3819 match _t {
3820 alloy_sol_types::private::AssertTypeEq::<
3821 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3822 >(_) => {}
3823 }
3824 }
3825 #[automatically_derived]
3826 #[doc(hidden)]
3827 impl ::core::convert::From<removeAdminCall> for UnderlyingRustTuple<'_> {
3828 fn from(value: removeAdminCall) -> Self {
3829 (value.account, value.admin)
3830 }
3831 }
3832 #[automatically_derived]
3833 #[doc(hidden)]
3834 impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminCall {
3835 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3836 Self {
3837 account: tuple.0,
3838 admin: tuple.1,
3839 }
3840 }
3841 }
3842 }
3843 {
3844 #[doc(hidden)]
3845 type UnderlyingSolTuple<'a> = ();
3846 #[doc(hidden)]
3847 type UnderlyingRustTuple<'a> = ();
3848 #[cfg(test)]
3849 #[allow(dead_code, unreachable_patterns)]
3850 fn _type_assertion(
3851 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3852 ) {
3853 match _t {
3854 alloy_sol_types::private::AssertTypeEq::<
3855 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3856 >(_) => {}
3857 }
3858 }
3859 #[automatically_derived]
3860 #[doc(hidden)]
3861 impl ::core::convert::From<removeAdminReturn> for UnderlyingRustTuple<'_> {
3862 fn from(value: removeAdminReturn) -> Self {
3863 ()
3864 }
3865 }
3866 #[automatically_derived]
3867 #[doc(hidden)]
3868 impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAdminReturn {
3869 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3870 Self {}
3871 }
3872 }
3873 }
3874 impl removeAdminReturn {
3875 fn _tokenize(
3876 &self,
3877 ) -> <removeAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3878 ()
3879 }
3880 }
3881 #[automatically_derived]
3882 impl alloy_sol_types::SolCall for removeAdminCall {
3883 type Parameters<'a> = (
3884 alloy::sol_types::sol_data::Address,
3885 alloy::sol_types::sol_data::Address,
3886 );
3887 type Token<'a> = <Self::Parameters<
3888 'a,
3889 > as alloy_sol_types::SolType>::Token<'a>;
3890 type Return = removeAdminReturn;
3891 type ReturnTuple<'a> = ();
3892 type ReturnToken<'a> = <Self::ReturnTuple<
3893 'a,
3894 > as alloy_sol_types::SolType>::Token<'a>;
3895 const SIGNATURE: &'static str = "removeAdmin(address,address)";
3896 const SELECTOR: [u8; 4] = [38u8, 137u8, 89u8, 229u8];
3897 #[inline]
3898 fn new<'a>(
3899 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3900 ) -> Self {
3901 tuple.into()
3902 }
3903 #[inline]
3904 fn tokenize(&self) -> Self::Token<'_> {
3905 (
3906 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3907 &self.account,
3908 ),
3909 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
3910 &self.admin,
3911 ),
3912 )
3913 }
3914 #[inline]
3915 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3916 removeAdminReturn::_tokenize(ret)
3917 }
3918 #[inline]
3919 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3920 <Self::ReturnTuple<
3921 '_,
3922 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3923 .map(Into::into)
3924 }
3925 #[inline]
3926 fn abi_decode_returns_validate(
3927 data: &[u8],
3928 ) -> alloy_sol_types::Result<Self::Return> {
3929 <Self::ReturnTuple<
3930 '_,
3931 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3932 .map(Into::into)
3933 }
3934 }
3935 };
3936 #[derive(serde::Serialize, serde::Deserialize)]
3937 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3938 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3943 #[derive(Clone)]
3944 pub struct removeAppointeeCall {
3945 #[allow(missing_docs)]
3946 pub account: alloy::sol_types::private::Address,
3947 #[allow(missing_docs)]
3948 pub appointee: alloy::sol_types::private::Address,
3949 #[allow(missing_docs)]
3950 pub target: alloy::sol_types::private::Address,
3951 #[allow(missing_docs)]
3952 pub selector: alloy::sol_types::private::FixedBytes<4>,
3953 }
3954 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3956 #[derive(Clone)]
3957 pub struct removeAppointeeReturn {}
3958 #[allow(
3959 non_camel_case_types,
3960 non_snake_case,
3961 clippy::pub_underscore_fields,
3962 clippy::style
3963 )]
3964 const _: () = {
3965 use alloy::sol_types as alloy_sol_types;
3966 {
3967 #[doc(hidden)]
3968 type UnderlyingSolTuple<'a> = (
3969 alloy::sol_types::sol_data::Address,
3970 alloy::sol_types::sol_data::Address,
3971 alloy::sol_types::sol_data::Address,
3972 alloy::sol_types::sol_data::FixedBytes<4>,
3973 );
3974 #[doc(hidden)]
3975 type UnderlyingRustTuple<'a> = (
3976 alloy::sol_types::private::Address,
3977 alloy::sol_types::private::Address,
3978 alloy::sol_types::private::Address,
3979 alloy::sol_types::private::FixedBytes<4>,
3980 );
3981 #[cfg(test)]
3982 #[allow(dead_code, unreachable_patterns)]
3983 fn _type_assertion(
3984 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3985 ) {
3986 match _t {
3987 alloy_sol_types::private::AssertTypeEq::<
3988 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3989 >(_) => {}
3990 }
3991 }
3992 #[automatically_derived]
3993 #[doc(hidden)]
3994 impl ::core::convert::From<removeAppointeeCall> for UnderlyingRustTuple<'_> {
3995 fn from(value: removeAppointeeCall) -> Self {
3996 (value.account, value.appointee, value.target, value.selector)
3997 }
3998 }
3999 #[automatically_derived]
4000 #[doc(hidden)]
4001 impl ::core::convert::From<UnderlyingRustTuple<'_>> for removeAppointeeCall {
4002 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4003 Self {
4004 account: tuple.0,
4005 appointee: tuple.1,
4006 target: tuple.2,
4007 selector: tuple.3,
4008 }
4009 }
4010 }
4011 }
4012 {
4013 #[doc(hidden)]
4014 type UnderlyingSolTuple<'a> = ();
4015 #[doc(hidden)]
4016 type UnderlyingRustTuple<'a> = ();
4017 #[cfg(test)]
4018 #[allow(dead_code, unreachable_patterns)]
4019 fn _type_assertion(
4020 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4021 ) {
4022 match _t {
4023 alloy_sol_types::private::AssertTypeEq::<
4024 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4025 >(_) => {}
4026 }
4027 }
4028 #[automatically_derived]
4029 #[doc(hidden)]
4030 impl ::core::convert::From<removeAppointeeReturn>
4031 for UnderlyingRustTuple<'_> {
4032 fn from(value: removeAppointeeReturn) -> Self {
4033 ()
4034 }
4035 }
4036 #[automatically_derived]
4037 #[doc(hidden)]
4038 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4039 for removeAppointeeReturn {
4040 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4041 Self {}
4042 }
4043 }
4044 }
4045 impl removeAppointeeReturn {
4046 fn _tokenize(
4047 &self,
4048 ) -> <removeAppointeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4049 ()
4050 }
4051 }
4052 #[automatically_derived]
4053 impl alloy_sol_types::SolCall for removeAppointeeCall {
4054 type Parameters<'a> = (
4055 alloy::sol_types::sol_data::Address,
4056 alloy::sol_types::sol_data::Address,
4057 alloy::sol_types::sol_data::Address,
4058 alloy::sol_types::sol_data::FixedBytes<4>,
4059 );
4060 type Token<'a> = <Self::Parameters<
4061 'a,
4062 > as alloy_sol_types::SolType>::Token<'a>;
4063 type Return = removeAppointeeReturn;
4064 type ReturnTuple<'a> = ();
4065 type ReturnToken<'a> = <Self::ReturnTuple<
4066 'a,
4067 > as alloy_sol_types::SolType>::Token<'a>;
4068 const SIGNATURE: &'static str = "removeAppointee(address,address,address,bytes4)";
4069 const SELECTOR: [u8; 4] = [6u8, 100u8, 18u8, 1u8];
4070 #[inline]
4071 fn new<'a>(
4072 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4073 ) -> Self {
4074 tuple.into()
4075 }
4076 #[inline]
4077 fn tokenize(&self) -> Self::Token<'_> {
4078 (
4079 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4080 &self.account,
4081 ),
4082 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4083 &self.appointee,
4084 ),
4085 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4086 &self.target,
4087 ),
4088 <alloy::sol_types::sol_data::FixedBytes<
4089 4,
4090 > as alloy_sol_types::SolType>::tokenize(&self.selector),
4091 )
4092 }
4093 #[inline]
4094 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4095 removeAppointeeReturn::_tokenize(ret)
4096 }
4097 #[inline]
4098 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4099 <Self::ReturnTuple<
4100 '_,
4101 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4102 .map(Into::into)
4103 }
4104 #[inline]
4105 fn abi_decode_returns_validate(
4106 data: &[u8],
4107 ) -> alloy_sol_types::Result<Self::Return> {
4108 <Self::ReturnTuple<
4109 '_,
4110 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4111 .map(Into::into)
4112 }
4113 }
4114 };
4115 #[derive(serde::Serialize, serde::Deserialize)]
4116 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4117 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4122 #[derive(Clone)]
4123 pub struct removePendingAdminCall {
4124 #[allow(missing_docs)]
4125 pub account: alloy::sol_types::private::Address,
4126 #[allow(missing_docs)]
4127 pub admin: alloy::sol_types::private::Address,
4128 }
4129 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4131 #[derive(Clone)]
4132 pub struct removePendingAdminReturn {}
4133 #[allow(
4134 non_camel_case_types,
4135 non_snake_case,
4136 clippy::pub_underscore_fields,
4137 clippy::style
4138 )]
4139 const _: () = {
4140 use alloy::sol_types as alloy_sol_types;
4141 {
4142 #[doc(hidden)]
4143 type UnderlyingSolTuple<'a> = (
4144 alloy::sol_types::sol_data::Address,
4145 alloy::sol_types::sol_data::Address,
4146 );
4147 #[doc(hidden)]
4148 type UnderlyingRustTuple<'a> = (
4149 alloy::sol_types::private::Address,
4150 alloy::sol_types::private::Address,
4151 );
4152 #[cfg(test)]
4153 #[allow(dead_code, unreachable_patterns)]
4154 fn _type_assertion(
4155 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4156 ) {
4157 match _t {
4158 alloy_sol_types::private::AssertTypeEq::<
4159 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4160 >(_) => {}
4161 }
4162 }
4163 #[automatically_derived]
4164 #[doc(hidden)]
4165 impl ::core::convert::From<removePendingAdminCall>
4166 for UnderlyingRustTuple<'_> {
4167 fn from(value: removePendingAdminCall) -> Self {
4168 (value.account, value.admin)
4169 }
4170 }
4171 #[automatically_derived]
4172 #[doc(hidden)]
4173 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4174 for removePendingAdminCall {
4175 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4176 Self {
4177 account: tuple.0,
4178 admin: tuple.1,
4179 }
4180 }
4181 }
4182 }
4183 {
4184 #[doc(hidden)]
4185 type UnderlyingSolTuple<'a> = ();
4186 #[doc(hidden)]
4187 type UnderlyingRustTuple<'a> = ();
4188 #[cfg(test)]
4189 #[allow(dead_code, unreachable_patterns)]
4190 fn _type_assertion(
4191 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4192 ) {
4193 match _t {
4194 alloy_sol_types::private::AssertTypeEq::<
4195 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4196 >(_) => {}
4197 }
4198 }
4199 #[automatically_derived]
4200 #[doc(hidden)]
4201 impl ::core::convert::From<removePendingAdminReturn>
4202 for UnderlyingRustTuple<'_> {
4203 fn from(value: removePendingAdminReturn) -> Self {
4204 ()
4205 }
4206 }
4207 #[automatically_derived]
4208 #[doc(hidden)]
4209 impl ::core::convert::From<UnderlyingRustTuple<'_>>
4210 for removePendingAdminReturn {
4211 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4212 Self {}
4213 }
4214 }
4215 }
4216 impl removePendingAdminReturn {
4217 fn _tokenize(
4218 &self,
4219 ) -> <removePendingAdminCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4220 ()
4221 }
4222 }
4223 #[automatically_derived]
4224 impl alloy_sol_types::SolCall for removePendingAdminCall {
4225 type Parameters<'a> = (
4226 alloy::sol_types::sol_data::Address,
4227 alloy::sol_types::sol_data::Address,
4228 );
4229 type Token<'a> = <Self::Parameters<
4230 'a,
4231 > as alloy_sol_types::SolType>::Token<'a>;
4232 type Return = removePendingAdminReturn;
4233 type ReturnTuple<'a> = ();
4234 type ReturnToken<'a> = <Self::ReturnTuple<
4235 'a,
4236 > as alloy_sol_types::SolType>::Token<'a>;
4237 const SIGNATURE: &'static str = "removePendingAdmin(address,address)";
4238 const SELECTOR: [u8; 4] = [79u8, 144u8, 108u8, 249u8];
4239 #[inline]
4240 fn new<'a>(
4241 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4242 ) -> Self {
4243 tuple.into()
4244 }
4245 #[inline]
4246 fn tokenize(&self) -> Self::Token<'_> {
4247 (
4248 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4249 &self.account,
4250 ),
4251 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4252 &self.admin,
4253 ),
4254 )
4255 }
4256 #[inline]
4257 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4258 removePendingAdminReturn::_tokenize(ret)
4259 }
4260 #[inline]
4261 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4262 <Self::ReturnTuple<
4263 '_,
4264 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4265 .map(Into::into)
4266 }
4267 #[inline]
4268 fn abi_decode_returns_validate(
4269 data: &[u8],
4270 ) -> alloy_sol_types::Result<Self::Return> {
4271 <Self::ReturnTuple<
4272 '_,
4273 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4274 .map(Into::into)
4275 }
4276 }
4277 };
4278 #[derive(serde::Serialize, serde::Deserialize)]
4279 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4280 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4285 #[derive(Clone)]
4286 pub struct setAppointeeCall {
4287 #[allow(missing_docs)]
4288 pub account: alloy::sol_types::private::Address,
4289 #[allow(missing_docs)]
4290 pub appointee: alloy::sol_types::private::Address,
4291 #[allow(missing_docs)]
4292 pub target: alloy::sol_types::private::Address,
4293 #[allow(missing_docs)]
4294 pub selector: alloy::sol_types::private::FixedBytes<4>,
4295 }
4296 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4298 #[derive(Clone)]
4299 pub struct setAppointeeReturn {}
4300 #[allow(
4301 non_camel_case_types,
4302 non_snake_case,
4303 clippy::pub_underscore_fields,
4304 clippy::style
4305 )]
4306 const _: () = {
4307 use alloy::sol_types as alloy_sol_types;
4308 {
4309 #[doc(hidden)]
4310 type UnderlyingSolTuple<'a> = (
4311 alloy::sol_types::sol_data::Address,
4312 alloy::sol_types::sol_data::Address,
4313 alloy::sol_types::sol_data::Address,
4314 alloy::sol_types::sol_data::FixedBytes<4>,
4315 );
4316 #[doc(hidden)]
4317 type UnderlyingRustTuple<'a> = (
4318 alloy::sol_types::private::Address,
4319 alloy::sol_types::private::Address,
4320 alloy::sol_types::private::Address,
4321 alloy::sol_types::private::FixedBytes<4>,
4322 );
4323 #[cfg(test)]
4324 #[allow(dead_code, unreachable_patterns)]
4325 fn _type_assertion(
4326 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4327 ) {
4328 match _t {
4329 alloy_sol_types::private::AssertTypeEq::<
4330 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4331 >(_) => {}
4332 }
4333 }
4334 #[automatically_derived]
4335 #[doc(hidden)]
4336 impl ::core::convert::From<setAppointeeCall> for UnderlyingRustTuple<'_> {
4337 fn from(value: setAppointeeCall) -> Self {
4338 (value.account, value.appointee, value.target, value.selector)
4339 }
4340 }
4341 #[automatically_derived]
4342 #[doc(hidden)]
4343 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeCall {
4344 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4345 Self {
4346 account: tuple.0,
4347 appointee: tuple.1,
4348 target: tuple.2,
4349 selector: tuple.3,
4350 }
4351 }
4352 }
4353 }
4354 {
4355 #[doc(hidden)]
4356 type UnderlyingSolTuple<'a> = ();
4357 #[doc(hidden)]
4358 type UnderlyingRustTuple<'a> = ();
4359 #[cfg(test)]
4360 #[allow(dead_code, unreachable_patterns)]
4361 fn _type_assertion(
4362 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4363 ) {
4364 match _t {
4365 alloy_sol_types::private::AssertTypeEq::<
4366 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4367 >(_) => {}
4368 }
4369 }
4370 #[automatically_derived]
4371 #[doc(hidden)]
4372 impl ::core::convert::From<setAppointeeReturn> for UnderlyingRustTuple<'_> {
4373 fn from(value: setAppointeeReturn) -> Self {
4374 ()
4375 }
4376 }
4377 #[automatically_derived]
4378 #[doc(hidden)]
4379 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setAppointeeReturn {
4380 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4381 Self {}
4382 }
4383 }
4384 }
4385 impl setAppointeeReturn {
4386 fn _tokenize(
4387 &self,
4388 ) -> <setAppointeeCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
4389 ()
4390 }
4391 }
4392 #[automatically_derived]
4393 impl alloy_sol_types::SolCall for setAppointeeCall {
4394 type Parameters<'a> = (
4395 alloy::sol_types::sol_data::Address,
4396 alloy::sol_types::sol_data::Address,
4397 alloy::sol_types::sol_data::Address,
4398 alloy::sol_types::sol_data::FixedBytes<4>,
4399 );
4400 type Token<'a> = <Self::Parameters<
4401 'a,
4402 > as alloy_sol_types::SolType>::Token<'a>;
4403 type Return = setAppointeeReturn;
4404 type ReturnTuple<'a> = ();
4405 type ReturnToken<'a> = <Self::ReturnTuple<
4406 'a,
4407 > as alloy_sol_types::SolType>::Token<'a>;
4408 const SIGNATURE: &'static str = "setAppointee(address,address,address,bytes4)";
4409 const SELECTOR: [u8; 4] = [149u8, 13u8, 128u8, 110u8];
4410 #[inline]
4411 fn new<'a>(
4412 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4413 ) -> Self {
4414 tuple.into()
4415 }
4416 #[inline]
4417 fn tokenize(&self) -> Self::Token<'_> {
4418 (
4419 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4420 &self.account,
4421 ),
4422 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4423 &self.appointee,
4424 ),
4425 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
4426 &self.target,
4427 ),
4428 <alloy::sol_types::sol_data::FixedBytes<
4429 4,
4430 > as alloy_sol_types::SolType>::tokenize(&self.selector),
4431 )
4432 }
4433 #[inline]
4434 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4435 setAppointeeReturn::_tokenize(ret)
4436 }
4437 #[inline]
4438 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4439 <Self::ReturnTuple<
4440 '_,
4441 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4442 .map(Into::into)
4443 }
4444 #[inline]
4445 fn abi_decode_returns_validate(
4446 data: &[u8],
4447 ) -> alloy_sol_types::Result<Self::Return> {
4448 <Self::ReturnTuple<
4449 '_,
4450 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4451 .map(Into::into)
4452 }
4453 }
4454 };
4455 #[derive(serde::Serialize, serde::Deserialize)]
4456 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4457 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4462 #[derive(Clone)]
4463 pub struct versionCall;
4464 #[derive(serde::Serialize, serde::Deserialize)]
4465 #[derive(Default, Debug, PartialEq, Eq, Hash)]
4466 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
4468 #[derive(Clone)]
4469 pub struct versionReturn {
4470 #[allow(missing_docs)]
4471 pub _0: alloy::sol_types::private::String,
4472 }
4473 #[allow(
4474 non_camel_case_types,
4475 non_snake_case,
4476 clippy::pub_underscore_fields,
4477 clippy::style
4478 )]
4479 const _: () = {
4480 use alloy::sol_types as alloy_sol_types;
4481 {
4482 #[doc(hidden)]
4483 type UnderlyingSolTuple<'a> = ();
4484 #[doc(hidden)]
4485 type UnderlyingRustTuple<'a> = ();
4486 #[cfg(test)]
4487 #[allow(dead_code, unreachable_patterns)]
4488 fn _type_assertion(
4489 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4490 ) {
4491 match _t {
4492 alloy_sol_types::private::AssertTypeEq::<
4493 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4494 >(_) => {}
4495 }
4496 }
4497 #[automatically_derived]
4498 #[doc(hidden)]
4499 impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
4500 fn from(value: versionCall) -> Self {
4501 ()
4502 }
4503 }
4504 #[automatically_derived]
4505 #[doc(hidden)]
4506 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
4507 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4508 Self
4509 }
4510 }
4511 }
4512 {
4513 #[doc(hidden)]
4514 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
4515 #[doc(hidden)]
4516 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
4517 #[cfg(test)]
4518 #[allow(dead_code, unreachable_patterns)]
4519 fn _type_assertion(
4520 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
4521 ) {
4522 match _t {
4523 alloy_sol_types::private::AssertTypeEq::<
4524 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
4525 >(_) => {}
4526 }
4527 }
4528 #[automatically_derived]
4529 #[doc(hidden)]
4530 impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
4531 fn from(value: versionReturn) -> Self {
4532 (value._0,)
4533 }
4534 }
4535 #[automatically_derived]
4536 #[doc(hidden)]
4537 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
4538 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
4539 Self { _0: tuple.0 }
4540 }
4541 }
4542 }
4543 #[automatically_derived]
4544 impl alloy_sol_types::SolCall for versionCall {
4545 type Parameters<'a> = ();
4546 type Token<'a> = <Self::Parameters<
4547 'a,
4548 > as alloy_sol_types::SolType>::Token<'a>;
4549 type Return = alloy::sol_types::private::String;
4550 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
4551 type ReturnToken<'a> = <Self::ReturnTuple<
4552 'a,
4553 > as alloy_sol_types::SolType>::Token<'a>;
4554 const SIGNATURE: &'static str = "version()";
4555 const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
4556 #[inline]
4557 fn new<'a>(
4558 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
4559 ) -> Self {
4560 tuple.into()
4561 }
4562 #[inline]
4563 fn tokenize(&self) -> Self::Token<'_> {
4564 ()
4565 }
4566 #[inline]
4567 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
4568 (
4569 <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
4570 ret,
4571 ),
4572 )
4573 }
4574 #[inline]
4575 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
4576 <Self::ReturnTuple<
4577 '_,
4578 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
4579 .map(|r| {
4580 let r: versionReturn = r.into();
4581 r._0
4582 })
4583 }
4584 #[inline]
4585 fn abi_decode_returns_validate(
4586 data: &[u8],
4587 ) -> alloy_sol_types::Result<Self::Return> {
4588 <Self::ReturnTuple<
4589 '_,
4590 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
4591 .map(|r| {
4592 let r: versionReturn = r.into();
4593 r._0
4594 })
4595 }
4596 }
4597 };
4598 #[derive(serde::Serialize, serde::Deserialize)]
4600 #[derive()]
4601 pub enum PermissionControllerCalls {
4602 #[allow(missing_docs)]
4603 acceptAdmin(acceptAdminCall),
4604 #[allow(missing_docs)]
4605 addPendingAdmin(addPendingAdminCall),
4606 #[allow(missing_docs)]
4607 canCall(canCallCall),
4608 #[allow(missing_docs)]
4609 getAdmins(getAdminsCall),
4610 #[allow(missing_docs)]
4611 getAppointeePermissions(getAppointeePermissionsCall),
4612 #[allow(missing_docs)]
4613 getAppointees(getAppointeesCall),
4614 #[allow(missing_docs)]
4615 getPendingAdmins(getPendingAdminsCall),
4616 #[allow(missing_docs)]
4617 isAdmin(isAdminCall),
4618 #[allow(missing_docs)]
4619 isPendingAdmin(isPendingAdminCall),
4620 #[allow(missing_docs)]
4621 removeAdmin(removeAdminCall),
4622 #[allow(missing_docs)]
4623 removeAppointee(removeAppointeeCall),
4624 #[allow(missing_docs)]
4625 removePendingAdmin(removePendingAdminCall),
4626 #[allow(missing_docs)]
4627 setAppointee(setAppointeeCall),
4628 #[allow(missing_docs)]
4629 version(versionCall),
4630 }
4631 #[automatically_derived]
4632 impl PermissionControllerCalls {
4633 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4640 [6u8, 100u8, 18u8, 1u8],
4641 [38u8, 137u8, 89u8, 229u8],
4642 [79u8, 144u8, 108u8, 249u8],
4643 [84u8, 253u8, 77u8, 80u8],
4644 [98u8, 136u8, 6u8, 239u8],
4645 [107u8, 221u8, 250u8, 31u8],
4646 [136u8, 42u8, 59u8, 56u8],
4647 [145u8, 0u8, 103u8, 69u8],
4648 [149u8, 13u8, 128u8, 110u8],
4649 [173u8, 95u8, 34u8, 16u8],
4650 [173u8, 138u8, 202u8, 119u8],
4651 [223u8, 89u8, 92u8, 184u8],
4652 [235u8, 90u8, 78u8, 135u8],
4653 [253u8, 219u8, 222u8, 253u8],
4654 ];
4655 }
4656 #[automatically_derived]
4657 impl alloy_sol_types::SolInterface for PermissionControllerCalls {
4658 const NAME: &'static str = "PermissionControllerCalls";
4659 const MIN_DATA_LENGTH: usize = 0usize;
4660 const COUNT: usize = 14usize;
4661 #[inline]
4662 fn selector(&self) -> [u8; 4] {
4663 match self {
4664 Self::acceptAdmin(_) => {
4665 <acceptAdminCall as alloy_sol_types::SolCall>::SELECTOR
4666 }
4667 Self::addPendingAdmin(_) => {
4668 <addPendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
4669 }
4670 Self::canCall(_) => <canCallCall as alloy_sol_types::SolCall>::SELECTOR,
4671 Self::getAdmins(_) => {
4672 <getAdminsCall as alloy_sol_types::SolCall>::SELECTOR
4673 }
4674 Self::getAppointeePermissions(_) => {
4675 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::SELECTOR
4676 }
4677 Self::getAppointees(_) => {
4678 <getAppointeesCall as alloy_sol_types::SolCall>::SELECTOR
4679 }
4680 Self::getPendingAdmins(_) => {
4681 <getPendingAdminsCall as alloy_sol_types::SolCall>::SELECTOR
4682 }
4683 Self::isAdmin(_) => <isAdminCall as alloy_sol_types::SolCall>::SELECTOR,
4684 Self::isPendingAdmin(_) => {
4685 <isPendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
4686 }
4687 Self::removeAdmin(_) => {
4688 <removeAdminCall as alloy_sol_types::SolCall>::SELECTOR
4689 }
4690 Self::removeAppointee(_) => {
4691 <removeAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
4692 }
4693 Self::removePendingAdmin(_) => {
4694 <removePendingAdminCall as alloy_sol_types::SolCall>::SELECTOR
4695 }
4696 Self::setAppointee(_) => {
4697 <setAppointeeCall as alloy_sol_types::SolCall>::SELECTOR
4698 }
4699 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
4700 }
4701 }
4702 #[inline]
4703 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4704 Self::SELECTORS.get(i).copied()
4705 }
4706 #[inline]
4707 fn valid_selector(selector: [u8; 4]) -> bool {
4708 Self::SELECTORS.binary_search(&selector).is_ok()
4709 }
4710 #[inline]
4711 #[allow(non_snake_case)]
4712 fn abi_decode_raw(
4713 selector: [u8; 4],
4714 data: &[u8],
4715 ) -> alloy_sol_types::Result<Self> {
4716 static DECODE_SHIMS: &[fn(
4717 &[u8],
4718 ) -> alloy_sol_types::Result<PermissionControllerCalls>] = &[
4719 {
4720 fn removeAppointee(
4721 data: &[u8],
4722 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4723 <removeAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4724 data,
4725 )
4726 .map(PermissionControllerCalls::removeAppointee)
4727 }
4728 removeAppointee
4729 },
4730 {
4731 fn removeAdmin(
4732 data: &[u8],
4733 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4734 <removeAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4735 data,
4736 )
4737 .map(PermissionControllerCalls::removeAdmin)
4738 }
4739 removeAdmin
4740 },
4741 {
4742 fn removePendingAdmin(
4743 data: &[u8],
4744 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4745 <removePendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4746 data,
4747 )
4748 .map(PermissionControllerCalls::removePendingAdmin)
4749 }
4750 removePendingAdmin
4751 },
4752 {
4753 fn version(
4754 data: &[u8],
4755 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4756 <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4757 .map(PermissionControllerCalls::version)
4758 }
4759 version
4760 },
4761 {
4762 fn acceptAdmin(
4763 data: &[u8],
4764 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4765 <acceptAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4766 data,
4767 )
4768 .map(PermissionControllerCalls::acceptAdmin)
4769 }
4770 acceptAdmin
4771 },
4772 {
4773 fn getPendingAdmins(
4774 data: &[u8],
4775 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4776 <getPendingAdminsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4777 data,
4778 )
4779 .map(PermissionControllerCalls::getPendingAdmins)
4780 }
4781 getPendingAdmins
4782 },
4783 {
4784 fn getAppointeePermissions(
4785 data: &[u8],
4786 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4787 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::abi_decode_raw(
4788 data,
4789 )
4790 .map(PermissionControllerCalls::getAppointeePermissions)
4791 }
4792 getAppointeePermissions
4793 },
4794 {
4795 fn isAdmin(
4796 data: &[u8],
4797 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4798 <isAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4799 .map(PermissionControllerCalls::isAdmin)
4800 }
4801 isAdmin
4802 },
4803 {
4804 fn setAppointee(
4805 data: &[u8],
4806 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4807 <setAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw(
4808 data,
4809 )
4810 .map(PermissionControllerCalls::setAppointee)
4811 }
4812 setAppointee
4813 },
4814 {
4815 fn getAdmins(
4816 data: &[u8],
4817 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4818 <getAdminsCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4819 .map(PermissionControllerCalls::getAdmins)
4820 }
4821 getAdmins
4822 },
4823 {
4824 fn isPendingAdmin(
4825 data: &[u8],
4826 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4827 <isPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4828 data,
4829 )
4830 .map(PermissionControllerCalls::isPendingAdmin)
4831 }
4832 isPendingAdmin
4833 },
4834 {
4835 fn canCall(
4836 data: &[u8],
4837 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4838 <canCallCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
4839 .map(PermissionControllerCalls::canCall)
4840 }
4841 canCall
4842 },
4843 {
4844 fn addPendingAdmin(
4845 data: &[u8],
4846 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4847 <addPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw(
4848 data,
4849 )
4850 .map(PermissionControllerCalls::addPendingAdmin)
4851 }
4852 addPendingAdmin
4853 },
4854 {
4855 fn getAppointees(
4856 data: &[u8],
4857 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4858 <getAppointeesCall as alloy_sol_types::SolCall>::abi_decode_raw(
4859 data,
4860 )
4861 .map(PermissionControllerCalls::getAppointees)
4862 }
4863 getAppointees
4864 },
4865 ];
4866 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4867 return Err(
4868 alloy_sol_types::Error::unknown_selector(
4869 <Self as alloy_sol_types::SolInterface>::NAME,
4870 selector,
4871 ),
4872 );
4873 };
4874 DECODE_SHIMS[idx](data)
4875 }
4876 #[inline]
4877 #[allow(non_snake_case)]
4878 fn abi_decode_raw_validate(
4879 selector: [u8; 4],
4880 data: &[u8],
4881 ) -> alloy_sol_types::Result<Self> {
4882 static DECODE_VALIDATE_SHIMS: &[fn(
4883 &[u8],
4884 ) -> alloy_sol_types::Result<PermissionControllerCalls>] = &[
4885 {
4886 fn removeAppointee(
4887 data: &[u8],
4888 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4889 <removeAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4890 data,
4891 )
4892 .map(PermissionControllerCalls::removeAppointee)
4893 }
4894 removeAppointee
4895 },
4896 {
4897 fn removeAdmin(
4898 data: &[u8],
4899 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4900 <removeAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4901 data,
4902 )
4903 .map(PermissionControllerCalls::removeAdmin)
4904 }
4905 removeAdmin
4906 },
4907 {
4908 fn removePendingAdmin(
4909 data: &[u8],
4910 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4911 <removePendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4912 data,
4913 )
4914 .map(PermissionControllerCalls::removePendingAdmin)
4915 }
4916 removePendingAdmin
4917 },
4918 {
4919 fn version(
4920 data: &[u8],
4921 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4922 <versionCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4923 data,
4924 )
4925 .map(PermissionControllerCalls::version)
4926 }
4927 version
4928 },
4929 {
4930 fn acceptAdmin(
4931 data: &[u8],
4932 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4933 <acceptAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4934 data,
4935 )
4936 .map(PermissionControllerCalls::acceptAdmin)
4937 }
4938 acceptAdmin
4939 },
4940 {
4941 fn getPendingAdmins(
4942 data: &[u8],
4943 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4944 <getPendingAdminsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4945 data,
4946 )
4947 .map(PermissionControllerCalls::getPendingAdmins)
4948 }
4949 getPendingAdmins
4950 },
4951 {
4952 fn getAppointeePermissions(
4953 data: &[u8],
4954 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4955 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4956 data,
4957 )
4958 .map(PermissionControllerCalls::getAppointeePermissions)
4959 }
4960 getAppointeePermissions
4961 },
4962 {
4963 fn isAdmin(
4964 data: &[u8],
4965 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4966 <isAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4967 data,
4968 )
4969 .map(PermissionControllerCalls::isAdmin)
4970 }
4971 isAdmin
4972 },
4973 {
4974 fn setAppointee(
4975 data: &[u8],
4976 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4977 <setAppointeeCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4978 data,
4979 )
4980 .map(PermissionControllerCalls::setAppointee)
4981 }
4982 setAppointee
4983 },
4984 {
4985 fn getAdmins(
4986 data: &[u8],
4987 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4988 <getAdminsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4989 data,
4990 )
4991 .map(PermissionControllerCalls::getAdmins)
4992 }
4993 getAdmins
4994 },
4995 {
4996 fn isPendingAdmin(
4997 data: &[u8],
4998 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
4999 <isPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5000 data,
5001 )
5002 .map(PermissionControllerCalls::isPendingAdmin)
5003 }
5004 isPendingAdmin
5005 },
5006 {
5007 fn canCall(
5008 data: &[u8],
5009 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
5010 <canCallCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5011 data,
5012 )
5013 .map(PermissionControllerCalls::canCall)
5014 }
5015 canCall
5016 },
5017 {
5018 fn addPendingAdmin(
5019 data: &[u8],
5020 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
5021 <addPendingAdminCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5022 data,
5023 )
5024 .map(PermissionControllerCalls::addPendingAdmin)
5025 }
5026 addPendingAdmin
5027 },
5028 {
5029 fn getAppointees(
5030 data: &[u8],
5031 ) -> alloy_sol_types::Result<PermissionControllerCalls> {
5032 <getAppointeesCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
5033 data,
5034 )
5035 .map(PermissionControllerCalls::getAppointees)
5036 }
5037 getAppointees
5038 },
5039 ];
5040 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5041 return Err(
5042 alloy_sol_types::Error::unknown_selector(
5043 <Self as alloy_sol_types::SolInterface>::NAME,
5044 selector,
5045 ),
5046 );
5047 };
5048 DECODE_VALIDATE_SHIMS[idx](data)
5049 }
5050 #[inline]
5051 fn abi_encoded_size(&self) -> usize {
5052 match self {
5053 Self::acceptAdmin(inner) => {
5054 <acceptAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
5055 inner,
5056 )
5057 }
5058 Self::addPendingAdmin(inner) => {
5059 <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
5060 inner,
5061 )
5062 }
5063 Self::canCall(inner) => {
5064 <canCallCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5065 }
5066 Self::getAdmins(inner) => {
5067 <getAdminsCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5068 }
5069 Self::getAppointeePermissions(inner) => {
5070 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::abi_encoded_size(
5071 inner,
5072 )
5073 }
5074 Self::getAppointees(inner) => {
5075 <getAppointeesCall as alloy_sol_types::SolCall>::abi_encoded_size(
5076 inner,
5077 )
5078 }
5079 Self::getPendingAdmins(inner) => {
5080 <getPendingAdminsCall as alloy_sol_types::SolCall>::abi_encoded_size(
5081 inner,
5082 )
5083 }
5084 Self::isAdmin(inner) => {
5085 <isAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5086 }
5087 Self::isPendingAdmin(inner) => {
5088 <isPendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
5089 inner,
5090 )
5091 }
5092 Self::removeAdmin(inner) => {
5093 <removeAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
5094 inner,
5095 )
5096 }
5097 Self::removeAppointee(inner) => {
5098 <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
5099 inner,
5100 )
5101 }
5102 Self::removePendingAdmin(inner) => {
5103 <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encoded_size(
5104 inner,
5105 )
5106 }
5107 Self::setAppointee(inner) => {
5108 <setAppointeeCall as alloy_sol_types::SolCall>::abi_encoded_size(
5109 inner,
5110 )
5111 }
5112 Self::version(inner) => {
5113 <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
5114 }
5115 }
5116 }
5117 #[inline]
5118 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5119 match self {
5120 Self::acceptAdmin(inner) => {
5121 <acceptAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
5122 inner,
5123 out,
5124 )
5125 }
5126 Self::addPendingAdmin(inner) => {
5127 <addPendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
5128 inner,
5129 out,
5130 )
5131 }
5132 Self::canCall(inner) => {
5133 <canCallCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5134 }
5135 Self::getAdmins(inner) => {
5136 <getAdminsCall as alloy_sol_types::SolCall>::abi_encode_raw(
5137 inner,
5138 out,
5139 )
5140 }
5141 Self::getAppointeePermissions(inner) => {
5142 <getAppointeePermissionsCall as alloy_sol_types::SolCall>::abi_encode_raw(
5143 inner,
5144 out,
5145 )
5146 }
5147 Self::getAppointees(inner) => {
5148 <getAppointeesCall as alloy_sol_types::SolCall>::abi_encode_raw(
5149 inner,
5150 out,
5151 )
5152 }
5153 Self::getPendingAdmins(inner) => {
5154 <getPendingAdminsCall as alloy_sol_types::SolCall>::abi_encode_raw(
5155 inner,
5156 out,
5157 )
5158 }
5159 Self::isAdmin(inner) => {
5160 <isAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5161 }
5162 Self::isPendingAdmin(inner) => {
5163 <isPendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
5164 inner,
5165 out,
5166 )
5167 }
5168 Self::removeAdmin(inner) => {
5169 <removeAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
5170 inner,
5171 out,
5172 )
5173 }
5174 Self::removeAppointee(inner) => {
5175 <removeAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
5176 inner,
5177 out,
5178 )
5179 }
5180 Self::removePendingAdmin(inner) => {
5181 <removePendingAdminCall as alloy_sol_types::SolCall>::abi_encode_raw(
5182 inner,
5183 out,
5184 )
5185 }
5186 Self::setAppointee(inner) => {
5187 <setAppointeeCall as alloy_sol_types::SolCall>::abi_encode_raw(
5188 inner,
5189 out,
5190 )
5191 }
5192 Self::version(inner) => {
5193 <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
5194 }
5195 }
5196 }
5197 }
5198 #[derive(serde::Serialize, serde::Deserialize)]
5200 #[derive(Debug, PartialEq, Eq, Hash)]
5201 pub enum PermissionControllerErrors {
5202 #[allow(missing_docs)]
5203 AdminAlreadyPending(AdminAlreadyPending),
5204 #[allow(missing_docs)]
5205 AdminAlreadySet(AdminAlreadySet),
5206 #[allow(missing_docs)]
5207 AdminNotPending(AdminNotPending),
5208 #[allow(missing_docs)]
5209 AdminNotSet(AdminNotSet),
5210 #[allow(missing_docs)]
5211 AppointeeAlreadySet(AppointeeAlreadySet),
5212 #[allow(missing_docs)]
5213 AppointeeNotSet(AppointeeNotSet),
5214 #[allow(missing_docs)]
5215 CannotHaveZeroAdmins(CannotHaveZeroAdmins),
5216 #[allow(missing_docs)]
5217 InvalidShortString(InvalidShortString),
5218 #[allow(missing_docs)]
5219 NotAdmin(NotAdmin),
5220 #[allow(missing_docs)]
5221 StringTooLong(StringTooLong),
5222 }
5223 #[automatically_derived]
5224 impl PermissionControllerErrors {
5225 pub const SELECTORS: &'static [[u8; 4usize]] = &[
5232 [38u8, 33u8, 24u8, 205u8],
5233 [48u8, 90u8, 39u8, 169u8],
5234 [51u8, 87u8, 219u8, 198u8],
5235 [123u8, 250u8, 75u8, 159u8],
5236 [134u8, 116u8, 73u8, 88u8],
5237 [152u8, 11u8, 7u8, 40u8],
5238 [173u8, 142u8, 254u8, 183u8],
5239 [179u8, 81u8, 43u8, 12u8],
5240 [190u8, 216u8, 41u8, 95u8],
5241 [226u8, 219u8, 3u8, 96u8],
5242 ];
5243 }
5244 #[automatically_derived]
5245 impl alloy_sol_types::SolInterface for PermissionControllerErrors {
5246 const NAME: &'static str = "PermissionControllerErrors";
5247 const MIN_DATA_LENGTH: usize = 0usize;
5248 const COUNT: usize = 10usize;
5249 #[inline]
5250 fn selector(&self) -> [u8; 4] {
5251 match self {
5252 Self::AdminAlreadyPending(_) => {
5253 <AdminAlreadyPending as alloy_sol_types::SolError>::SELECTOR
5254 }
5255 Self::AdminAlreadySet(_) => {
5256 <AdminAlreadySet as alloy_sol_types::SolError>::SELECTOR
5257 }
5258 Self::AdminNotPending(_) => {
5259 <AdminNotPending as alloy_sol_types::SolError>::SELECTOR
5260 }
5261 Self::AdminNotSet(_) => {
5262 <AdminNotSet as alloy_sol_types::SolError>::SELECTOR
5263 }
5264 Self::AppointeeAlreadySet(_) => {
5265 <AppointeeAlreadySet as alloy_sol_types::SolError>::SELECTOR
5266 }
5267 Self::AppointeeNotSet(_) => {
5268 <AppointeeNotSet as alloy_sol_types::SolError>::SELECTOR
5269 }
5270 Self::CannotHaveZeroAdmins(_) => {
5271 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::SELECTOR
5272 }
5273 Self::InvalidShortString(_) => {
5274 <InvalidShortString as alloy_sol_types::SolError>::SELECTOR
5275 }
5276 Self::NotAdmin(_) => <NotAdmin as alloy_sol_types::SolError>::SELECTOR,
5277 Self::StringTooLong(_) => {
5278 <StringTooLong as alloy_sol_types::SolError>::SELECTOR
5279 }
5280 }
5281 }
5282 #[inline]
5283 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
5284 Self::SELECTORS.get(i).copied()
5285 }
5286 #[inline]
5287 fn valid_selector(selector: [u8; 4]) -> bool {
5288 Self::SELECTORS.binary_search(&selector).is_ok()
5289 }
5290 #[inline]
5291 #[allow(non_snake_case)]
5292 fn abi_decode_raw(
5293 selector: [u8; 4],
5294 data: &[u8],
5295 ) -> alloy_sol_types::Result<Self> {
5296 static DECODE_SHIMS: &[fn(
5297 &[u8],
5298 ) -> alloy_sol_types::Result<PermissionControllerErrors>] = &[
5299 {
5300 fn AppointeeNotSet(
5301 data: &[u8],
5302 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5303 <AppointeeNotSet as alloy_sol_types::SolError>::abi_decode_raw(
5304 data,
5305 )
5306 .map(PermissionControllerErrors::AppointeeNotSet)
5307 }
5308 AppointeeNotSet
5309 },
5310 {
5311 fn StringTooLong(
5312 data: &[u8],
5313 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5314 <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw(
5315 data,
5316 )
5317 .map(PermissionControllerErrors::StringTooLong)
5318 }
5319 StringTooLong
5320 },
5321 {
5322 fn AdminAlreadyPending(
5323 data: &[u8],
5324 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5325 <AdminAlreadyPending as alloy_sol_types::SolError>::abi_decode_raw(
5326 data,
5327 )
5328 .map(PermissionControllerErrors::AdminAlreadyPending)
5329 }
5330 AdminAlreadyPending
5331 },
5332 {
5333 fn NotAdmin(
5334 data: &[u8],
5335 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5336 <NotAdmin as alloy_sol_types::SolError>::abi_decode_raw(data)
5337 .map(PermissionControllerErrors::NotAdmin)
5338 }
5339 NotAdmin
5340 },
5341 {
5342 fn CannotHaveZeroAdmins(
5343 data: &[u8],
5344 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5345 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::abi_decode_raw(
5346 data,
5347 )
5348 .map(PermissionControllerErrors::CannotHaveZeroAdmins)
5349 }
5350 CannotHaveZeroAdmins
5351 },
5352 {
5353 fn AdminAlreadySet(
5354 data: &[u8],
5355 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5356 <AdminAlreadySet as alloy_sol_types::SolError>::abi_decode_raw(
5357 data,
5358 )
5359 .map(PermissionControllerErrors::AdminAlreadySet)
5360 }
5361 AdminAlreadySet
5362 },
5363 {
5364 fn AppointeeAlreadySet(
5365 data: &[u8],
5366 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5367 <AppointeeAlreadySet as alloy_sol_types::SolError>::abi_decode_raw(
5368 data,
5369 )
5370 .map(PermissionControllerErrors::AppointeeAlreadySet)
5371 }
5372 AppointeeAlreadySet
5373 },
5374 {
5375 fn InvalidShortString(
5376 data: &[u8],
5377 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5378 <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw(
5379 data,
5380 )
5381 .map(PermissionControllerErrors::InvalidShortString)
5382 }
5383 InvalidShortString
5384 },
5385 {
5386 fn AdminNotPending(
5387 data: &[u8],
5388 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5389 <AdminNotPending as alloy_sol_types::SolError>::abi_decode_raw(
5390 data,
5391 )
5392 .map(PermissionControllerErrors::AdminNotPending)
5393 }
5394 AdminNotPending
5395 },
5396 {
5397 fn AdminNotSet(
5398 data: &[u8],
5399 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5400 <AdminNotSet as alloy_sol_types::SolError>::abi_decode_raw(data)
5401 .map(PermissionControllerErrors::AdminNotSet)
5402 }
5403 AdminNotSet
5404 },
5405 ];
5406 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5407 return Err(
5408 alloy_sol_types::Error::unknown_selector(
5409 <Self as alloy_sol_types::SolInterface>::NAME,
5410 selector,
5411 ),
5412 );
5413 };
5414 DECODE_SHIMS[idx](data)
5415 }
5416 #[inline]
5417 #[allow(non_snake_case)]
5418 fn abi_decode_raw_validate(
5419 selector: [u8; 4],
5420 data: &[u8],
5421 ) -> alloy_sol_types::Result<Self> {
5422 static DECODE_VALIDATE_SHIMS: &[fn(
5423 &[u8],
5424 ) -> alloy_sol_types::Result<PermissionControllerErrors>] = &[
5425 {
5426 fn AppointeeNotSet(
5427 data: &[u8],
5428 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5429 <AppointeeNotSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
5430 data,
5431 )
5432 .map(PermissionControllerErrors::AppointeeNotSet)
5433 }
5434 AppointeeNotSet
5435 },
5436 {
5437 fn StringTooLong(
5438 data: &[u8],
5439 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5440 <StringTooLong as alloy_sol_types::SolError>::abi_decode_raw_validate(
5441 data,
5442 )
5443 .map(PermissionControllerErrors::StringTooLong)
5444 }
5445 StringTooLong
5446 },
5447 {
5448 fn AdminAlreadyPending(
5449 data: &[u8],
5450 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5451 <AdminAlreadyPending as alloy_sol_types::SolError>::abi_decode_raw_validate(
5452 data,
5453 )
5454 .map(PermissionControllerErrors::AdminAlreadyPending)
5455 }
5456 AdminAlreadyPending
5457 },
5458 {
5459 fn NotAdmin(
5460 data: &[u8],
5461 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5462 <NotAdmin as alloy_sol_types::SolError>::abi_decode_raw_validate(
5463 data,
5464 )
5465 .map(PermissionControllerErrors::NotAdmin)
5466 }
5467 NotAdmin
5468 },
5469 {
5470 fn CannotHaveZeroAdmins(
5471 data: &[u8],
5472 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5473 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::abi_decode_raw_validate(
5474 data,
5475 )
5476 .map(PermissionControllerErrors::CannotHaveZeroAdmins)
5477 }
5478 CannotHaveZeroAdmins
5479 },
5480 {
5481 fn AdminAlreadySet(
5482 data: &[u8],
5483 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5484 <AdminAlreadySet as alloy_sol_types::SolError>::abi_decode_raw_validate(
5485 data,
5486 )
5487 .map(PermissionControllerErrors::AdminAlreadySet)
5488 }
5489 AdminAlreadySet
5490 },
5491 {
5492 fn AppointeeAlreadySet(
5493 data: &[u8],
5494 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5495 <AppointeeAlreadySet as alloy_sol_types::SolError>::abi_decode_raw_validate(
5496 data,
5497 )
5498 .map(PermissionControllerErrors::AppointeeAlreadySet)
5499 }
5500 AppointeeAlreadySet
5501 },
5502 {
5503 fn InvalidShortString(
5504 data: &[u8],
5505 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5506 <InvalidShortString as alloy_sol_types::SolError>::abi_decode_raw_validate(
5507 data,
5508 )
5509 .map(PermissionControllerErrors::InvalidShortString)
5510 }
5511 InvalidShortString
5512 },
5513 {
5514 fn AdminNotPending(
5515 data: &[u8],
5516 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5517 <AdminNotPending as alloy_sol_types::SolError>::abi_decode_raw_validate(
5518 data,
5519 )
5520 .map(PermissionControllerErrors::AdminNotPending)
5521 }
5522 AdminNotPending
5523 },
5524 {
5525 fn AdminNotSet(
5526 data: &[u8],
5527 ) -> alloy_sol_types::Result<PermissionControllerErrors> {
5528 <AdminNotSet as alloy_sol_types::SolError>::abi_decode_raw_validate(
5529 data,
5530 )
5531 .map(PermissionControllerErrors::AdminNotSet)
5532 }
5533 AdminNotSet
5534 },
5535 ];
5536 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
5537 return Err(
5538 alloy_sol_types::Error::unknown_selector(
5539 <Self as alloy_sol_types::SolInterface>::NAME,
5540 selector,
5541 ),
5542 );
5543 };
5544 DECODE_VALIDATE_SHIMS[idx](data)
5545 }
5546 #[inline]
5547 fn abi_encoded_size(&self) -> usize {
5548 match self {
5549 Self::AdminAlreadyPending(inner) => {
5550 <AdminAlreadyPending as alloy_sol_types::SolError>::abi_encoded_size(
5551 inner,
5552 )
5553 }
5554 Self::AdminAlreadySet(inner) => {
5555 <AdminAlreadySet as alloy_sol_types::SolError>::abi_encoded_size(
5556 inner,
5557 )
5558 }
5559 Self::AdminNotPending(inner) => {
5560 <AdminNotPending as alloy_sol_types::SolError>::abi_encoded_size(
5561 inner,
5562 )
5563 }
5564 Self::AdminNotSet(inner) => {
5565 <AdminNotSet as alloy_sol_types::SolError>::abi_encoded_size(inner)
5566 }
5567 Self::AppointeeAlreadySet(inner) => {
5568 <AppointeeAlreadySet as alloy_sol_types::SolError>::abi_encoded_size(
5569 inner,
5570 )
5571 }
5572 Self::AppointeeNotSet(inner) => {
5573 <AppointeeNotSet as alloy_sol_types::SolError>::abi_encoded_size(
5574 inner,
5575 )
5576 }
5577 Self::CannotHaveZeroAdmins(inner) => {
5578 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::abi_encoded_size(
5579 inner,
5580 )
5581 }
5582 Self::InvalidShortString(inner) => {
5583 <InvalidShortString as alloy_sol_types::SolError>::abi_encoded_size(
5584 inner,
5585 )
5586 }
5587 Self::NotAdmin(inner) => {
5588 <NotAdmin as alloy_sol_types::SolError>::abi_encoded_size(inner)
5589 }
5590 Self::StringTooLong(inner) => {
5591 <StringTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
5592 }
5593 }
5594 }
5595 #[inline]
5596 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
5597 match self {
5598 Self::AdminAlreadyPending(inner) => {
5599 <AdminAlreadyPending as alloy_sol_types::SolError>::abi_encode_raw(
5600 inner,
5601 out,
5602 )
5603 }
5604 Self::AdminAlreadySet(inner) => {
5605 <AdminAlreadySet as alloy_sol_types::SolError>::abi_encode_raw(
5606 inner,
5607 out,
5608 )
5609 }
5610 Self::AdminNotPending(inner) => {
5611 <AdminNotPending as alloy_sol_types::SolError>::abi_encode_raw(
5612 inner,
5613 out,
5614 )
5615 }
5616 Self::AdminNotSet(inner) => {
5617 <AdminNotSet as alloy_sol_types::SolError>::abi_encode_raw(
5618 inner,
5619 out,
5620 )
5621 }
5622 Self::AppointeeAlreadySet(inner) => {
5623 <AppointeeAlreadySet as alloy_sol_types::SolError>::abi_encode_raw(
5624 inner,
5625 out,
5626 )
5627 }
5628 Self::AppointeeNotSet(inner) => {
5629 <AppointeeNotSet as alloy_sol_types::SolError>::abi_encode_raw(
5630 inner,
5631 out,
5632 )
5633 }
5634 Self::CannotHaveZeroAdmins(inner) => {
5635 <CannotHaveZeroAdmins as alloy_sol_types::SolError>::abi_encode_raw(
5636 inner,
5637 out,
5638 )
5639 }
5640 Self::InvalidShortString(inner) => {
5641 <InvalidShortString as alloy_sol_types::SolError>::abi_encode_raw(
5642 inner,
5643 out,
5644 )
5645 }
5646 Self::NotAdmin(inner) => {
5647 <NotAdmin as alloy_sol_types::SolError>::abi_encode_raw(inner, out)
5648 }
5649 Self::StringTooLong(inner) => {
5650 <StringTooLong as alloy_sol_types::SolError>::abi_encode_raw(
5651 inner,
5652 out,
5653 )
5654 }
5655 }
5656 }
5657 }
5658 #[derive(serde::Serialize, serde::Deserialize)]
5660 #[derive(Debug, PartialEq, Eq, Hash)]
5661 pub enum PermissionControllerEvents {
5662 #[allow(missing_docs)]
5663 AdminRemoved(AdminRemoved),
5664 #[allow(missing_docs)]
5665 AdminSet(AdminSet),
5666 #[allow(missing_docs)]
5667 AppointeeRemoved(AppointeeRemoved),
5668 #[allow(missing_docs)]
5669 AppointeeSet(AppointeeSet),
5670 #[allow(missing_docs)]
5671 Initialized(Initialized),
5672 #[allow(missing_docs)]
5673 PendingAdminAdded(PendingAdminAdded),
5674 #[allow(missing_docs)]
5675 PendingAdminRemoved(PendingAdminRemoved),
5676 }
5677 #[automatically_derived]
5678 impl PermissionControllerEvents {
5679 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5686 [
5687 3u8, 127u8, 3u8, 162u8, 173u8, 107u8, 150u8, 125u8, 244u8, 160u8, 23u8,
5688 121u8, 182u8, 210u8, 180u8, 200u8, 89u8, 80u8, 223u8, 131u8, 146u8, 93u8,
5689 158u8, 49u8, 54u8, 43u8, 81u8, 148u8, 34u8, 252u8, 1u8, 105u8,
5690 ],
5691 [
5692 24u8, 36u8, 35u8, 38u8, 182u8, 184u8, 98u8, 18u8, 105u8, 112u8, 103u8,
5693 151u8, 89u8, 22u8, 159u8, 1u8, 246u8, 70u8, 189u8, 85u8, 236u8, 91u8,
5694 252u8, 171u8, 133u8, 186u8, 159u8, 51u8, 122u8, 116u8, 224u8, 198u8,
5695 ],
5696 [
5697 127u8, 38u8, 184u8, 63u8, 249u8, 110u8, 31u8, 43u8, 106u8, 104u8, 47u8,
5698 19u8, 56u8, 82u8, 246u8, 121u8, 138u8, 9u8, 196u8, 101u8, 218u8, 149u8,
5699 146u8, 20u8, 96u8, 206u8, 251u8, 56u8, 71u8, 64u8, 36u8, 152u8,
5700 ],
5701 [
5702 177u8, 75u8, 154u8, 61u8, 68u8, 140u8, 91u8, 4u8, 240u8, 229u8, 176u8,
5703 135u8, 182u8, 245u8, 25u8, 51u8, 144u8, 219u8, 121u8, 85u8, 72u8, 42u8,
5704 111u8, 251u8, 132u8, 30u8, 123u8, 59u8, 166u8, 26u8, 70u8, 12u8,
5705 ],
5706 [
5707 191u8, 38u8, 94u8, 131u8, 38u8, 40u8, 90u8, 39u8, 71u8, 227u8, 62u8,
5708 84u8, 213u8, 148u8, 95u8, 113u8, 17u8, 242u8, 181u8, 237u8, 184u8, 38u8,
5709 235u8, 140u8, 8u8, 212u8, 103u8, 119u8, 121u8, 179u8, 255u8, 151u8,
5710 ],
5711 [
5712 215u8, 6u8, 237u8, 122u8, 224u8, 68u8, 215u8, 149u8, 180u8, 158u8, 84u8,
5713 201u8, 245u8, 25u8, 246u8, 99u8, 5u8, 57u8, 81u8, 1u8, 25u8, 133u8,
5714 246u8, 99u8, 168u8, 98u8, 205u8, 158u8, 231u8, 42u8, 154u8, 199u8,
5715 ],
5716 [
5717 219u8, 157u8, 93u8, 49u8, 50u8, 13u8, 175u8, 91u8, 199u8, 24u8, 29u8,
5718 86u8, 91u8, 109u8, 164u8, 209u8, 46u8, 48u8, 240u8, 244u8, 213u8, 170u8,
5719 50u8, 74u8, 153u8, 36u8, 38u8, 193u8, 74u8, 29u8, 25u8, 206u8,
5720 ],
5721 ];
5722 }
5723 #[automatically_derived]
5724 impl alloy_sol_types::SolEventInterface for PermissionControllerEvents {
5725 const NAME: &'static str = "PermissionControllerEvents";
5726 const COUNT: usize = 7usize;
5727 fn decode_raw_log(
5728 topics: &[alloy_sol_types::Word],
5729 data: &[u8],
5730 ) -> alloy_sol_types::Result<Self> {
5731 match topics.first().copied() {
5732 Some(<AdminRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5733 <AdminRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
5734 topics,
5735 data,
5736 )
5737 .map(Self::AdminRemoved)
5738 }
5739 Some(<AdminSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5740 <AdminSet as alloy_sol_types::SolEvent>::decode_raw_log(topics, data)
5741 .map(Self::AdminSet)
5742 }
5743 Some(<AppointeeRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5744 <AppointeeRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
5745 topics,
5746 data,
5747 )
5748 .map(Self::AppointeeRemoved)
5749 }
5750 Some(<AppointeeSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5751 <AppointeeSet as alloy_sol_types::SolEvent>::decode_raw_log(
5752 topics,
5753 data,
5754 )
5755 .map(Self::AppointeeSet)
5756 }
5757 Some(<Initialized as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5758 <Initialized as alloy_sol_types::SolEvent>::decode_raw_log(
5759 topics,
5760 data,
5761 )
5762 .map(Self::Initialized)
5763 }
5764 Some(
5765 <PendingAdminAdded as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5766 ) => {
5767 <PendingAdminAdded as alloy_sol_types::SolEvent>::decode_raw_log(
5768 topics,
5769 data,
5770 )
5771 .map(Self::PendingAdminAdded)
5772 }
5773 Some(
5774 <PendingAdminRemoved as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5775 ) => {
5776 <PendingAdminRemoved as alloy_sol_types::SolEvent>::decode_raw_log(
5777 topics,
5778 data,
5779 )
5780 .map(Self::PendingAdminRemoved)
5781 }
5782 _ => {
5783 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5784 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5785 log: alloy_sol_types::private::Box::new(
5786 alloy_sol_types::private::LogData::new_unchecked(
5787 topics.to_vec(),
5788 data.to_vec().into(),
5789 ),
5790 ),
5791 })
5792 }
5793 }
5794 }
5795 }
5796 #[automatically_derived]
5797 impl alloy_sol_types::private::IntoLogData for PermissionControllerEvents {
5798 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5799 match self {
5800 Self::AdminRemoved(inner) => {
5801 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5802 }
5803 Self::AdminSet(inner) => {
5804 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5805 }
5806 Self::AppointeeRemoved(inner) => {
5807 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5808 }
5809 Self::AppointeeSet(inner) => {
5810 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5811 }
5812 Self::Initialized(inner) => {
5813 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5814 }
5815 Self::PendingAdminAdded(inner) => {
5816 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5817 }
5818 Self::PendingAdminRemoved(inner) => {
5819 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5820 }
5821 }
5822 }
5823 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5824 match self {
5825 Self::AdminRemoved(inner) => {
5826 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5827 }
5828 Self::AdminSet(inner) => {
5829 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5830 }
5831 Self::AppointeeRemoved(inner) => {
5832 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5833 }
5834 Self::AppointeeSet(inner) => {
5835 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5836 }
5837 Self::Initialized(inner) => {
5838 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5839 }
5840 Self::PendingAdminAdded(inner) => {
5841 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5842 }
5843 Self::PendingAdminRemoved(inner) => {
5844 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5845 }
5846 }
5847 }
5848 }
5849 use alloy::contract as alloy_contract;
5850 #[inline]
5854 pub const fn new<
5855 P: alloy_contract::private::Provider<N>,
5856 N: alloy_contract::private::Network,
5857 >(
5858 address: alloy_sol_types::private::Address,
5859 provider: P,
5860 ) -> PermissionControllerInstance<P, N> {
5861 PermissionControllerInstance::<P, N>::new(address, provider)
5862 }
5863 #[inline]
5869 pub fn deploy<
5870 P: alloy_contract::private::Provider<N>,
5871 N: alloy_contract::private::Network,
5872 >(
5873 provider: P,
5874 _version: alloy::sol_types::private::String,
5875 ) -> impl ::core::future::Future<
5876 Output = alloy_contract::Result<PermissionControllerInstance<P, N>>,
5877 > {
5878 PermissionControllerInstance::<P, N>::deploy(provider, _version)
5879 }
5880 #[inline]
5886 pub fn deploy_builder<
5887 P: alloy_contract::private::Provider<N>,
5888 N: alloy_contract::private::Network,
5889 >(
5890 provider: P,
5891 _version: alloy::sol_types::private::String,
5892 ) -> alloy_contract::RawCallBuilder<P, N> {
5893 PermissionControllerInstance::<P, N>::deploy_builder(provider, _version)
5894 }
5895 #[derive(Clone)]
5907 pub struct PermissionControllerInstance<P, N = alloy_contract::private::Ethereum> {
5908 address: alloy_sol_types::private::Address,
5909 provider: P,
5910 _network: ::core::marker::PhantomData<N>,
5911 }
5912 #[automatically_derived]
5913 impl<P, N> ::core::fmt::Debug for PermissionControllerInstance<P, N> {
5914 #[inline]
5915 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5916 f.debug_tuple("PermissionControllerInstance").field(&self.address).finish()
5917 }
5918 }
5919 #[automatically_derived]
5921 impl<
5922 P: alloy_contract::private::Provider<N>,
5923 N: alloy_contract::private::Network,
5924 > PermissionControllerInstance<P, N> {
5925 #[inline]
5929 pub const fn new(
5930 address: alloy_sol_types::private::Address,
5931 provider: P,
5932 ) -> Self {
5933 Self {
5934 address,
5935 provider,
5936 _network: ::core::marker::PhantomData,
5937 }
5938 }
5939 #[inline]
5945 pub async fn deploy(
5946 provider: P,
5947 _version: alloy::sol_types::private::String,
5948 ) -> alloy_contract::Result<PermissionControllerInstance<P, N>> {
5949 let call_builder = Self::deploy_builder(provider, _version);
5950 let contract_address = call_builder.deploy().await?;
5951 Ok(Self::new(contract_address, call_builder.provider))
5952 }
5953 #[inline]
5959 pub fn deploy_builder(
5960 provider: P,
5961 _version: alloy::sol_types::private::String,
5962 ) -> alloy_contract::RawCallBuilder<P, N> {
5963 alloy_contract::RawCallBuilder::new_raw_deploy(
5964 provider,
5965 [
5966 &BYTECODE[..],
5967 &alloy_sol_types::SolConstructor::abi_encode(
5968 &constructorCall { _version },
5969 )[..],
5970 ]
5971 .concat()
5972 .into(),
5973 )
5974 }
5975 #[inline]
5977 pub const fn address(&self) -> &alloy_sol_types::private::Address {
5978 &self.address
5979 }
5980 #[inline]
5982 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5983 self.address = address;
5984 }
5985 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5987 self.set_address(address);
5988 self
5989 }
5990 #[inline]
5992 pub const fn provider(&self) -> &P {
5993 &self.provider
5994 }
5995 }
5996 impl<P: ::core::clone::Clone, N> PermissionControllerInstance<&P, N> {
5997 #[inline]
5999 pub fn with_cloned_provider(self) -> PermissionControllerInstance<P, N> {
6000 PermissionControllerInstance {
6001 address: self.address,
6002 provider: ::core::clone::Clone::clone(&self.provider),
6003 _network: ::core::marker::PhantomData,
6004 }
6005 }
6006 }
6007 #[automatically_derived]
6009 impl<
6010 P: alloy_contract::private::Provider<N>,
6011 N: alloy_contract::private::Network,
6012 > PermissionControllerInstance<P, N> {
6013 pub fn call_builder<C: alloy_sol_types::SolCall>(
6018 &self,
6019 call: &C,
6020 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
6021 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
6022 }
6023 pub fn acceptAdmin(
6025 &self,
6026 account: alloy::sol_types::private::Address,
6027 ) -> alloy_contract::SolCallBuilder<&P, acceptAdminCall, N> {
6028 self.call_builder(&acceptAdminCall { account })
6029 }
6030 pub fn addPendingAdmin(
6032 &self,
6033 account: alloy::sol_types::private::Address,
6034 admin: alloy::sol_types::private::Address,
6035 ) -> alloy_contract::SolCallBuilder<&P, addPendingAdminCall, N> {
6036 self.call_builder(
6037 &addPendingAdminCall {
6038 account,
6039 admin,
6040 },
6041 )
6042 }
6043 pub fn canCall(
6045 &self,
6046 account: alloy::sol_types::private::Address,
6047 caller: alloy::sol_types::private::Address,
6048 target: alloy::sol_types::private::Address,
6049 selector: alloy::sol_types::private::FixedBytes<4>,
6050 ) -> alloy_contract::SolCallBuilder<&P, canCallCall, N> {
6051 self.call_builder(
6052 &canCallCall {
6053 account,
6054 caller,
6055 target,
6056 selector,
6057 },
6058 )
6059 }
6060 pub fn getAdmins(
6062 &self,
6063 account: alloy::sol_types::private::Address,
6064 ) -> alloy_contract::SolCallBuilder<&P, getAdminsCall, N> {
6065 self.call_builder(&getAdminsCall { account })
6066 }
6067 pub fn getAppointeePermissions(
6069 &self,
6070 account: alloy::sol_types::private::Address,
6071 appointee: alloy::sol_types::private::Address,
6072 ) -> alloy_contract::SolCallBuilder<&P, getAppointeePermissionsCall, N> {
6073 self.call_builder(
6074 &getAppointeePermissionsCall {
6075 account,
6076 appointee,
6077 },
6078 )
6079 }
6080 pub fn getAppointees(
6082 &self,
6083 account: alloy::sol_types::private::Address,
6084 target: alloy::sol_types::private::Address,
6085 selector: alloy::sol_types::private::FixedBytes<4>,
6086 ) -> alloy_contract::SolCallBuilder<&P, getAppointeesCall, N> {
6087 self.call_builder(
6088 &getAppointeesCall {
6089 account,
6090 target,
6091 selector,
6092 },
6093 )
6094 }
6095 pub fn getPendingAdmins(
6097 &self,
6098 account: alloy::sol_types::private::Address,
6099 ) -> alloy_contract::SolCallBuilder<&P, getPendingAdminsCall, N> {
6100 self.call_builder(&getPendingAdminsCall { account })
6101 }
6102 pub fn isAdmin(
6104 &self,
6105 account: alloy::sol_types::private::Address,
6106 caller: alloy::sol_types::private::Address,
6107 ) -> alloy_contract::SolCallBuilder<&P, isAdminCall, N> {
6108 self.call_builder(&isAdminCall { account, caller })
6109 }
6110 pub fn isPendingAdmin(
6112 &self,
6113 account: alloy::sol_types::private::Address,
6114 pendingAdmin: alloy::sol_types::private::Address,
6115 ) -> alloy_contract::SolCallBuilder<&P, isPendingAdminCall, N> {
6116 self.call_builder(
6117 &isPendingAdminCall {
6118 account,
6119 pendingAdmin,
6120 },
6121 )
6122 }
6123 pub fn removeAdmin(
6125 &self,
6126 account: alloy::sol_types::private::Address,
6127 admin: alloy::sol_types::private::Address,
6128 ) -> alloy_contract::SolCallBuilder<&P, removeAdminCall, N> {
6129 self.call_builder(&removeAdminCall { account, admin })
6130 }
6131 pub fn removeAppointee(
6133 &self,
6134 account: alloy::sol_types::private::Address,
6135 appointee: alloy::sol_types::private::Address,
6136 target: alloy::sol_types::private::Address,
6137 selector: alloy::sol_types::private::FixedBytes<4>,
6138 ) -> alloy_contract::SolCallBuilder<&P, removeAppointeeCall, N> {
6139 self.call_builder(
6140 &removeAppointeeCall {
6141 account,
6142 appointee,
6143 target,
6144 selector,
6145 },
6146 )
6147 }
6148 pub fn removePendingAdmin(
6150 &self,
6151 account: alloy::sol_types::private::Address,
6152 admin: alloy::sol_types::private::Address,
6153 ) -> alloy_contract::SolCallBuilder<&P, removePendingAdminCall, N> {
6154 self.call_builder(
6155 &removePendingAdminCall {
6156 account,
6157 admin,
6158 },
6159 )
6160 }
6161 pub fn setAppointee(
6163 &self,
6164 account: alloy::sol_types::private::Address,
6165 appointee: alloy::sol_types::private::Address,
6166 target: alloy::sol_types::private::Address,
6167 selector: alloy::sol_types::private::FixedBytes<4>,
6168 ) -> alloy_contract::SolCallBuilder<&P, setAppointeeCall, N> {
6169 self.call_builder(
6170 &setAppointeeCall {
6171 account,
6172 appointee,
6173 target,
6174 selector,
6175 },
6176 )
6177 }
6178 pub fn version(&self) -> alloy_contract::SolCallBuilder<&P, versionCall, N> {
6180 self.call_builder(&versionCall)
6181 }
6182 }
6183 #[automatically_derived]
6185 impl<
6186 P: alloy_contract::private::Provider<N>,
6187 N: alloy_contract::private::Network,
6188 > PermissionControllerInstance<P, N> {
6189 pub fn event_filter<E: alloy_sol_types::SolEvent>(
6194 &self,
6195 ) -> alloy_contract::Event<&P, E, N> {
6196 alloy_contract::Event::new_sol(&self.provider, &self.address)
6197 }
6198 pub fn AdminRemoved_filter(&self) -> alloy_contract::Event<&P, AdminRemoved, N> {
6200 self.event_filter::<AdminRemoved>()
6201 }
6202 pub fn AdminSet_filter(&self) -> alloy_contract::Event<&P, AdminSet, N> {
6204 self.event_filter::<AdminSet>()
6205 }
6206 pub fn AppointeeRemoved_filter(
6208 &self,
6209 ) -> alloy_contract::Event<&P, AppointeeRemoved, N> {
6210 self.event_filter::<AppointeeRemoved>()
6211 }
6212 pub fn AppointeeSet_filter(&self) -> alloy_contract::Event<&P, AppointeeSet, N> {
6214 self.event_filter::<AppointeeSet>()
6215 }
6216 pub fn Initialized_filter(&self) -> alloy_contract::Event<&P, Initialized, N> {
6218 self.event_filter::<Initialized>()
6219 }
6220 pub fn PendingAdminAdded_filter(
6222 &self,
6223 ) -> alloy_contract::Event<&P, PendingAdminAdded, N> {
6224 self.event_filter::<PendingAdminAdded>()
6225 }
6226 pub fn PendingAdminRemoved_filter(
6228 &self,
6229 ) -> alloy_contract::Event<&P, PendingAdminRemoved, N> {
6230 self.event_filter::<PendingAdminRemoved>()
6231 }
6232 }
6233}