import { z } from 'zod';
export declare const PKPSignInputSchema: z.ZodObject<{
    /**
     * Picking the chains would use the correct hash function for the signing scheme.
     *
     * @example
     * ethereum -> keccak256(<to_sign_bytes_array>)
     * bitcoin -> sha256(<to_sign_bytes_array>)
     */
    chain: z.ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
    signingScheme: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
    pubKey: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
    toSign: z.ZodAny;
    authContext: z.ZodUnion<[z.ZodObject<{
        pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
        chain: z.ZodString;
        sessionKeyPair: z.ZodObject<{
            publicKey: z.ZodString;
            secretKey: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            publicKey: string;
            secretKey: string;
        }, {
            publicKey: string;
            secretKey: string;
        }>;
        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                sig: z.ZodString;
                derivedVia: z.ZodString;
                signedMessage: z.ZodString;
                address: z.ZodString;
                algo: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>, "many">>>;
            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                resource: z.ZodObject<{
                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                        readonly PKPSigning: "pkp-signing";
                        readonly PaymentDelegation: "lit-payment-delegation";
                        readonly LitActionExecution: "lit-action-execution";
                    }>], z.ZodUnknown>, z.ZodBoolean>;
                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                        readonly PKP: "lit-pkp";
                        readonly RLI: "lit-ratelimitincrease";
                        readonly PaymentDelegation: "lit-paymentdelegation";
                        readonly LitAction: "lit-litaction";
                    }>>;
                    resource: z.ZodReadonly<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }>;
                ability: z.ZodNativeEnum<{
                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                    readonly PKPSigning: "pkp-signing";
                    readonly PaymentDelegation: "lit-payment-delegation";
                    readonly LitActionExecution: "lit-action-execution";
                }>;
                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
            }, "strip", z.ZodTypeAny, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }>, "many">>>;
            keySetIdentifier: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, {
            keySetIdentifier?: string | undefined;
            capabilityAuthSigs?: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[] | undefined;
            expiration?: string | undefined;
            statement?: string | undefined;
            domain?: string | undefined;
            resources?: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[] | undefined;
        }>, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, unknown>>;
    }, "strip", z.ZodTypeAny, {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    }, {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    }>, z.ZodObject<{
        account: z.ZodAny;
        authenticator: z.ZodAny;
        authData: z.ZodLazy<z.ZodObject<{
            authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
            authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                readonly EthWallet: 1;
                readonly LitAction: 2;
                readonly WebAuthn: 3;
                readonly Discord: 4;
                readonly Google: 5;
                readonly GoogleJwt: 6;
                readonly AppleJwt: 8;
                readonly StytchOtp: 9;
                readonly StytchEmailFactorOtp: 10;
                readonly StytchSmsFactorOtp: 11;
                readonly StytchWhatsAppFactorOtp: 12;
                readonly StytchTotpFactorOtp: 13;
            }>>;
            accessToken: z.ZodString;
            publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
            metadata: z.ZodOptional<z.ZodAny>;
        }, "strip", z.ZodTypeAny, {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        }, {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        }>>;
        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
        sessionKeyPair: z.ZodObject<{
            publicKey: z.ZodString;
            secretKey: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            publicKey: string;
            secretKey: string;
        }, {
            publicKey: string;
            secretKey: string;
        }>;
        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                sig: z.ZodString;
                derivedVia: z.ZodString;
                signedMessage: z.ZodString;
                address: z.ZodString;
                algo: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>, "many">>>;
            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                resource: z.ZodObject<{
                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                        readonly PKPSigning: "pkp-signing";
                        readonly PaymentDelegation: "lit-payment-delegation";
                        readonly LitActionExecution: "lit-action-execution";
                    }>], z.ZodUnknown>, z.ZodBoolean>;
                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                        readonly PKP: "lit-pkp";
                        readonly RLI: "lit-ratelimitincrease";
                        readonly PaymentDelegation: "lit-paymentdelegation";
                        readonly LitAction: "lit-litaction";
                    }>>;
                    resource: z.ZodReadonly<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }>;
                ability: z.ZodNativeEnum<{
                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                    readonly PKPSigning: "pkp-signing";
                    readonly PaymentDelegation: "lit-payment-delegation";
                    readonly LitActionExecution: "lit-action-execution";
                }>;
                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
            }, "strip", z.ZodTypeAny, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }>, "many">>>;
            keySetIdentifier: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, {
            keySetIdentifier?: string | undefined;
            capabilityAuthSigs?: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[] | undefined;
            expiration?: string | undefined;
            statement?: string | undefined;
            domain?: string | undefined;
            resources?: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[] | undefined;
        }>, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, unknown>>;
    }, "strip", z.ZodTypeAny, {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    }, {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    }>]>;
    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
    bypassAutoHashing: z.ZodOptional<z.ZodBoolean>;
    /**
     * Key set identifier used to select the signing key set
     */
    keySetIdentifier: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    pubKey: string;
    chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    };
    signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}, {
    pubKey: string;
    chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    };
    signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}>;
