@aragon/gov-ui-kit 1.28.0 → 1.29.1

package/dist/types/node_modules/.pnpm/ox@0.12.1_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/WebAuthnP256.d.ts

@@ -1,423 +0,0 @@
-import * as Base64 from './Base64.js';
-import * as Bytes from './Bytes.js';
-import * as Errors from './Errors.js';
-import * as Hash from './Hash.js';
-import * as Hex from './Hex.js';
-import type { Compute, OneOf } from './internal/types.js';
-import * as internal from './internal/webauthn.js';
-import * as P256 from './P256.js';
-import type * as PublicKey from './PublicKey.js';
-import type * as Signature from './Signature.js';
-/** A WebAuthn-flavored P256 credential. */
-export type P256Credential = {
-    id: string;
-    publicKey: PublicKey.PublicKey;
-    raw: internal.PublicKeyCredential;
-};
-/** Metadata for a WebAuthn P256 signature. */
-export type SignMetadata = Compute<{
-    authenticatorData: Hex.Hex;
-    challengeIndex?: number | undefined;
-    clientDataJSON: string;
-    typeIndex?: number | undefined;
-    userVerificationRequired?: boolean | undefined;
-}>;
-export declare const createChallenge: Uint8Array<ArrayBuffer>;
-/**
- * Creates a new WebAuthn P256 Credential, which can be stored and later used for signing.
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
- *
- * const credential = await WebAuthnP256.createCredential({ name: 'Example' }) // [!code focus]
- * // @log: {
- * // @log:   id: 'oZ48...',
- * // @log:   publicKey: { x: 51421...5123n, y: 12345...6789n },
- * // @log:   raw: PublicKeyCredential {},
- * // @log: }
- *
- * const { metadata, signature } = await WebAuthnP256.sign({
- *   credentialId: credential.id,
- *   challenge: '0xdeadbeef',
- * })
- * ```
- *
- * @param options - Credential creation options.
- * @returns A WebAuthn P256 credential.
- */
-export declare function createCredential(options: createCredential.Options): Promise<P256Credential>;
-export declare namespace createCredential {
-    type Options = getCredentialCreationOptions.Options & {
-        /**
-         * Credential creation function. Useful for environments that do not support
-         * the WebAuthn API natively (i.e. React Native or testing environments).
-         *
-         * @default window.navigator.credentials.create
-         */
-        createFn?: ((options?: internal.CredentialCreationOptions | undefined) => Promise<internal.Credential | null>) | undefined;
-    };
-    type ErrorType = getCredentialCreationOptions.ErrorType | internal.parseCredentialPublicKey.ErrorType | Errors.GlobalErrorType;
-}
-/**
- * Gets the authenticator data which contains information about the
- * processing of an authenticator request (ie. from `WebAuthnP256.sign`).
- *
- * :::warning
- *
- * This function is mainly for testing purposes or for manually constructing
- * autenticator data. In most cases you will not need this function.
- * `authenticatorData` is typically returned as part of the
- * {@link ox#WebAuthnP256.(sign:function)} response (ie. an authenticator response).
- *
- * :::
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
- *
- * const authenticatorData = WebAuthnP256.getAuthenticatorData({
- *   rpId: 'example.com',
- *   signCount: 420,
- * })
- * // @log: "0xa379a6f6eeafb9a55e378c118034e2751e682fab9f2d30ab13d2125586ce194705000001a4"
- * ```
- *
- * @param options - Options to construct the authenticator data.
- * @returns The authenticator data.
- */
-export declare function getAuthenticatorData(options?: getAuthenticatorData.Options): Hex.Hex;
-export declare namespace getAuthenticatorData {
-    type Options = {
-        /** A bitfield that indicates various attributes that were asserted by the authenticator. [Read more](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API/Authenticator_data#flags) */
-        flag?: number | undefined;
-        /** The [Relying Party ID](https://w3c.github.io/webauthn/#relying-party-identifier) that the credential is scoped to. */
-        rpId?: internal.PublicKeyCredentialRequestOptions['rpId'] | undefined;
-        /** A signature counter, if supported by the authenticator (set to 0 otherwise). */
-        signCount?: number | undefined;
-    };
-    type ErrorType = Errors.GlobalErrorType;
-}
-/**
- * Constructs the Client Data in stringified JSON format which represents client data that
- * was passed to `credentials.get()` in {@link ox#WebAuthnP256.(sign:function)}.
- *
- * :::warning
- *
- * This function is mainly for testing purposes or for manually constructing
- * client data. In most cases you will not need this function.
- * `clientDataJSON` is typically returned as part of the
- * {@link ox#WebAuthnP256.(sign:function)} response (ie. an authenticator response).
- *
- * :::
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
- *
- * const clientDataJSON = WebAuthnP256.getClientDataJSON({
- *   challenge: '0xdeadbeef',
- *   origin: 'https://example.com',
- * })
- * // @log: "{"type":"webauthn.get","challenge":"3q2-7w","origin":"https://example.com","crossOrigin":false}"
- * ```
- *
- * @param options - Options to construct the client data.
- * @returns The client data.
- */
-export declare function getClientDataJSON(options: getClientDataJSON.Options): string;
-export declare namespace getClientDataJSON {
-    type Options = {
-        /** The challenge to sign. */
-        challenge: Hex.Hex;
-        /** If set to `true`, it means that the calling context is an `<iframe>` that is not same origin with its ancestor frames. */
-        crossOrigin?: boolean | undefined;
-        /** Additional client data to include in the client data JSON. */
-        extraClientData?: Record<string, unknown> | undefined;
-        /** The fully qualified origin of the relying party which has been given by the client/browser to the authenticator. */
-        origin?: string | undefined;
-    };
-    type ErrorType = Errors.GlobalErrorType;
-}
-/**
- * Returns the creation options for a P256 WebAuthn Credential to be used with
- * the Web Authentication API.
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
- *
- * const options = WebAuthnP256.getCredentialCreationOptions({ name: 'Example' })
- *
- * const credential = await window.navigator.credentials.create(options)
- * ```
- *
- * @param options - Options.
- * @returns The credential creation options.
- */
-export declare function getCredentialCreationOptions(options: getCredentialCreationOptions.Options): internal.CredentialCreationOptions;
-export declare namespace getCredentialCreationOptions {
-    type Options = {
-        /**
-         * A string specifying the relying party's preference for how the attestation statement
-         * (i.e., provision of verifiable evidence of the authenticity of the authenticator and its data)
-         * is conveyed during credential creation.
-         */
-        attestation?: internal.PublicKeyCredentialCreationOptions['attestation'] | undefined;
-        /**
-         * An object whose properties are criteria used to filter out the potential authenticators
-         * for the credential creation operation.
-         */
-        authenticatorSelection?: internal.PublicKeyCredentialCreationOptions['authenticatorSelection'] | undefined;
-        /**
-         * An `ArrayBuffer`, `TypedArray`, or `DataView` used as a cryptographic challenge.
-         */
-        challenge?: Hex.Hex | internal.PublicKeyCredentialCreationOptions['challenge'] | undefined;
-        /**
-         * List of credential IDs to exclude from the creation. This property can be used
-         * to prevent creation of a credential if it already exists.
-         */
-        excludeCredentialIds?: readonly string[] | undefined;
-        /**
-         * List of Web Authentication API credentials to use during creation or authentication.
-         */
-        extensions?: internal.PublicKeyCredentialCreationOptions['extensions'] | undefined;
-        /**
-         * An object describing the relying party that requested the credential creation
-         */
-        rp?: {
-            id: string;
-            name: string;
-        } | undefined;
-        /**
-         * A numerical hint, in milliseconds, which indicates the time the calling web app is willing to wait for the creation operation to complete.
-         */
-        timeout?: internal.PublicKeyCredentialCreationOptions['timeout'] | undefined;
-    } & OneOf<{
-        /** Name for the credential (user.name). */
-        name: string;
-    } | {
-        /**
-         * An object describing the user account for which the credential is generated.
-         */
-        user: {
-            displayName?: string;
-            id?: BufferSource;
-            name: string;
-        };
-    }>;
-    type ErrorType = Base64.toBytes.ErrorType | Hash.keccak256.ErrorType | Bytes.fromString.ErrorType | Errors.GlobalErrorType;
-}
-/**
- * Returns the request options to sign a challenge with the Web Authentication API.
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
- *
- * const options = WebAuthnP256.getCredentialRequestOptions({
- *   challenge: '0xdeadbeef',
- * })
- *
- * const credential = await window.navigator.credentials.get(options)
- * ```
- *
- * @param options - Options.
- * @returns The credential request options.
- */
-export declare function getCredentialRequestOptions(options: getCredentialRequestOptions.Options): internal.CredentialRequestOptions;
-export declare namespace getCredentialRequestOptions {
-    type Options = {
-        /** The credential ID to use. */
-        credentialId?: string | string[] | undefined;
-        /** The challenge to sign. */
-        challenge: Hex.Hex;
-        /** List of Web Authentication API credentials to use during creation or authentication. */
-        extensions?: internal.PublicKeyCredentialRequestOptions['extensions'] | undefined;
-        /** The relying party identifier to use. */
-        rpId?: internal.PublicKeyCredentialRequestOptions['rpId'] | undefined;
-        /** The user verification requirement. */
-        userVerification?: internal.PublicKeyCredentialRequestOptions['userVerification'] | undefined;
-    };
-    type ErrorType = Bytes.fromHex.ErrorType | Base64.toBytes.ErrorType | Errors.GlobalErrorType;
-}
-/**
- * Constructs the final digest that was signed and computed by the authenticator. This payload includes
- * the cryptographic `challenge`, as well as authenticator metadata (`authenticatorData` + `clientDataJSON`).
- * This value can be also used with raw P256 verification (such as {@link ox#P256.(verify:function)} or
- * {@link ox#WebCryptoP256.(verify:function)}).
- *
- * :::warning
- *
- * This function is mainly for testing purposes or for manually constructing
- * signing payloads. In most cases you will not need this function and
- * instead use {@link ox#WebAuthnP256.(sign:function)}.
- *
- * :::
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256, WebCryptoP256 } from 'ox'
- *
- * const { metadata, payload } = WebAuthnP256.getSignPayload({ // [!code focus]
- *   challenge: '0xdeadbeef', // [!code focus]
- * }) // [!code focus]
- * // @log: {
- * // @log:   metadata: {
- * // @log:     authenticatorData: "0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d97630500000000",
- * // @log:     challengeIndex: 23,
- * // @log:     clientDataJSON: "{"type":"webauthn.get","challenge":"9jEFijuhEWrM4SOW-tChJbUEHEP44VcjcJ-Bqo1fTM8","origin":"http://localhost:5173","crossOrigin":false}",
- * // @log:     typeIndex: 1,
- * // @log:     userVerificationRequired: true,
- * // @log:   },
- * // @log:   payload: "0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d9763050000000045086dcb06a5f234db625bcdc94e657f86b76b6fd3eb9c30543eabc1e577a4b0",
- * // @log: }
- *
- * const { publicKey, privateKey } = await WebCryptoP256.createKeyPair()
- *
- * const signature = await WebCryptoP256.sign({
- *   payload,
- *   privateKey,
- * })
- * ```
- *
- * @param options - Options to construct the signing payload.
- * @returns The signing payload.
- */
-export declare function getSignPayload(options: getSignPayload.Options): getSignPayload.ReturnType;
-export declare namespace getSignPayload {
-    type Options = {
-        /** The challenge to sign. */
-        challenge: Hex.Hex;
-        /** If set to `true`, it means that the calling context is an `<iframe>` that is not same origin with its ancestor frames. */
-        crossOrigin?: boolean | undefined;
-        /** Additional client data to include in the client data JSON. */
-        extraClientData?: Record<string, unknown> | undefined;
-        /** If set to `true`, the payload will be hashed before being returned. */
-        hash?: boolean | undefined;
-        /** A bitfield that indicates various attributes that were asserted by the authenticator. [Read more](https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API/Authenticator_data#flags) */
-        flag?: number | undefined;
-        /** The fully qualified origin of the relying party which has been given by the client/browser to the authenticator. */
-        origin?: string | undefined;
-        /** The [Relying Party ID](https://w3c.github.io/webauthn/#relying-party-identifier) that the credential is scoped to. */
-        rpId?: internal.PublicKeyCredentialRequestOptions['rpId'] | undefined;
-        /** A signature counter, if supported by the authenticator (set to 0 otherwise). */
-        signCount?: number | undefined;
-        /** The user verification requirement that the authenticator will enforce. */
-        userVerification?: internal.PublicKeyCredentialRequestOptions['userVerification'] | undefined;
-    };
-    type ReturnType = {
-        metadata: SignMetadata;
-        payload: Hex.Hex;
-    };
-    type ErrorType = Hash.sha256.ErrorType | Hex.concat.ErrorType | Hex.fromString.ErrorType | getAuthenticatorData.ErrorType | getClientDataJSON.ErrorType | Errors.GlobalErrorType;
-}
-/**
- * Signs a challenge using a stored WebAuthn P256 Credential. If no Credential is provided,
- * a prompt will be displayed for the user to select an existing Credential
- * that was previously registered.
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
- *
- * const credential = await WebAuthnP256.createCredential({
- *   name: 'Example',
- * })
- *
- * const { metadata, signature } = await WebAuthnP256.sign({ // [!code focus]
- *   credentialId: credential.id, // [!code focus]
- *   challenge: '0xdeadbeef', // [!code focus]
- * }) // [!code focus]
- * // @log: {
- * // @log:   metadata: {
- * // @log:     authenticatorData: '0x49960de5880e8c687434170f6476605b8fe4aeb9a28632c7995cf3ba831d97630500000000',
- * // @log:     clientDataJSON: '{"type":"webauthn.get","challenge":"9jEFijuhEWrM4SOW-tChJbUEHEP44VcjcJ-Bqo1fTM8","origin":"http://localhost:5173","crossOrigin":false}',
- * // @log:     challengeIndex: 23,
- * // @log:     typeIndex: 1,
- * // @log:     userVerificationRequired: true,
- * // @log:   },
- * // @log:   signature: { r: 51231...4215n, s: 12345...6789n },
- * // @log: }
- * ```
- *
- * @param options - Options.
- * @returns The signature.
- */
-export declare function sign(options: sign.Options): Promise<sign.ReturnType>;
-export declare namespace sign {
-    type Options = getCredentialRequestOptions.Options & {
-        /**
-         * Credential request function. Useful for environments that do not support
-         * the WebAuthn API natively (i.e. React Native or testing environments).
-         *
-         * @default window.navigator.credentials.get
-         */
-        getFn?: ((options?: internal.CredentialRequestOptions | undefined) => Promise<internal.Credential | null>) | undefined;
-    };
-    type ReturnType = {
-        metadata: SignMetadata;
-        raw: internal.PublicKeyCredential;
-        signature: Signature.Signature<false>;
-    };
-    type ErrorType = Hex.fromBytes.ErrorType | getCredentialRequestOptions.ErrorType | Errors.GlobalErrorType;
-}
-/**
- * Verifies a signature using the Credential's public key and the challenge which was signed.
- *
- * @example
- * ```ts twoslash
- * import { WebAuthnP256 } from 'ox'
- *
- * const credential = await WebAuthnP256.createCredential({
- *   name: 'Example',
- * })
- *
- * const { metadata, signature } = await WebAuthnP256.sign({
- *   credentialId: credential.id,
- *   challenge: '0xdeadbeef',
- * })
- *
- * const result = await WebAuthnP256.verify({ // [!code focus]
- *   metadata, // [!code focus]
- *   challenge: '0xdeadbeef', // [!code focus]
- *   publicKey: credential.publicKey, // [!code focus]
- *   signature, // [!code focus]
- * }) // [!code focus]
- * // @log: true
- * ```
- *
- * @param options - Options.
- * @returns Whether the signature is valid.
- */
-export declare function verify(options: verify.Options): boolean;
-export declare namespace verify {
-    type Options = {
-        /** The challenge to verify. */
-        challenge: Hex.Hex;
-        /** If set to `true`, the payload will be hashed (sha256) before being verified. */
-        hash?: boolean | undefined;
-        /** The public key to verify the signature with. */
-        publicKey: PublicKey.PublicKey;
-        /** The signature to verify. */
-        signature: Signature.Signature<false>;
-        /** The metadata to verify the signature with. */
-        metadata: SignMetadata;
-    };
-    type ErrorType = Base64.toBytes.ErrorType | Bytes.concat.ErrorType | Bytes.fromHex.ErrorType | P256.verify.ErrorType | Errors.GlobalErrorType;
-}
-/** Thrown when a WebAuthn P256 credential creation fails. */
-export declare class CredentialCreationFailedError extends Errors.BaseError<Error> {
-    readonly name = "WebAuthnP256.CredentialCreationFailedError";
-    constructor({ cause }?: {
-        cause?: Error | undefined;
-    });
-}
-/** Thrown when a WebAuthn P256 credential request fails. */
-export declare class CredentialRequestFailedError extends Errors.BaseError<Error> {
-    readonly name = "WebAuthnP256.CredentialRequestFailedError";
-    constructor({ cause }?: {
-        cause?: Error | undefined;
-    });
-}
-export type { AttestationConveyancePreference, AuthenticationExtensionsClientInputs, AuthenticatorAttachment, AuthenticatorSelectionCriteria, AuthenticatorTransport, BufferSource, COSEAlgorithmIdentifier, Credential, CredentialCreationOptions, CredentialMediationRequirement, CredentialRequestOptions, LargeBlobSupport, PrfExtension, PublicKeyCredential, PublicKeyCredentialCreationOptions, PublicKeyCredentialDescriptor, PublicKeyCredentialEntity, PublicKeyCredentialParameters, PublicKeyCredentialRequestOptions, PublicKeyCredentialRpEntity, PublicKeyCredentialType, PublicKeyCredentialUserEntity, ResidentKeyRequirement, UserVerificationRequirement, } from './internal/webauthn.js';

