//#region node_modules/.pnpm/abitype@1.2.3_typescript@6.0.2_zod@4.3.6/node_modules/abitype/dist/types/register.d.ts
interface Register {}
type ResolvedRegister = {
  /**
   * TypeScript type to use for `address` values
   * @default `0x${string}`
   */
  addressType: Register extends {
    addressType: infer type;
  } ? type : Register extends {
    AddressType: infer type;
  } ? type : DefaultRegister['addressType'];
  /**
   * TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48`
   * @default bigint
   */
  bigIntType: Register extends {
    bigIntType: infer type;
  } ? type : Register extends {
    BigIntType: infer type;
  } ? type : DefaultRegister['bigIntType'];
  /**
   * TypeScript type to use for `bytes` values
   * @default { inputs: `0x${string}`; outputs: `0x${string}`; }
   */
  bytesType: Register extends {
    bytesType: infer type extends {
      inputs: unknown;
      outputs: unknown;
    };
  } ? type : Register extends {
    BytesType: infer type extends {
      inputs: unknown;
      outputs: unknown;
    };
  } ? type : DefaultRegister['bytesType'];
  /**
   * TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48`
   * @default number
   */
  intType: Register extends {
    intType: infer type;
  } ? type : Register extends {
    IntType: infer type;
  } ? type : DefaultRegister['intType'];
  /**
   * Maximum depth for nested array types (e.g. string[][])
   *
   * Note: You probably only want to set this to a specific number if parsed types are returning as `unknown`
   * and you want to figure out why. If you set this, you should probably also reduce `FixedArrayMaxLength`.
   *
   * @default false
   */
  arrayMaxDepth: Register extends {
    arrayMaxDepth: infer type extends number | false;
  } ? type : Register extends {
    ArrayMaxDepth: infer type extends number | false;
  } ? type : DefaultRegister['arrayMaxDepth'];
  /**
   * Lower bound for fixed array length
   * @default 1
   */
  fixedArrayMinLength: Register extends {
    fixedArrayMinLength: infer type extends number;
  } ? type : Register extends {
    FixedArrayMinLength: infer type extends number;
  } ? type : DefaultRegister['fixedArrayMinLength'];
  /**
   * Upper bound for fixed array length
   * @default 99
   */
  fixedArrayMaxLength: Register extends {
    fixedArrayMaxLength: infer type extends number;
  } ? type : Register extends {
    FixedArrayMaxLength: infer type extends number;
  } ? type : DefaultRegister['fixedArrayMaxLength'];
  /**
   * Enables named tuple generation in {@link AbiParametersToPrimitiveTypes} for common ABI parameter names.
   *
   * @default false
   */
  experimental_namedTuples: Register extends {
    experimental_namedTuples: infer type extends boolean;
  } ? type : DefaultRegister['experimental_namedTuples'];
  /**
   * When set, validates {@link AbiParameter}'s `type` against {@link AbiType}
   *
   * Note: You probably only want to set this to `true` if parsed types are returning as `unknown`
   * and you want to figure out why.
   *
   * @default false
   */
  strictAbiType: Register extends {
    strictAbiType: infer type extends boolean;
  } ? type : Register extends {
    StrictAbiType: infer type extends boolean;
  } ? type : DefaultRegister['strictAbiType']; /** @deprecated Use `addressType` instead */
  AddressType: ResolvedRegister['addressType']; /** @deprecated Use `addressType` instead */
  BigIntType: ResolvedRegister['bigIntType']; /** @deprecated Use `bytesType` instead */
  BytesType: ResolvedRegister['bytesType']; /** @deprecated Use `intType` instead */
  IntType: ResolvedRegister['intType']; /** @deprecated Use `arrayMaxDepth` instead */
  ArrayMaxDepth: ResolvedRegister['arrayMaxDepth']; /** @deprecated Use `fixedArrayMinLength` instead */
  FixedArrayMinLength: ResolvedRegister['fixedArrayMinLength']; /** @deprecated Use `fixedArrayMaxLength` instead */
  FixedArrayMaxLength: ResolvedRegister['fixedArrayMaxLength']; /** @deprecated Use `strictAbiType` instead */
  StrictAbiType: ResolvedRegister['strictAbiType'];
};
type DefaultRegister = {
  /** Maximum depth for nested array types (e.g. string[][]) */arrayMaxDepth: false; /** Lower bound for fixed array length */
  fixedArrayMinLength: 1; /** Upper bound for fixed array length */
  fixedArrayMaxLength: 99; /** TypeScript type to use for `address` values */
  addressType: `0x${string}`; /** TypeScript type to use for `bytes` values */
  bytesType: {
    /** TypeScript type to use for `bytes` input values */inputs: `0x${string}`; /** TypeScript type to use for `bytes` output values */
    outputs: `0x${string}`;
  }; /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M > 48` */
  bigIntType: bigint; /** TypeScript type to use for `int<M>` and `uint<M>` values, where `M <= 48` */
  intType: number; /** Enables named tuple generation in {@link AbiParametersToPrimitiveTypes} for common ABI parameter names */
  experimental_namedTuples: false; /** When set, validates {@link AbiParameter}'s `type` against {@link AbiType} */
  strictAbiType: false; /** @deprecated Use `arrayMaxDepth` instead */
  ArrayMaxDepth: DefaultRegister['arrayMaxDepth']; /** @deprecated Use `fixedArrayMinLength` instead */
  FixedArrayMinLength: DefaultRegister['fixedArrayMinLength']; /** @deprecated Use `fixedArrayMaxLength` instead */
  FixedArrayMaxLength: DefaultRegister['fixedArrayMaxLength']; /** @deprecated Use `addressType` instead */
  AddressType: DefaultRegister['addressType']; /** @deprecated Use `bytesType` instead */
  BytesType: {
    inputs: DefaultRegister['bytesType']['inputs'];
    outputs: DefaultRegister['bytesType']['outputs'];
  }; /** @deprecated Use `bigIntType` instead */
  BigIntType: DefaultRegister['bigIntType']; /** @deprecated Use `intType` instead */
  IntType: DefaultRegister['intType']; /** @deprecated Use `strictAbiType` instead */
  StrictAbiType: DefaultRegister['strictAbiType'];
};
//#endregion
//#region node_modules/.pnpm/abitype@1.2.3_typescript@6.0.2_zod@4.3.6/node_modules/abitype/dist/types/types.d.ts
/**
 * Prints custom error message
 *
 * @param messages - Error message
 * @returns Custom error message
 *
 * @example
 * type Result = Error<'Custom error message'>
 * //   ^? type Result = ['Error: Custom error message']
 */
type Error<messages extends string | string[]> = messages extends string ? [`Error: ${messages}`] : { [key in keyof messages]: messages[key] extends infer message extends string ? `Error: ${message}` : never };
/**
 * Merges two object types into new type
 *
 * @param object1 - Object to merge into
 * @param object2 - Object to merge and override keys from {@link object1}
 * @returns New object type with keys from {@link object1} and {@link object2}. If a key exists in both {@link object1} and {@link object2}, the key from {@link object2} will be used.
 *
 * @example
 * type Result = Merge<{ foo: string }, { foo: number; bar: string }>
 * //   ^? type Result = { foo: number; bar: string }
 */
type Merge<object1, object2> = Omit<object1, keyof object2> & object2;
/**
 * Combines members of an intersection into a readable type.
 *
 * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
 * @example
 * type Result = Pretty<{ a: string } | { b: string } | { c: number, d: bigint }>
 * //   ^? type Result = { a: string; b: string; c: number; d: bigint }
 */
type Pretty<type> = { [key in keyof type]: type[key] } & unknown;
/**
 * Creates range between two positive numbers using [tail recursion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#tail-recursion-elimination-on-conditional-types).
 *
 * @param start - Number to start range
 * @param stop - Number to end range
 * @returns Array with inclusive range from {@link start} to {@link stop}
 *
 * @example
 * type Result = Range<1, 3>
 * //   ^? type Result = [1, 2, 3]
 */
type Range<start extends number, stop extends number, result extends number[] = [], padding extends 0[] = [], current extends number = [...padding, ...result]['length'] & number> = current extends stop ? current extends start ? [current] : result extends [] ? [] : [...result, current] : current extends start ? Range<start, stop, [current], padding> : result extends [] ? Range<start, stop, [], [...padding, 0]> : Range<start, stop, [...result, current], padding>;
/**
 * Create tuple of {@link type} type with {@link size} size
 *
 * @param Type - Type of tuple
 * @param Size - Size of tuple
 * @returns Tuple of {@link type} type with {@link size} size
 *
 * @example
 * type Result = Tuple<string, 2>
 * //   ^? type Result = [string, string]
 */
type Tuple<type, size extends number> = size extends size ? number extends size ? type[] : _TupleOf<type, size, []> : never;
type _TupleOf<length, size extends number, acc extends readonly unknown[]> = acc['length'] extends size ? acc : _TupleOf<length, size, readonly [length, ...acc]>;
//#endregion
//#region node_modules/.pnpm/abitype@1.2.3_typescript@6.0.2_zod@4.3.6/node_modules/abitype/dist/types/abi.d.ts
type Address = ResolvedRegister['addressType'];
type MBytes = '' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32;
type MBits = '' | 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 | 104 | 112 | 120 | 128 | 136 | 144 | 152 | 160 | 168 | 176 | 184 | 192 | 200 | 208 | 216 | 224 | 232 | 240 | 248 | 256;
type SolidityAddress = 'address';
type SolidityBool = 'bool';
type SolidityBytes = `bytes${MBytes}`;
type SolidityFunction = 'function';
type SolidityString = 'string';
type SolidityTuple = 'tuple';
type SolidityInt = `${'u' | ''}int${MBits}`;
type SolidityFixedArrayRange = Range<ResolvedRegister['fixedArrayMinLength'], ResolvedRegister['fixedArrayMaxLength']>[number];
type SolidityFixedArraySizeLookup = { [Prop in SolidityFixedArrayRange as `${Prop}`]: Prop };
/**
 * Recursively build arrays up to maximum depth
 * or use a more broad type when maximum depth is switched "off"
 */
type _BuildArrayTypes<T extends string, Depth extends readonly number[] = []> = ResolvedRegister['arrayMaxDepth'] extends false ? `${T}[${string}]` : Depth['length'] extends ResolvedRegister['arrayMaxDepth'] ? T : T extends `${any}[${SolidityFixedArrayRange | ''}]` ? _BuildArrayTypes<T | `${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]> : _BuildArrayTypes<`${T}[${SolidityFixedArrayRange | ''}]`, [...Depth, 1]>;
type SolidityArrayWithoutTuple = _BuildArrayTypes<SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString>;
type SolidityArrayWithTuple = _BuildArrayTypes<SolidityTuple>;
type SolidityArray = SolidityArrayWithoutTuple | SolidityArrayWithTuple;
type AbiType = SolidityArray | SolidityAddress | SolidityBool | SolidityBytes | SolidityFunction | SolidityInt | SolidityString | SolidityTuple;
type ResolvedAbiType = ResolvedRegister['strictAbiType'] extends true ? AbiType : string;
type AbiInternalType = ResolvedAbiType | `address ${string}` | `contract ${string}` | `enum ${string}` | `struct ${string}`;
type AbiParameter = Pretty<{
  type: ResolvedAbiType;
  name?: string | undefined; /** Representation used by Solidity compiler */
  internalType?: AbiInternalType | undefined;
} & ({
  type: Exclude<ResolvedAbiType, SolidityTuple | SolidityArrayWithTuple>;
} | {
  type: SolidityTuple | SolidityArrayWithTuple;
  components: readonly AbiParameter[];
})>;
type AbiEventParameter = AbiParameter & {
  indexed?: boolean | undefined;
};
/**
 * State mutability for {@link AbiFunction}
 *
 * @see https://docs.soliditylang.org/en/latest/contracts.html#state-mutability
 */
type AbiStateMutability = 'pure' | 'view' | 'nonpayable' | 'payable';
/** Kind of {@link AbiParameter} */
type AbiParameterKind = 'inputs' | 'outputs';
/** ABI ["function"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
type AbiFunction = {
  type: 'function';
  /**
   * @deprecated use `pure` or `view` from {@link AbiStateMutability} instead
   * @see https://github.com/ethereum/solidity/issues/992
   */
  constant?: boolean | undefined;
  /**
   * @deprecated Vyper used to provide gas estimates
   * @see https://github.com/vyperlang/vyper/issues/2151
   */
  gas?: number | undefined;
  inputs: readonly AbiParameter[];
  name: string;
  outputs: readonly AbiParameter[];
  /**
   * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
   * @see https://github.com/ethereum/solidity/issues/992
   */
  payable?: boolean | undefined;
  stateMutability: AbiStateMutability;
};
/** ABI ["constructor"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
type AbiConstructor = {
  type: 'constructor';
  inputs: readonly AbiParameter[];
  /**
   * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
   * @see https://github.com/ethereum/solidity/issues/992
   */
  payable?: boolean | undefined;
  stateMutability: Extract<AbiStateMutability, 'payable' | 'nonpayable'>;
};
/** ABI ["fallback"](https://docs.soliditylang.org/en/latest/abi-spec.html#json) type */
type AbiFallback = {
  type: 'fallback';
  /**
   * @deprecated use `payable` or `nonpayable` from {@link AbiStateMutability} instead
   * @see https://github.com/ethereum/solidity/issues/992
   */
  payable?: boolean | undefined;
  stateMutability: Extract<AbiStateMutability, 'payable' | 'nonpayable'>;
};
/** ABI ["receive"](https://docs.soliditylang.org/en/latest/contracts.html#receive-ether-function) type */
type AbiReceive = {
  type: 'receive';
  stateMutability: Extract<AbiStateMutability, 'payable'>;
};
/** ABI ["event"](https://docs.soliditylang.org/en/latest/abi-spec.html#events) type */
type AbiEvent = {
  type: 'event';
  anonymous?: boolean | undefined;
  inputs: readonly AbiEventParameter[];
  name: string;
};
/** ABI ["error"](https://docs.soliditylang.org/en/latest/abi-spec.html#errors) type */
type AbiError = {
  type: 'error';
  inputs: readonly AbiParameter[];
  name: string;
};
/**
 * Contract [ABI Specification](https://docs.soliditylang.org/en/latest/abi-spec.html#json)
 */