export declare const EthereumPKPSignInputSchema: z.ZodEffects<z.ZodObject<Omit<{
    /**
     * Picking the chains would use the correct hash function for the signing scheme.
     *
     * @example
     * ethereum -> keccak256(<to_sign_bytes_array>)
     * bitcoin -> sha256(<to_sign_bytes_array>)
     */
    chain: z.ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
    signingScheme: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
    pubKey: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
    toSign: z.ZodAny;
    authContext: z.ZodUnion<[z.ZodObject<{
        pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
        chain: z.ZodString;
        sessionKeyPair: z.ZodObject<{
            publicKey: z.ZodString;
            secretKey: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            publicKey: string;
            secretKey: string;
        }, {
            publicKey: string;
            secretKey: string;
        }>;
        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                sig: z.ZodString;
                derivedVia: z.ZodString;
                signedMessage: z.ZodString;
                address: z.ZodString;
                algo: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>, "many">>>;
            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                resource: z.ZodObject<{
                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                        readonly PKPSigning: "pkp-signing";
                        readonly PaymentDelegation: "lit-payment-delegation";
                        readonly LitActionExecution: "lit-action-execution";
                    }>], z.ZodUnknown>, z.ZodBoolean>;
                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                        readonly PKP: "lit-pkp";
                        readonly RLI: "lit-ratelimitincrease";
                        readonly PaymentDelegation: "lit-paymentdelegation";
                        readonly LitAction: "lit-litaction";
                    }>>;
                    resource: z.ZodReadonly<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }>;
                ability: z.ZodNativeEnum<{
                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                    readonly PKPSigning: "pkp-signing";
                    readonly PaymentDelegation: "lit-payment-delegation";
                    readonly LitActionExecution: "lit-action-execution";
                }>;
                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
            }, "strip", z.ZodTypeAny, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }>, "many">>>;
            keySetIdentifier: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, {
            keySetIdentifier?: string | undefined;
            capabilityAuthSigs?: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[] | undefined;
            expiration?: string | undefined;
            statement?: string | undefined;
            domain?: string | undefined;
            resources?: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[] | undefined;
        }>, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, unknown>>;
    }, "strip", z.ZodTypeAny, {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    }, {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    }>, z.ZodObject<{
        account: z.ZodAny;
        authenticator: z.ZodAny;
        authData: z.ZodLazy<z.ZodObject<{
            authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
            authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                readonly EthWallet: 1;
                readonly LitAction: 2;
                readonly WebAuthn: 3;
                readonly Discord: 4;
                readonly Google: 5;
                readonly GoogleJwt: 6;
                readonly AppleJwt: 8;
                readonly StytchOtp: 9;
                readonly StytchEmailFactorOtp: 10;
                readonly StytchSmsFactorOtp: 11;
                readonly StytchWhatsAppFactorOtp: 12;
                readonly StytchTotpFactorOtp: 13;
            }>>;
            accessToken: z.ZodString;
            publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
            metadata: z.ZodOptional<z.ZodAny>;
        }, "strip", z.ZodTypeAny, {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        }, {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        }>>;
        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
        sessionKeyPair: z.ZodObject<{
            publicKey: z.ZodString;
            secretKey: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            publicKey: string;
            secretKey: string;
        }, {
            publicKey: string;
            secretKey: string;
        }>;
        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                sig: z.ZodString;
                derivedVia: z.ZodString;
                signedMessage: z.ZodString;
                address: z.ZodString;
                algo: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>, "many">>>;
            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                resource: z.ZodObject<{
                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                        readonly PKPSigning: "pkp-signing";
                        readonly PaymentDelegation: "lit-payment-delegation";
                        readonly LitActionExecution: "lit-action-execution";
                    }>], z.ZodUnknown>, z.ZodBoolean>;
                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                        readonly PKP: "lit-pkp";
                        readonly RLI: "lit-ratelimitincrease";
                        readonly PaymentDelegation: "lit-paymentdelegation";
                        readonly LitAction: "lit-litaction";
                    }>>;
                    resource: z.ZodReadonly<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }>;
                ability: z.ZodNativeEnum<{
                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                    readonly PKPSigning: "pkp-signing";
                    readonly PaymentDelegation: "lit-payment-delegation";
                    readonly LitActionExecution: "lit-action-execution";
                }>;
                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
            }, "strip", z.ZodTypeAny, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }>, "many">>>;
            keySetIdentifier: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, {
            keySetIdentifier?: string | undefined;
            capabilityAuthSigs?: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[] | undefined;
            expiration?: string | undefined;
            statement?: string | undefined;
            domain?: string | undefined;
            resources?: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[] | undefined;
        }>, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, unknown>>;
    }, "strip", z.ZodTypeAny, {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    }, {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    }>]>;
    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
    bypassAutoHashing: z.ZodOptional<z.ZodBoolean>;
    /**
     * Key set identifier used to select the signing key set
     */
    keySetIdentifier: z.ZodOptional<z.ZodString>;
}, "chain" | "signingScheme">, "strip", z.ZodTypeAny, {
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    };
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}, {
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    };
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}>, {
    signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
    chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    };
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}, {
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    };
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}>;
export declare const BitCoinPKPSignInputSchema: z.ZodEffects<z.ZodObject<Omit<{
    /**
     * Picking the chains would use the correct hash function for the signing scheme.
     *
     * @example
     * ethereum -> keccak256(<to_sign_bytes_array>)
     * bitcoin -> sha256(<to_sign_bytes_array>)
     */
    chain: z.ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
    signingScheme: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
    pubKey: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
    toSign: z.ZodAny;
    authContext: z.ZodUnion<[z.ZodObject<{
        pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
        chain: z.ZodString;
        sessionKeyPair: z.ZodObject<{
            publicKey: z.ZodString;
            secretKey: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            publicKey: string;
            secretKey: string;
        }, {
            publicKey: string;
            secretKey: string;
        }>;
        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                sig: z.ZodString;
                derivedVia: z.ZodString;
                signedMessage: z.ZodString;
                address: z.ZodString;
                algo: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>, "many">>>;
            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                resource: z.ZodObject<{
                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                        readonly PKPSigning: "pkp-signing";
                        readonly PaymentDelegation: "lit-payment-delegation";
                        readonly LitActionExecution: "lit-action-execution";
                    }>], z.ZodUnknown>, z.ZodBoolean>;
                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                        readonly PKP: "lit-pkp";
                        readonly RLI: "lit-ratelimitincrease";
                        readonly PaymentDelegation: "lit-paymentdelegation";
                        readonly LitAction: "lit-litaction";
                    }>>;
                    resource: z.ZodReadonly<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }>;
                ability: z.ZodNativeEnum<{
                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                    readonly PKPSigning: "pkp-signing";
                    readonly PaymentDelegation: "lit-payment-delegation";
                    readonly LitActionExecution: "lit-action-execution";
                }>;
                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
            }, "strip", z.ZodTypeAny, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }>, "many">>>;
            keySetIdentifier: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, {
            keySetIdentifier?: string | undefined;
            capabilityAuthSigs?: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[] | undefined;
            expiration?: string | undefined;
            statement?: string | undefined;
            domain?: string | undefined;
            resources?: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[] | undefined;
        }>, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, unknown>>;
    }, "strip", z.ZodTypeAny, {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    }, {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    }>, z.ZodObject<{
        account: z.ZodAny;
        authenticator: z.ZodAny;
        authData: z.ZodLazy<z.ZodObject<{
            authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
            authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                readonly EthWallet: 1;
                readonly LitAction: 2;
                readonly WebAuthn: 3;
                readonly Discord: 4;
                readonly Google: 5;
                readonly GoogleJwt: 6;
                readonly AppleJwt: 8;
                readonly StytchOtp: 9;
                readonly StytchEmailFactorOtp: 10;
                readonly StytchSmsFactorOtp: 11;
                readonly StytchWhatsAppFactorOtp: 12;
                readonly StytchTotpFactorOtp: 13;
            }>>;
            accessToken: z.ZodString;
            publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
            metadata: z.ZodOptional<z.ZodAny>;
        }, "strip", z.ZodTypeAny, {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        }, {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        }>>;
        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
        sessionKeyPair: z.ZodObject<{
            publicKey: z.ZodString;
            secretKey: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            publicKey: string;
            secretKey: string;
        }, {
            publicKey: string;
            secretKey: string;
        }>;
        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                sig: z.ZodString;
                derivedVia: z.ZodString;
                signedMessage: z.ZodString;
                address: z.ZodString;
                algo: z.ZodOptional<z.ZodString>;
            }, "strip", z.ZodTypeAny, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }, {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>, "many">>>;
            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                resource: z.ZodObject<{
                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                        readonly PKPSigning: "pkp-signing";
                        readonly PaymentDelegation: "lit-payment-delegation";
                        readonly LitActionExecution: "lit-action-execution";
                    }>], z.ZodUnknown>, z.ZodBoolean>;
                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                        readonly PKP: "lit-pkp";
                        readonly RLI: "lit-ratelimitincrease";
                        readonly PaymentDelegation: "lit-paymentdelegation";
                        readonly LitAction: "lit-litaction";
                    }>>;
                    resource: z.ZodReadonly<z.ZodString>;
                }, "strip", z.ZodTypeAny, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }, {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                }>;
                ability: z.ZodNativeEnum<{
                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                    readonly PKPSigning: "pkp-signing";
                    readonly PaymentDelegation: "lit-payment-delegation";
                    readonly LitActionExecution: "lit-action-execution";
                }>;
                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
            }, "strip", z.ZodTypeAny, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }, {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }>, "many">>>;
            keySetIdentifier: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, {
            keySetIdentifier?: string | undefined;
            capabilityAuthSigs?: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[] | undefined;
            expiration?: string | undefined;
            statement?: string | undefined;
            domain?: string | undefined;
            resources?: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[] | undefined;
        }>, {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        }, unknown>>;
    }, "strip", z.ZodTypeAny, {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    }, {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    }>]>;
    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
    bypassAutoHashing: z.ZodOptional<z.ZodBoolean>;
    /**
     * Key set identifier used to select the signing key set
     */
    keySetIdentifier: z.ZodOptional<z.ZodString>;
}, "chain" | "signingScheme"> & {
    signingScheme: z.ZodEnum<["EcdsaK256Sha256", "SchnorrK256Sha256", "SchnorrK256Taproot"]>;
}, "strip", z.ZodTypeAny, {
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    };
    signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}, {
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    };
    signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}>, {
    chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        pkpPublicKey?: string | undefined;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authConfig: {
            capabilityAuthSigs: {
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }[];
            expiration: string;
            statement: string;
            domain: string;
            resources: {
                resource: {
                    toString: (...args: unknown[]) => string;
                    getResourceKey: (...args: unknown[]) => string;
                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                    resource: string;
                };
                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
            }[];
            keySetIdentifier?: string | undefined;
        };
        authData: {
            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        account?: any;
        authenticator?: any;
    };
    signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}, {
    pubKey: string;
    authContext: {
        chain: string;
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        pkpPublicKey?: string | undefined;
        authConfig?: unknown;
    } | {
        sessionKeyPair: {
            publicKey: string;
            secretKey: string;
        };
        authNeededCallback: (...args: unknown[]) => unknown;
        authData: {
            authMethodType: number;
            accessToken: string;
            authMethodId: string;
            publicKey?: string | undefined;
            metadata?: any;
        };
        authConfig?: unknown;
        account?: any;
        authenticator?: any;
    };
    signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
    keySetIdentifier?: string | undefined;
    userMaxPrice?: bigint | undefined;
    toSign?: any;
    bypassAutoHashing?: boolean | undefined;
}>;