//#region node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_types/types/utils.d.ts
declare const symbol: unique symbol;
/**
 * Creates a branded type of {@link T} with the brand {@link U}.
 *
 * @param T - Type to brand
 * @param U - Label
 * @returns Branded type
 *
 * @example
 * type Result = Branded<string, 'foo'>
 * //   ^? type Result = string & { [symbol]: 'foo' }
 */
type Branded<T, U> = T & {
  [symbol]: U;
};
/**
 * Filters out all members of {@link T} that are not {@link P}
 *
 * @param T - Items to filter
 * @param P - Type to filter out
 * @returns Filtered items
 *
 * @example
 * type Result = Filter<['a', 'b', 'c'], 'b'>
 * //   ^? type Result = ['a', 'c']
 */
type Filter<T extends readonly unknown[], P, Acc extends readonly unknown[] = []> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]] ? [F] extends [P] ? Filter<Rest, P, [...Acc, F]> : Filter<Rest, P, Acc> : readonly [...Acc];
/**
 * @description Checks if {@link T} can be narrowed further than {@link U}
 * @param T - Type to check
 * @param U - Type to against
 * @example
 * type Result = IsNarrowable<'foo', string>
 * //   ^? true
 */
type IsNarrowable<T, U> = IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true ? false : true;
/**
 * @description Checks if {@link T} is `never`
 * @param T - Type to check
 * @example
 * type Result = IsNever<never>
 * //   ^? type Result = true
 */
type IsNever<T> = [T] extends [never] ? true : false;
/**
 * @description Checks if {@link T} is `undefined`
 * @param T - Type to check
 * @example
 * type Result = IsUndefined<undefined>
 * //   ^? type Result = true
 */
type IsUndefined<T> = [undefined] extends [T] ? true : false;
type MaybePromise<T> = T | Promise<T>;
/**
 * @description Makes attributes on the type T required if required is true.
 *
 * @example
 * MaybeRequired<{ a: string, b?: number }, true>
 * => { a: string, b: number }
 *
 * MaybeRequired<{ a: string, b?: number }, false>
 * => { a: string, b?: number }
 */
type MaybeRequired<T, required extends boolean> = required extends true ? ExactRequired<T> : T;
/**
 * @description Assigns the properties of U onto T.
 *
 * @example
 * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
 * => { a: undefined, b: number, c: boolean }
 */
type Assign<T, U> = Assign_<T, U> & U;
type Assign_<T, U> = { [K in keyof T as K extends keyof U ? U[K] extends void ? never : K : K]: K extends keyof U ? U[K] : T[K] };
type NoInfer<type> = [type][type extends any ? 0 : never];
/** Strict version of built-in Omit type */
type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
/**
 * @description Creates a type that is a partial of T, but with the required keys K.
 *
 * @example
 * PartialBy<{ a: string, b: number }, 'a'>
 * => { a?: string, b: number }
 */
type PartialBy<T, K extends keyof T> = Omit<T, K> & ExactPartial<Pick<T, K>>;
/**
 * @description Combines members of an intersection into a readable type.
 *
 * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
 * @example
 * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
 * => { a: string, b: string, c: number, d: bigint }
 */
type Prettify<T> = { [K in keyof T]: T[K] } & {};
/**
 * @description Creates a type that is T with the required keys K.
 *
 * @example
 * RequiredBy<{ a?: string, b: number }, 'a'>
 * => { a: string, b: number }
 */
type RequiredBy<T, K extends keyof T> = Omit<T, K> & ExactRequired<Pick<T, K>>;
/**
 * @description Returns truthy if `array` contains `value`.
 *
 * @example
 * Some<[1, 2, 3], 2>
 * => true
 */