package/dist/types/node_modules/.pnpm/ox@0.12.1_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/abiParameters.d.ts

@@ -1,180 +0,0 @@
-import type { AbiParameter, AbiParameterKind, AbiParametersToPrimitiveTypes, AbiParameterToPrimitiveType } from 'abitype';
-import * as AbiParameters from '../AbiParameters.js';
-import * as Address from '../Address.js';
-import * as Bytes from '../Bytes.js';
-import * as Errors from '../Errors.js';
-import * as Hex from '../Hex.js';
-import type * as Cursor from './cursor.js';
-import type { Compute, IsNarrowable, UnionToIntersection } from './types.js';
-/** @internal */
-export type ParameterToPrimitiveType<abiParameter extends AbiParameter | {
-    name: string;
-    type: unknown;
-}, abiParameterKind extends AbiParameterKind = AbiParameterKind> = AbiParameterToPrimitiveType<abiParameter, abiParameterKind>;
-/** @internal */
-export type PreparedParameter = {
-    dynamic: boolean;
-    encoded: Hex.Hex;
-};
-/** @internal */
-export type ToObject<parameters extends readonly AbiParameter[], kind extends AbiParameterKind = AbiParameterKind> = IsNarrowable<parameters, AbiParameters.AbiParameters> extends true ? Compute<UnionToIntersection<{
-    [index in keyof parameters]: parameters[index] extends {
-        name: infer name extends string;
-    } ? {
-        [key in name]: AbiParameterToPrimitiveType<parameters[index], kind>;
-    } : {
-        [key in index]: AbiParameterToPrimitiveType<parameters[index], kind>;
-    };
-}[number]>> : unknown;
-/** @internal */
-export type ToPrimitiveTypes<abiParameters extends readonly AbiParameter[], abiParameterKind extends AbiParameterKind = AbiParameterKind> = AbiParametersToPrimitiveTypes<abiParameters, abiParameterKind>;
-/** @internal */
-export type Tuple = ParameterToPrimitiveType<TupleAbiParameter>;
-/** @internal */
-export declare function decodeParameter(cursor: Cursor.Cursor, param: AbiParameters.Parameter, options: {
-    checksumAddress?: boolean | undefined;
-    staticPosition: number;
-}): any[];
-export declare namespace decodeParameter {
-    type ErrorType = decodeArray.ErrorType | decodeTuple.ErrorType | decodeAddress.ErrorType | decodeBool.ErrorType | decodeBytes.ErrorType | decodeNumber.ErrorType | decodeString.ErrorType | AbiParameters.InvalidTypeError | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function decodeAddress(cursor: Cursor.Cursor, options?: {
-    checksum?: boolean | undefined;
-}): (number | `0x${string}`)[];
-export declare namespace decodeAddress {
-    type ErrorType = Hex.fromBytes.ErrorType | Bytes.slice.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function decodeArray(cursor: Cursor.Cursor, param: AbiParameters.Parameter, options: {
-    checksumAddress?: boolean | undefined;
-    length: number | null;
-    staticPosition: number;
-}): (number | unknown[])[];
-export declare namespace decodeArray {
-    type ErrorType = Bytes.toNumber.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function decodeBool(cursor: Cursor.Cursor): (number | boolean)[];
-export declare namespace decodeBool {
-    type ErrorType = Bytes.toBoolean.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function decodeBytes(cursor: Cursor.Cursor, param: AbiParameters.Parameter, { staticPosition }: {
-    staticPosition: number;
-}): (string | number)[];
-export declare namespace decodeBytes {
-    type ErrorType = Hex.fromBytes.ErrorType | Bytes.toNumber.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function decodeNumber(cursor: Cursor.Cursor, param: AbiParameters.Parameter): (number | bigint)[];
-export declare namespace decodeNumber {
-    type ErrorType = Bytes.toNumber.ErrorType | Bytes.toBigInt.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export type TupleAbiParameter = AbiParameters.Parameter & {
-    components: readonly AbiParameters.Parameter[];
-};
-/** @internal */
-export declare function decodeTuple(cursor: Cursor.Cursor, param: TupleAbiParameter, options: {
-    checksumAddress?: boolean | undefined;
-    staticPosition: number;
-}): any[];
-export declare namespace decodeTuple {
-    type ErrorType = Bytes.toNumber.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function decodeString(cursor: Cursor.Cursor, { staticPosition }: {
-    staticPosition: number;
-}): (string | number)[];
-export declare namespace decodeString {
-    type ErrorType = Bytes.toNumber.ErrorType | Bytes.toString.ErrorType | Bytes.trimLeft.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function prepareParameters<const parameters extends AbiParameters.AbiParameters>({ checksumAddress, parameters, values, }: {
-    checksumAddress?: boolean | undefined;
-    parameters: parameters;
-    values: parameters extends AbiParameters.AbiParameters ? ToPrimitiveTypes<parameters> : never;
-}): PreparedParameter[];
-/** @internal */
-export declare namespace prepareParameters {
-    type ErrorType = prepareParameter.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function prepareParameter<const parameter extends AbiParameters.Parameter>({ checksumAddress, parameter: parameter_, value, }: {
-    parameter: parameter;
-    value: parameter extends AbiParameters.Parameter ? ParameterToPrimitiveType<parameter> : never;
-    checksumAddress?: boolean | undefined;
-}): PreparedParameter;
-/** @internal */
-export declare namespace prepareParameter {
-    type ErrorType = encodeArray.ErrorType | encodeTuple.ErrorType | encodeAddress.ErrorType | encodeBoolean.ErrorType | encodeBytes.ErrorType | encodeString.ErrorType | AbiParameters.InvalidTypeError | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encode(preparedParameters: PreparedParameter[]): Hex.Hex;
-/** @internal */
-export declare namespace encode {
-    type ErrorType = Hex.concat.ErrorType | Hex.fromNumber.ErrorType | Hex.size.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encodeAddress(value: Hex.Hex, options: {
-    checksum: boolean;
-}): PreparedParameter;
-/** @internal */
-export declare namespace encodeAddress {
-    type ErrorType = Address.assert.ErrorType | Hex.padLeft.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encodeArray<const parameter extends AbiParameters.Parameter>(value: ParameterToPrimitiveType<parameter>, options: {
-    checksumAddress?: boolean | undefined;
-    length: number | null;
-    parameter: parameter;
-}): PreparedParameter;
-/** @internal */
-export declare namespace encodeArray {
-    type ErrorType = AbiParameters.InvalidArrayError | AbiParameters.ArrayLengthMismatchError | Hex.concat.ErrorType | Hex.fromNumber.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encodeBytes(value: Hex.Hex, { type }: {
-    type: string;
-}): PreparedParameter;
-/** @internal */
-export declare namespace encodeBytes {
-    type ErrorType = Hex.padLeft.ErrorType | Hex.padRight.ErrorType | Hex.fromNumber.ErrorType | Hex.slice.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encodeBoolean(value: boolean): PreparedParameter;
-/** @internal */
-export declare namespace encodeBoolean {
-    type ErrorType = Hex.padLeft.ErrorType | Hex.fromBoolean.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encodeNumber(value: number, { signed, size }: {
-    signed: boolean;
-    size: number;
-}): PreparedParameter;
-/** @internal */
-export declare namespace encodeNumber {
-    type ErrorType = Hex.fromNumber.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encodeString(value: string): PreparedParameter;
-/** @internal */
-export declare namespace encodeString {
-    type ErrorType = Hex.fromNumber.ErrorType | Hex.padRight.ErrorType | Hex.slice.ErrorType | Hex.size.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function encodeTuple<const parameter extends AbiParameters.Parameter & {
-    components: readonly AbiParameters.Parameter[];
-}>(value: ParameterToPrimitiveType<parameter>, options: {
-    checksumAddress?: boolean | undefined;
-    parameter: parameter;
-}): PreparedParameter;
-/** @internal */
-export declare namespace encodeTuple {
-    type ErrorType = Hex.concat.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function getArrayComponents(type: string): [length: number | null, innerType: string] | undefined;
-/** @internal */
-export declare function hasDynamicChild(param: AbiParameters.Parameter): any;

package/dist/types/node_modules/.pnpm/ox@0.12.1_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/bytes.d.ts

@@ -1,51 +0,0 @@
-import * as Bytes from '../Bytes.js';
-import type * as Errors from '../Errors.js';
-/** @internal */
-export declare function assertSize(bytes: Bytes.Bytes, size_: number): void;
-/** @internal */
-export declare namespace assertSize {
-    type ErrorType = Bytes.size.ErrorType | Bytes.SizeOverflowError | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function assertStartOffset(value: Bytes.Bytes, start?: number | undefined): void;
-export declare namespace assertStartOffset {
-    type ErrorType = Bytes.SliceOffsetOutOfBoundsError | Bytes.size.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function assertEndOffset(value: Bytes.Bytes, start?: number | undefined, end?: number | undefined): void;
-/** @internal */
-export declare namespace assertEndOffset {
-    type ErrorType = Bytes.SliceOffsetOutOfBoundsError | Bytes.size.ErrorType | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare const charCodeMap: {
-    readonly zero: 48;
-    readonly nine: 57;
-    readonly A: 65;
-    readonly F: 70;
-    readonly a: 97;
-    readonly f: 102;
-};
-/** @internal */
-export declare function charCodeToBase16(char: number): number | undefined;
-/** @internal */
-export declare function pad(bytes: Bytes.Bytes, options?: pad.Options): Bytes.Bytes;
-/** @internal */
-export declare namespace pad {
-    type Options = {
-        dir?: 'left' | 'right' | undefined;
-        size?: number | undefined;
-    };
-    type ReturnType = Bytes.Bytes;
-    type ErrorType = Bytes.SizeExceedsPaddingSizeError | Errors.GlobalErrorType;
-}
-/** @internal */
-export declare function trim(value: Bytes.Bytes, options?: trim.Options): trim.ReturnType;
-/** @internal */
-export declare namespace trim {
-    type Options = {
-        dir?: 'left' | 'right' | undefined;
-    };
-    type ReturnType = Bytes.Bytes;
-    type ErrorType = Errors.GlobalErrorType;
-}