type Abi = readonly (AbiConstructor | AbiError | AbiEvent | AbiFallback | AbiFunction | AbiReceive)[];
type TypedDataDomain = {
  chainId?: number | bigint | undefined;
  name?: string | undefined;
  salt?: ResolvedRegister['bytesType']['outputs'] | undefined;
  verifyingContract?: Address | undefined;
  version?: string | undefined;
};
type TypedDataType = Exclude<AbiType, SolidityFunction | SolidityTuple | SolidityArrayWithTuple | 'int' | 'uint'>;
type TypedDataParameter = {
  name: string;
  type: TypedDataType | keyof TypedData | `${keyof TypedData}[${string | ''}]`;
};
/**
 * [EIP-712](https://eips.ethereum.org/EIPS/eip-712#definition-of-typed-structured-data-%F0%9D%95%8A) Typed Data Specification
 */
type TypedData = Pretty<Record<string, readonly TypedDataParameter[]> & { [_ in TypedDataType]?: never }>;
//#endregion
export { Tuple as C, Pretty as S, TypedDataDomain as _, AbiParameterKind as a, Error as b, Address as c, SolidityBytes as d, SolidityFixedArrayRange as f, TypedData as g, SolidityTuple as h, AbiParameter as i, MBits as l, SolidityInt as m, AbiEvent as n, AbiStateMutability as o, SolidityFixedArraySizeLookup as p, AbiFunction as r, AbiType as s, Abi as t, SolidityArray as u, TypedDataParameter as v, ResolvedRegister as w, Merge as x, TypedDataType as y };
//# sourceMappingURL=abi-Bjd7pZee.d.mts.map