type Some<array extends readonly unknown[], value> = array extends readonly [value, ...unknown[]] ? true : array extends readonly [unknown, ...infer rest] ? Some<rest, value> : false;
type UnionToTuple<union, last = LastInUnion<union>> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last];
type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends ((x: infer l) => 0) ? l : never;
type UnionToIntersection<union> = (union extends unknown ? (arg: union) => 0 : never) extends ((arg: infer i) => 0) ? i : never;
type IsUnion<union, union2 = union> = union extends union2 ? ([union2] extends [union] ? false : true) : never;
type MaybePartial<type, enabled extends boolean | undefined> = enabled extends true ? Prettify<ExactPartial<type>> : type;
type ExactPartial<type> = { [key in keyof type]?: type[key] | undefined };
type ExactRequired<type> = { [P in keyof type]-?: Exclude<type[P], undefined> };
type OneOf<union extends object, fallback extends object | undefined = undefined, keys extends KeyofUnion<union> = KeyofUnion<union>> = union extends infer item ? Prettify<item & { [key in Exclude<keys, keyof item>]?: fallback extends object ? key extends keyof fallback ? fallback[key] : undefined : undefined }> : never;
type KeyofUnion<type> = type extends type ? keyof type : never;
/**
 * Loose version of {@link Omit}
 * @internal
 */
type LooseOmit<type, keys extends string> = Pick<type, Exclude<keyof type, keys>>;
type UnionEvaluate<type> = type extends object ? Prettify<type> : type;
type UnionLooseOmit<type, keys extends string> = type extends any ? LooseOmit<type, keys> : never;
/**
 * @description Construct a type with the properties of union type T except for those in type K.
 * @example
 * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
 * => { b: number } | { b: undefined, c: number }
 */
type UnionOmit<type, keys extends keyof type> = type extends any ? Omit<type, keys> : never;
/**
 * @description Creates a type that is a partial of T, but with the required keys K.
 *
 * @example
 * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
 * => { a?: string, b: number } | { a?: string, b: undefined, c: number }
 */
type UnionPartialBy<T, K extends keyof T> = T extends any ? PartialBy<T, K> : never;
/**
 * @description Creates a type that is T with the required keys K.
 *
 * @example
 * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
 * => { a: string, b: number } | { a: string, c?: number }
 */
type UnionRequiredBy<T, K extends keyof T> = T extends any ? RequiredBy<T, K> : never;
//#endregion
//#region node_modules/.pnpm/viem@2.47.6_typescript@6.0.2_zod@4.3.6/node_modules/viem/_types/types/misc.d.ts
type ByteArray = Uint8Array;
type Hex = `0x${string}`;
type Hash = `0x${string}`;
type LogTopic = Hex | Hex[] | null;
type SignableMessage = string | {
  /** Raw data representation of the message. */raw: Hex | ByteArray;
};
type SignatureLegacy<bigintType = bigint> = {
  r: Hex;
  s: Hex;
  v: bigintType;
};
type Signature<numberType = number, bigintType = bigint> = OneOf<SignatureLegacy | {
  r: Hex;
  s: Hex; /** @deprecated use `yParity`. */
  v: bigintType;
  yParity?: numberType | undefined;
} | {
  r: Hex;
  s: Hex; /** @deprecated use `yParity`. */
  v?: bigintType | undefined;
  yParity: numberType;
}>;
//#endregion
export { UnionToTuple as A, RequiredBy as C, UnionOmit as D, UnionLooseOmit as E, UnionPartialBy as O, Prettify as S, UnionEvaluate as T, MaybeRequired as _, SignableMessage as a, OneOf as b, Branded as c, IsNarrowable as d, IsNever as f, MaybePromise as g, MaybePartial as h, LogTopic as i, UnionRequiredBy as k, ExactPartial as l, IsUnion as m, Hash as n, Signature as o, IsUndefined as p, Hex as r, Assign as s, ByteArray as t, Filter as u, NoInfer as v, Some as w, PartialBy as x, Omit as y };
//# sourceMappingURL=misc-BASHpEmW.d.mts.map