import type { ExpectedAccountOrWalletClient } from '../../shared/managers/contract-manager/createContractsManager';
declare const nagaDev: {
    id: string;
    version: string;
    config: {
        requiredAttestation: boolean;
        abortTimeout: number;
        minimumThreshold: number;
        httpProtocol: "http://" | "https://";
    };
    schemas: {
        GenericResponseSchema: <T extends import("zod").ZodTypeAny>(dataSchema: T) => import("zod").ZodEffects<import("zod").ZodObject<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }, "strip", import("zod").ZodTypeAny, import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }>, any> extends infer T_1 ? { [k in keyof T_1]: import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }>, any>[k]; } : never, import("zod").baseObjectInputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }> extends infer T_2 ? { [k_1 in keyof T_2]: import("zod").baseObjectInputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }>[k_1]; } : never>, (import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }>, any> extends infer T_3 ? { [k in keyof T_3]: import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }>, any>[k]; } : never) & {
            parseData: () => import("zod").objectUtil.addQuestionMarks<import("zod").baseObjectOutputType<{
                ok: import("zod").ZodBoolean;
                error: import("zod").ZodNullable<import("zod").ZodString>;
                errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
                data: T;
            }>, any>["data"] | undefined;
        }, import("zod").baseObjectInputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }> extends infer T_4 ? { [k_1 in keyof T_4]: import("zod").baseObjectInputType<{
            ok: import("zod").ZodBoolean;
            error: import("zod").ZodNullable<import("zod").ZodString>;
            errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
            data: T;
        }>[k_1]; } : never>;
    };
    getNetworkName: () => string;
    getHttpProtocol: () => "http://" | "https://";
    getEndpoints: () => import("../../shared/managers/endpoints-manager/endpoints").NagaEndpointsType;
    getRpcUrl: () => string;
    getChainConfig: () => import("viem").Chain;
    getDefaultLoginBaseUrl: () => string;
    getMinimumThreshold: () => number;
    createStateManager: <StateT, ModuleT>(params: {
        callback: (params: import("dist/packages/types/src").CallbackParams) => Promise<StateT>;
        networkModule: ModuleT;
    }) => Promise<{
        getLatestBlockhash: () => Promise<string>;
        getCallbackResult: () => StateT | null;
        getLatestConnectionInfo: () => import("../../../..").ConnectionInfo | null;
        refreshHandshake: (reason?: string) => Promise<void>;
        stop: () => void;
        contractManager: any;
    }>;
    getMaxPricesForNodeProduct: typeof import("../../shared").getMaxPricesForNodeProduct;
    getUserMaxPrice: (params: {
        product: keyof typeof import("../../../..").PRODUCT_IDS;
    }) => bigint;
    getVerifyReleaseId: () => (attestation: import("dist/packages/types/src").NodeAttestation, config: import("dist/packages/crypto/src").ReleaseVerificationConfig) => Promise<void>;
    chainApi: {
        getPKPPermissionsManager: (params: {
            pkpIdentifier: import("../../../..").PkpIdentifierRaw;
            account: ExpectedAccountOrWalletClient;
        }) => Promise<import("../../../..").PKPPermissionsManager>;
        getPaymentManager: (params: {
            account: ExpectedAccountOrWalletClient;
        }) => Promise<import("../../../..").PaymentManager>;
        getPKPsByAuthData: (params: {
            authData: Partial<import("dist/packages/schemas/src").AuthData>;
            pagination?: {
                limit?: number;
                offset?: number;
            } | undefined;
            storageProvider?: import("../../../..").PKPStorageProvider;
            account: ExpectedAccountOrWalletClient;
        }) => Promise<import("../../shared/managers/LitChainClient/apis/highLevelApis/PKPPermissionsManager/handlers/getPKPsByAuthMethod").PaginatedPKPsResponse>;
        getPKPsByAddress: (params: {
            ownerAddress: string;
            pagination?: {
                limit?: number;
                offset?: number;
            } | undefined;
            storageProvider?: import("../../../..").PKPStorageProvider;
            account: ExpectedAccountOrWalletClient;
        }) => Promise<import("../../shared/managers/LitChainClient/apis/highLevelApis/PKPPermissionsManager/handlers/getPKPsByAuthMethod").PaginatedPKPsResponse>;
        mintWithEoa: (params: {
            account: ExpectedAccountOrWalletClient;
        }) => Promise<import("../../../..").GenericTxRes<import("../../../..").LitTxRes<import("../../../..").PKPData>, import("../../../..").PKPData>>;
        mintWithAuth: (params: {
            account: ExpectedAccountOrWalletClient;
            authData: import("dist/packages/types/src").Optional<import("dist/packages/schemas/src").AuthDataInput, "accessToken">;
            scopes: import("zod").TypeOf<typeof import("dist/packages/schemas/src").ScopeStringSchema>[];
        }) => Promise<import("../../../..").GenericTxRes<import("../../../..").LitTxRes<import("../../../..").PKPData>, import("../../../..").PKPData>>;
        mintWithMultiAuths: (params: {
            account: ExpectedAccountOrWalletClient;
        } & {
            authMethodIds: string[];
            authMethodTypes: (number | bigint)[];
            authMethodScopes: ("no-permissions" | "sign-anything" | "personal-sign")[][];
            addPkpEthAddressAsPermittedAddress?: boolean | undefined;
            sendPkpToItself?: boolean | undefined;
            pubkeys?: string[] | undefined;
        }) => Promise<import("../../../..").GenericTxRes<import("../../../..").LitTxRes<import("../../../..").PKPData>, import("../../../..").PKPData>>;
    };
    authService: {
        pkpMint: (params: {
            authData: import("dist/packages/schemas/src").AuthData;
            authServiceBaseUrl: string;
            scopes?: ("sign-anything" | "personal-sign" | "no-permissions")[];
            apiKey?: string;
        }) => Promise<import("dist/packages/types/src").AuthServerTx<{
            ethAddress: string;
            tokenId: bigint;
            pubkey: string;
        }>>;
        registerPayer: (params: {
            authServiceBaseUrl: string;
            apiKey: string;
        }) => Promise<import("../../../shared/helpers/paymentDelegation").RegisterPayerResult>;
        delegateUsers: (params: {
            authServiceBaseUrl: string;
            apiKey: string;
            payerSecretKey: string;
            userAddresses: string[];
        }) => Promise<import("../../../shared/helpers/paymentDelegation").DelegateUsersResult>;
    };
    api: {
        createJitContext: (connectionInfo: import("../../../..").ConnectionInfo, handshakeResult: import("dist/packages/types/src").OrchestrateHandshakeResponse) => Promise<import("dist/packages/types/src").NagaJitContext>;
        handshake: {
            schemas: {
                Input: {
                    ResponseData: import("zod").ZodEffects<import("zod").ZodObject<{
                        ok: import("zod").ZodBoolean;
                        error: import("zod").ZodNullable<import("zod").ZodString>;
                        errorObject: import("zod").ZodNullable<import("zod").ZodAny>;
                        data: import("zod").ZodObject<{
                            serverPublicKey: import("zod").ZodString;
                            subnetPublicKey: import("zod").ZodString;
                            networkPublicKey: import("zod").ZodString;
                            networkPublicKeySet: import("zod").ZodString;
                            clientSdkVersion: import("zod").ZodString;
                            hdRootPubkeys: import("zod").ZodArray<import("zod").ZodString, "many">;
                            attestation: import("zod").ZodOptional<import("zod").ZodAny>;
                            latestBlockhash: import("zod").ZodString;
                            nodeIdentityKey: import("zod").ZodString;
                            nodeVersion: import("zod").ZodString;
                            epoch: import("zod").ZodNumber;
                        }, "strip", import("zod").ZodTypeAny, {
                            epoch: number;
                            serverPublicKey: string;
                            subnetPublicKey: string;
                            networkPublicKey: string;
                            networkPublicKeySet: string;
                            clientSdkVersion: string;
                            hdRootPubkeys: string[];
                            latestBlockhash: string;
                            nodeIdentityKey: string;
                            nodeVersion: string;
                            attestation?: any;
                        }, {
                            epoch: number;
                            serverPublicKey: string;
                            subnetPublicKey: string;
                            networkPublicKey: string;
                            networkPublicKeySet: string;
                            clientSdkVersion: string;
                            hdRootPubkeys: string[];
                            latestBlockhash: string;
                            nodeIdentityKey: string;
                            nodeVersion: string;
                            attestation?: any;
                        }>;
                    }, "strip", import("zod").ZodTypeAny, {
                        data: {
                            epoch: number;
                            serverPublicKey: string;
                            subnetPublicKey: string;
                            networkPublicKey: string;
                            networkPublicKeySet: string;
                            clientSdkVersion: string;
                            hdRootPubkeys: string[];
                            latestBlockhash: string;
                            nodeIdentityKey: string;
                            nodeVersion: string;
                            attestation?: any;
                        };
                        error: string | null;
                        ok: boolean;
                        errorObject?: any;
                    }, {
                        data: {
                            epoch: number;
                            serverPublicKey: string;
                            subnetPublicKey: string;
                            networkPublicKey: string;
                            networkPublicKeySet: string;
                            clientSdkVersion: string;
                            hdRootPubkeys: string[];
                            latestBlockhash: string;
                            nodeIdentityKey: string;
                            nodeVersion: string;
                            attestation?: any;
                        };
                        error: string | null;
                        ok: boolean;
                        errorObject?: any;
                    }>, {
                        data: {
                            epoch: number;
                            serverPublicKey: string;
                            subnetPublicKey: string;
                            networkPublicKey: string;
                            networkPublicKeySet: string;
                            clientSdkVersion: string;
                            hdRootPubkeys: string[];
                            latestBlockhash: string;
                            nodeIdentityKey: string;
                            nodeVersion: string;
                            attestation?: any;
                        };
                        error: string | null;
                        ok: boolean;
                        errorObject?: any;
                    } & {
                        parseData: () => {
                            epoch: number;
                            serverPublicKey: string;
                            subnetPublicKey: string;
                            networkPublicKey: string;
                            networkPublicKeySet: string;
                            clientSdkVersion: string;
                            hdRootPubkeys: string[];
                            latestBlockhash: string;
                            nodeIdentityKey: string;
                            nodeVersion: string;
                            attestation?: any;
                        } | undefined;
                    }, {
                        data: {
                            epoch: number;
                            serverPublicKey: string;
                            subnetPublicKey: string;
                            networkPublicKey: string;
                            networkPublicKeySet: string;
                            clientSdkVersion: string;
                            hdRootPubkeys: string[];
                            latestBlockhash: string;
                            nodeIdentityKey: string;
                            nodeVersion: string;
                            attestation?: any;
                        };
                        error: string | null;
                        ok: boolean;
                        errorObject?: any;
                    }>;
                };
            };
        };
        pkpSign: {
            schemas: {
                Input: {
                    raw: import("zod").ZodObject<{
                        chain: import("zod").ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                        signingScheme: import("zod").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: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                        toSign: import("zod").ZodAny;
                        authContext: import("zod").ZodUnion<[import("zod").ZodObject<{
                            pkpPublicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                            chain: import("zod").ZodString;
                            sessionKeyPair: import("zod").ZodObject<{
                                publicKey: import("zod").ZodString;
                                secretKey: import("zod").ZodString;
                            }, "strip", import("zod").ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authNeededCallback: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                            authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                                capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    sig: import("zod").ZodString;
                                    derivedVia: import("zod").ZodString;
                                    signedMessage: import("zod").ZodString;
                                    address: import("zod").ZodString;
                                    algo: import("zod").ZodOptional<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                                domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    resource: import("zod").ZodObject<{
                                        getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                        }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                        toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                    }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                                }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        }, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        }>, import("zod").ZodObject<{
                            account: import("zod").ZodAny;
                            authenticator: import("zod").ZodAny;
                            authData: import("zod").ZodLazy<import("zod").ZodObject<{
                                authMethodId: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                                authMethodType: import("zod").ZodPipeline<import("zod").ZodNumber, import("zod").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: import("zod").ZodString;
                                publicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                                metadata: import("zod").ZodOptional<import("zod").ZodAny>;
                            }, "strip", import("zod").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: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                            sessionKeyPair: import("zod").ZodObject<{
                                publicKey: import("zod").ZodString;
                                secretKey: import("zod").ZodString;
                            }, "strip", import("zod").ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                                capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    sig: import("zod").ZodString;
                                    derivedVia: import("zod").ZodString;
                                    signedMessage: import("zod").ZodString;
                                    address: import("zod").ZodString;
                                    algo: import("zod").ZodOptional<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                                domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    resource: import("zod").ZodObject<{
                                        getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                        }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                        toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                    }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                                }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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: import("zod").ZodOptional<import("zod").ZodBigInt>;
                        bypassAutoHashing: import("zod").ZodOptional<import("zod").ZodBoolean>;
                        keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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;
                    }>;
                    ethereum: import("zod").ZodEffects<import("zod").ZodObject<Omit<{
                        chain: import("zod").ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                        signingScheme: import("zod").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: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                        toSign: import("zod").ZodAny;
                        authContext: import("zod").ZodUnion<[import("zod").ZodObject<{
                            pkpPublicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                            chain: import("zod").ZodString;
                            sessionKeyPair: import("zod").ZodObject<{
                                publicKey: import("zod").ZodString;
                                secretKey: import("zod").ZodString;
                            }, "strip", import("zod").ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authNeededCallback: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                            authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                                capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    sig: import("zod").ZodString;
                                    derivedVia: import("zod").ZodString;
                                    signedMessage: import("zod").ZodString;
                                    address: import("zod").ZodString;
                                    algo: import("zod").ZodOptional<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                                domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    resource: import("zod").ZodObject<{
                                        getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                        }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                        toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                    }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                                }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        }, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        }>, import("zod").ZodObject<{
                            account: import("zod").ZodAny;
                            authenticator: import("zod").ZodAny;
                            authData: import("zod").ZodLazy<import("zod").ZodObject<{
                                authMethodId: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                                authMethodType: import("zod").ZodPipeline<import("zod").ZodNumber, import("zod").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: import("zod").ZodString;
                                publicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                                metadata: import("zod").ZodOptional<import("zod").ZodAny>;
                            }, "strip", import("zod").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: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                            sessionKeyPair: import("zod").ZodObject<{
                                publicKey: import("zod").ZodString;
                                secretKey: import("zod").ZodString;
                            }, "strip", import("zod").ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                                capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    sig: import("zod").ZodString;
                                    derivedVia: import("zod").ZodString;
                                    signedMessage: import("zod").ZodString;
                                    address: import("zod").ZodString;
                                    algo: import("zod").ZodOptional<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                                domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    resource: import("zod").ZodObject<{
                                        getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                        }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                        toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                    }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                                }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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: import("zod").ZodOptional<import("zod").ZodBigInt>;
                        bypassAutoHashing: import("zod").ZodOptional<import("zod").ZodBoolean>;
                        keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "chain" | "signingScheme">, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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;
                    }>;
                    bitcoin: import("zod").ZodEffects<import("zod").ZodObject<Omit<{
                        chain: import("zod").ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                        signingScheme: import("zod").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: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                        toSign: import("zod").ZodAny;
                        authContext: import("zod").ZodUnion<[import("zod").ZodObject<{
                            pkpPublicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                            chain: import("zod").ZodString;
                            sessionKeyPair: import("zod").ZodObject<{
                                publicKey: import("zod").ZodString;
                                secretKey: import("zod").ZodString;
                            }, "strip", import("zod").ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authNeededCallback: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                            authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                                capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    sig: import("zod").ZodString;
                                    derivedVia: import("zod").ZodString;
                                    signedMessage: import("zod").ZodString;
                                    address: import("zod").ZodString;
                                    algo: import("zod").ZodOptional<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                                domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    resource: import("zod").ZodObject<{
                                        getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                        }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                        toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                    }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                                }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        }, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        }>, import("zod").ZodObject<{
                            account: import("zod").ZodAny;
                            authenticator: import("zod").ZodAny;
                            authData: import("zod").ZodLazy<import("zod").ZodObject<{
                                authMethodId: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                                authMethodType: import("zod").ZodPipeline<import("zod").ZodNumber, import("zod").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: import("zod").ZodString;
                                publicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                                metadata: import("zod").ZodOptional<import("zod").ZodAny>;
                            }, "strip", import("zod").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: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                            sessionKeyPair: import("zod").ZodObject<{
                                publicKey: import("zod").ZodString;
                                secretKey: import("zod").ZodString;
                            }, "strip", import("zod").ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                                capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    sig: import("zod").ZodString;
                                    derivedVia: import("zod").ZodString;
                                    signedMessage: import("zod").ZodString;
                                    address: import("zod").ZodString;
                                    algo: import("zod").ZodOptional<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                                domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                                resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                    resource: import("zod").ZodObject<{
                                        getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                        }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                        toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                        resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                    }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                                }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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: import("zod").ZodOptional<import("zod").ZodBigInt>;
                        bypassAutoHashing: import("zod").ZodOptional<import("zod").ZodBoolean>;
                        keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "chain" | "signingScheme"> & {
                        signingScheme: import("zod").ZodEnum<["EcdsaK256Sha256", "SchnorrK256Sha256", "SchnorrK256Taproot"]>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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;
                    }>;
                };
                RequestData: import("zod").ZodEffects<import("zod").ZodObject<{
                    toSign: import("zod").ZodEffects<import("zod").ZodAny, number[], any>;
                    signingScheme: import("zod").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: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                    authSig: import("zod").ZodObject<{
                        sig: import("zod").ZodString;
                        derivedVia: import("zod").ZodString;
                        signedMessage: import("zod").ZodString;
                        address: import("zod").ZodString;
                        algo: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    nodeSet: import("zod").ZodEffects<import("zod").ZodArray<import("zod").ZodString, "many">, {
                        value: number;
                        socketAddress: string;
                    }[], string[]>;
                    chain: import("zod").ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                    bypassAutoHashing: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    keySetId: import("zod").ZodString;
                    epoch: import("zod").ZodDefault<import("zod").ZodNumber>;
                    authMethods: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodObject<{
                        authMethodType: import("zod").ZodNumber;
                        accessToken: import("zod").ZodString;
                    }, "strip", import("zod").ZodTypeAny, {
                        authMethodType: number;
                        accessToken: string;
                    }, {
                        authMethodType: number;
                        accessToken: string;
                    }>, "many">>;
                }, "strip", import("zod").ZodTypeAny, {
                    keySetId: string;
                    pubkey: string;
                    epoch: number;
                    chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
                    authMethods: {
                        authMethodType: number;
                        accessToken: string;
                    }[];
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    nodeSet: {
                        value: number;
                        socketAddress: string;
                    }[];
                    signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                    toSign: number[];
                    bypassAutoHashing?: boolean | undefined;
                }, {
                    keySetId: string;
                    pubkey: string;
                    chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    nodeSet: string[];
                    signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                    epoch?: number | undefined;
                    authMethods?: {
                        authMethodType: number;
                        accessToken: string;
                    }[] | undefined;
                    toSign?: any;
                    bypassAutoHashing?: boolean | undefined;
                }>, {
                    toSign: number[];
                    signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                    pubkey: string;
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    nodeSet: {
                        value: number;
                        socketAddress: string;
                    }[];
                    epoch: number;
                    authMethods: {
                        authMethodType: number;
                        accessToken: string;
                    }[];
                    keySetId: string;
                }, {
                    keySetId: string;
                    pubkey: string;
                    chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    nodeSet: string[];
                    signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                    epoch?: number | undefined;
                    authMethods?: {
                        authMethodType: number;
                        accessToken: string;
                    }[] | undefined;
                    toSign?: any;
                    bypassAutoHashing?: boolean | undefined;
                }>;
                ResponseData: import("zod").ZodObject<{
                    success: import("zod").ZodLiteral<true>;
                    values: import("zod").ZodArray<import("zod").ZodObject<{
                        success: import("zod").ZodBoolean;
                        signedData: import("zod").ZodArray<import("zod").ZodNumber, "many">;
                        signatureShare: import("zod").ZodUnion<[import("zod").ZodObject<{
                            EcdsaSignedMessageShare: import("zod").ZodObject<{
                                digest: import("zod").ZodString;
                                result: import("zod").ZodString;
                                share_id: import("zod").ZodString;
                                peer_id: import("zod").ZodString;
                                signature_share: import("zod").ZodString;
                                big_r: import("zod").ZodString;
                                compressed_public_key: import("zod").ZodString;
                                public_key: import("zod").ZodString;
                                sig_type: import("zod").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")[]]>;
                            }, "strip", import("zod").ZodTypeAny, {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            }, {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            }>;
                        }, "strip", import("zod").ZodTypeAny, {
                            EcdsaSignedMessageShare: {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            };
                        }, {
                            EcdsaSignedMessageShare: {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            };
                        }>, import("zod").ZodObject<{
                            FrostSignedMessageShare: import("zod").ZodObject<{
                                message: import("zod").ZodString;
                                result: import("zod").ZodString;
                                share_id: import("zod").ZodString;
                                peer_id: import("zod").ZodString;
                                signature_share: import("zod").ZodString;
                                signing_commitments: import("zod").ZodString;
                                verifying_share: import("zod").ZodString;
                                public_key: import("zod").ZodString;
                                sig_type: import("zod").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")[]]>;
                            }, "strip", import("zod").ZodTypeAny, {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            }, {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            }>;
                        }, "strip", import("zod").ZodTypeAny, {
                            FrostSignedMessageShare: {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            };
                        }, {
                            FrostSignedMessageShare: {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            };
                        }>]>;
                    }, "strip", import("zod").ZodTypeAny, {
                        success: boolean;
                        signedData: number[];
                        signatureShare: {
                            EcdsaSignedMessageShare: {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            };
                        } | {
                            FrostSignedMessageShare: {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            };
                        };
                    }, {
                        success: boolean;
                        signedData: number[];
                        signatureShare: {
                            EcdsaSignedMessageShare: {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            };
                        } | {
                            FrostSignedMessageShare: {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            };
                        };
                    }>, "many">;
                }, "strip", import("zod").ZodTypeAny, {
                    values: {
                        success: boolean;
                        signedData: number[];
                        signatureShare: {
                            EcdsaSignedMessageShare: {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            };
                        } | {
                            FrostSignedMessageShare: {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            };
                        };
                    }[];
                    success: true;
                }, {
                    values: {
                        success: boolean;
                        signedData: number[];
                        signatureShare: {
                            EcdsaSignedMessageShare: {
                                digest: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                big_r: string;
                                compressed_public_key: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                            };
                        } | {
                            FrostSignedMessageShare: {
                                message: string;
                                result: string;
                                share_id: string;
                                peer_id: string;
                                signature_share: string;
                                public_key: string;
                                sig_type: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                                signing_commitments: string;
                                verifying_share: string;
                            };
                        };
                    }[];
                    success: true;
                }>;
            };
            createRequest: (params: import("../../shared").PKPSignCreateRequestParams) => Promise<import("dist/packages/types/src").RequestItem<import("zod").TypeOf<typeof import("dist/packages/schemas/src").EncryptedVersion1Schema>>[]>;
            handleResponse: (result: import("zod").TypeOf<typeof import("dist/packages/schemas/src").GenericEncryptedPayloadSchema>, requestId: string, jitContext: import("dist/packages/types/src").NagaJitContext) => Promise<import("dist/packages/types/src").LitNodeSignature>;
        };
        decrypt: {
            schemas: {
                Input: import("zod").ZodUnion<[import("zod").ZodObject<{
                    ciphertext: import("zod").ZodString;
                    dataToEncryptHash: import("zod").ZodString;
                    metadata: import("zod").ZodOptional<import("zod").ZodObject<{
                        dataType: import("zod").ZodOptional<import("zod").ZodEnum<["uint8array", "string", "json", "buffer", "image", "video", "file"]>>;
                        mimeType: import("zod").ZodOptional<import("zod").ZodString>;
                        filename: import("zod").ZodOptional<import("zod").ZodString>;
                        size: import("zod").ZodOptional<import("zod").ZodNumber>;
                        custom: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
                    }, "strip", import("zod").ZodTypeAny, {
                        custom?: Record<string, any> | undefined;
                        dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                        mimeType?: string | undefined;
                        filename?: string | undefined;
                        size?: number | undefined;
                    }, {
                        custom?: Record<string, any> | undefined;
                        dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                        mimeType?: string | undefined;
                        filename?: string | undefined;
                        size?: number | undefined;
                    }>>;
                } & {
                    accessControlConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[]>>;
                    evmContractConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[]>>;
                    solRpcConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[]>>;
                    unifiedAccessControlConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[]>>;
                } & {
                    chain: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodString>>;
                } & {
                    userMaxPrice: import("zod").ZodOptional<import("zod").ZodBigInt>;
                } & {
                    authContext: import("zod").ZodUnion<[import("zod").ZodObject<{
                        pkpPublicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                        chain: import("zod").ZodString;
                        sessionKeyPair: import("zod").ZodObject<{
                            publicKey: import("zod").ZodString;
                            secretKey: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authNeededCallback: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                        authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                            capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                sig: import("zod").ZodString;
                                derivedVia: import("zod").ZodString;
                                signedMessage: import("zod").ZodString;
                                address: import("zod").ZodString;
                                algo: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                            domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                resource: import("zod").ZodObject<{
                                    getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                    }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                    toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    }, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        pkpPublicKey?: string | undefined;
                        authConfig?: unknown;
                    }>, import("zod").ZodObject<{
                        account: import("zod").ZodAny;
                        authenticator: import("zod").ZodAny;
                        authData: import("zod").ZodLazy<import("zod").ZodObject<{
                            authMethodId: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                            authMethodType: import("zod").ZodPipeline<import("zod").ZodNumber, import("zod").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: import("zod").ZodString;
                            publicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                            metadata: import("zod").ZodOptional<import("zod").ZodAny>;
                        }, "strip", import("zod").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: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                        sessionKeyPair: import("zod").ZodObject<{
                            publicKey: import("zod").ZodString;
                            secretKey: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                            capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                sig: import("zod").ZodString;
                                derivedVia: import("zod").ZodString;
                                signedMessage: import("zod").ZodString;
                                address: import("zod").ZodString;
                                algo: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                            domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                resource: import("zod").ZodObject<{
                                    getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                    }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                    toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").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;
                    }>]>;
                    authSig: import("zod").ZodOptional<import("zod").ZodObject<{
                        sig: import("zod").ZodString;
                        derivedVia: import("zod").ZodString;
                        signedMessage: import("zod").ZodString;
                        address: import("zod").ZodString;
                        algo: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>>;
                    keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                }, "strip", import("zod").ZodTypeAny, {
                    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("dist/packages/schemas/src").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("dist/packages/schemas/src").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;
                    };
                    ciphertext: string;
                    dataToEncryptHash: string;
                    chain?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    keySetIdentifier?: string | undefined;
                    metadata?: {
                        custom?: Record<string, any> | undefined;
                        dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                        mimeType?: string | undefined;
                        filename?: string | undefined;
                        size?: number | undefined;
                    } | undefined;
                    accessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[] | undefined;
                    evmContractConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[] | undefined;
                    solRpcConditions?: import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[] | undefined;
                    unifiedAccessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[] | undefined;
                    authSig?: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    } | undefined;
                }, {
                    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;
                    };
                    ciphertext: string;
                    dataToEncryptHash: string;
                    chain?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    keySetIdentifier?: string | undefined;
                    metadata?: {
                        custom?: Record<string, any> | undefined;
                        dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                        mimeType?: string | undefined;
                        filename?: string | undefined;
                        size?: number | undefined;
                    } | undefined;
                    accessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[] | undefined;
                    evmContractConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[] | undefined;
                    solRpcConditions?: import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[] | undefined;
                    unifiedAccessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[] | undefined;
                    authSig?: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    } | undefined;
                }>, import("zod").ZodObject<{
                    accessControlConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[]>>;
                    evmContractConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[]>>;
                    solRpcConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[]>>;
                    unifiedAccessControlConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[]>>;
                } & {
                    chain: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodString>>;
                } & {
                    userMaxPrice: import("zod").ZodOptional<import("zod").ZodBigInt>;
                } & {
                    authContext: import("zod").ZodUnion<[import("zod").ZodObject<{
                        pkpPublicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                        chain: import("zod").ZodString;
                        sessionKeyPair: import("zod").ZodObject<{
                            publicKey: import("zod").ZodString;
                            secretKey: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authNeededCallback: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                        authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                            capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                sig: import("zod").ZodString;
                                derivedVia: import("zod").ZodString;
                                signedMessage: import("zod").ZodString;
                                address: import("zod").ZodString;
                                algo: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                            domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                resource: import("zod").ZodObject<{
                                    getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                    }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                    toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    }, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        pkpPublicKey?: string | undefined;
                        authConfig?: unknown;
                    }>, import("zod").ZodObject<{
                        account: import("zod").ZodAny;
                        authenticator: import("zod").ZodAny;
                        authData: import("zod").ZodLazy<import("zod").ZodObject<{
                            authMethodId: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                            authMethodType: import("zod").ZodPipeline<import("zod").ZodNumber, import("zod").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: import("zod").ZodString;
                            publicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                            metadata: import("zod").ZodOptional<import("zod").ZodAny>;
                        }, "strip", import("zod").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: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                        sessionKeyPair: import("zod").ZodObject<{
                            publicKey: import("zod").ZodString;
                            secretKey: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                            capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                sig: import("zod").ZodString;
                                derivedVia: import("zod").ZodString;
                                signedMessage: import("zod").ZodString;
                                address: import("zod").ZodString;
                                algo: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                            domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                resource: import("zod").ZodObject<{
                                    getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                    }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                    toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").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;
                    }>]>;
                    authSig: import("zod").ZodOptional<import("zod").ZodObject<{
                        sig: import("zod").ZodString;
                        derivedVia: import("zod").ZodString;
                        signedMessage: import("zod").ZodString;
                        address: import("zod").ZodString;
                        algo: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>>;
                    keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                } & {
                    data: import("zod").ZodObject<{
                        ciphertext: import("zod").ZodString;
                        dataToEncryptHash: import("zod").ZodString;
                        metadata: import("zod").ZodOptional<import("zod").ZodObject<{
                            dataType: import("zod").ZodOptional<import("zod").ZodEnum<["uint8array", "string", "json", "buffer", "image", "video", "file"]>>;
                            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
                            filename: import("zod").ZodOptional<import("zod").ZodString>;
                            size: import("zod").ZodOptional<import("zod").ZodNumber>;
                            custom: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
                        }, "strip", import("zod").ZodTypeAny, {
                            custom?: Record<string, any> | undefined;
                            dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                            mimeType?: string | undefined;
                            filename?: string | undefined;
                            size?: number | undefined;
                        }, {
                            custom?: Record<string, any> | undefined;
                            dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                            mimeType?: string | undefined;
                            filename?: string | undefined;
                            size?: number | undefined;
                        }>>;
                    }, "strip", import("zod").ZodTypeAny, {
                        ciphertext: string;
                        dataToEncryptHash: string;
                        metadata?: {
                            custom?: Record<string, any> | undefined;
                            dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                            mimeType?: string | undefined;
                            filename?: string | undefined;
                            size?: number | undefined;
                        } | undefined;
                    }, {
                        ciphertext: string;
                        dataToEncryptHash: string;
                        metadata?: {
                            custom?: Record<string, any> | undefined;
                            dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                            mimeType?: string | undefined;
                            filename?: string | undefined;
                            size?: number | undefined;
                        } | undefined;
                    }>;
                }, "strip", import("zod").ZodTypeAny, {
                    data: {
                        ciphertext: string;
                        dataToEncryptHash: string;
                        metadata?: {
                            custom?: Record<string, any> | undefined;
                            dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                            mimeType?: string | undefined;
                            filename?: string | undefined;
                            size?: number | undefined;
                        } | undefined;
                    };
                    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("dist/packages/schemas/src").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("dist/packages/schemas/src").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;
                    };
                    chain?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    keySetIdentifier?: string | undefined;
                    accessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[] | undefined;
                    evmContractConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[] | undefined;
                    solRpcConditions?: import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[] | undefined;
                    unifiedAccessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[] | undefined;
                    authSig?: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    } | undefined;
                }, {
                    data: {
                        ciphertext: string;
                        dataToEncryptHash: string;
                        metadata?: {
                            custom?: Record<string, any> | undefined;
                            dataType?: "string" | "uint8array" | "json" | "buffer" | "image" | "video" | "file" | undefined;
                            mimeType?: string | undefined;
                            filename?: string | undefined;
                            size?: number | undefined;
                        } | undefined;
                    };
                    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;
                    };
                    chain?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    keySetIdentifier?: string | undefined;
                    accessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[] | undefined;
                    evmContractConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[] | undefined;
                    solRpcConditions?: import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[] | undefined;
                    unifiedAccessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[] | undefined;
                    authSig?: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    } | undefined;
                }>]>;
                RequestData: import("zod").ZodEffects<import("zod").ZodObject<{
                    accessControlConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[]>>;
                    evmContractConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[]>>;
                    solRpcConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[]>>;
                    unifiedAccessControlConditions: import("zod").ZodOptional<import("zod").ZodType<import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[], import("zod").ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[]>>;
                } & {
                    ciphertext: import("zod").ZodString;
                    dataToEncryptHash: import("zod").ZodString;
                    authSig: import("zod").ZodObject<{
                        sig: import("zod").ZodString;
                        derivedVia: import("zod").ZodString;
                        signedMessage: import("zod").ZodString;
                        address: import("zod").ZodString;
                        algo: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    chain: import("zod").ZodString;
                    keySetId: import("zod").ZodString;
                }, "strip", import("zod").ZodTypeAny, {
                    keySetId: string;
                    chain: string;
                    ciphertext: string;
                    dataToEncryptHash: string;
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    accessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[] | undefined;
                    evmContractConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[] | undefined;
                    solRpcConditions?: import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[] | undefined;
                    unifiedAccessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[] | undefined;
                }, {
                    keySetId: string;
                    chain: string;
                    ciphertext: string;
                    dataToEncryptHash: string;
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    accessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[] | undefined;
                    evmContractConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[] | undefined;
                    solRpcConditions?: import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[] | undefined;
                    unifiedAccessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[] | undefined;
                }>, {
                    accessControlConditions: any;
                    evmContractConditions: any;
                    solRpcConditions: any;
                    unifiedAccessControlConditions: any;
                    keySetId: string;
                    chain: string;
                    ciphertext: string;
                    dataToEncryptHash: string;
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                }, {
                    keySetId: string;
                    chain: string;
                    ciphertext: string;
                    dataToEncryptHash: string;
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    accessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[] | undefined;
                    evmContractConditions?: import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[] | undefined;
                    solRpcConditions?: import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[] | undefined;
                    unifiedAccessControlConditions?: import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[] | undefined;
                }>;
                ResponseData: import("zod").ZodObject<{
                    signatureShare: import("zod").ZodObject<{
                        ProofOfPossession: import("zod").ZodObject<{
                            identifier: import("zod").ZodString;
                            value: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            value: string;
                            identifier: string;
                        }, {
                            value: string;
                            identifier: string;
                        }>;
                    }, "strip", import("zod").ZodTypeAny, {
                        ProofOfPossession: {
                            value: string;
                            identifier: string;
                        };
                    }, {
                        ProofOfPossession: {
                            value: string;
                            identifier: string;
                        };
                    }>;
                    shareId: import("zod").ZodString;
                    share_id: import("zod").ZodOptional<import("zod").ZodString>;
                    signature_share: import("zod").ZodOptional<import("zod").ZodString>;
                }, "strip", import("zod").ZodTypeAny, {
                    signatureShare: {
                        ProofOfPossession: {
                            value: string;
                            identifier: string;
                        };
                    };
                    shareId: string;
                    share_id?: string | undefined;
                    signature_share?: string | undefined;
                }, {
                    signatureShare: {
                        ProofOfPossession: {
                            value: string;
                            identifier: string;
                        };
                    };
                    shareId: string;
                    share_id?: string | undefined;
                    signature_share?: string | undefined;
                }>;
            };
            createRequest: (params: import("../../shared").DecryptCreateRequestParams) => Promise<import("dist/packages/types/src").RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: import("zod").TypeOf<typeof import("dist/packages/schemas/src").GenericEncryptedPayloadSchema>, requestId: string, identityParam: string, ciphertext: string, subnetPubKey: string, jitContext: import("dist/packages/types/src").NagaJitContext) => Promise<{
                decryptedData: Uint8Array<ArrayBufferLike>;
            }>;
        };
        signSessionKey: {
            schemas: {};
            createRequest: (requestBody: import("zod").TypeOf<typeof import("dist/packages/schemas/src").JsonSignSessionKeyRequestForPkpReturnSchema>, httpProtocol: "http://" | "https://", version: string, jitContext: import("dist/packages/types/src").NagaJitContext) => Promise<import("dist/packages/types/src").RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: import("zod").TypeOf<typeof import("dist/packages/schemas/src").GenericEncryptedPayloadSchema>, pkpPublicKey: import("viem").Hex | string, jitContext: import("dist/packages/types/src").NagaJitContext, requestId: string) => Promise<{
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>;
        };
        signCustomSessionKey: {
            schemas: {};
            createRequest: (requestBody: import("zod").TypeOf<typeof import("dist/packages/schemas/src").JsonSignCustomSessionKeyRequestForPkpReturnSchema>, httpProtocol: "http://" | "https://", version: string, jitContext: import("dist/packages/types/src").NagaJitContext) => Promise<import("dist/packages/types/src").RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: import("zod").TypeOf<typeof import("dist/packages/schemas/src").GenericEncryptedPayloadSchema>, pkpPublicKey: import("viem").Hex | string, jitContext: import("dist/packages/types/src").NagaJitContext, requestId: string) => Promise<{
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>;
        };
        executeJs: {
            schemas: {
                Input: import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodObject<{
                    code: import("zod").ZodOptional<import("zod").ZodString>;
                    ipfsId: import("zod").ZodOptional<import("zod").ZodString>;
                    jsParams: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodAny, import("zod").ZodObject<{
                        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
                        sigName: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodAny, import("zod").objectOutputType<{
                        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
                        sigName: import("zod").ZodOptional<import("zod").ZodString>;
                    }, import("zod").ZodAny, "strip">, import("zod").objectInputType<{
                        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
                        sigName: import("zod").ZodOptional<import("zod").ZodString>;
                    }, import("zod").ZodAny, "strip">>]>>;
                    keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                    userMaxPrice: import("zod").ZodOptional<import("zod").ZodBigInt>;
                    useSingleNode: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    responseStrategy: import("zod").ZodOptional<import("zod").ZodType<{
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }, import("zod").ZodTypeDef, {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }>>;
                } & {
                    authContext: import("zod").ZodUnion<[import("zod").ZodObject<{
                        pkpPublicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                        chain: import("zod").ZodString;
                        sessionKeyPair: import("zod").ZodObject<{
                            publicKey: import("zod").ZodString;
                            secretKey: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authNeededCallback: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                        authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                            capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                sig: import("zod").ZodString;
                                derivedVia: import("zod").ZodString;
                                signedMessage: import("zod").ZodString;
                                address: import("zod").ZodString;
                                algo: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                            domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                resource: import("zod").ZodObject<{
                                    getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                    }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                    toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    }, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        pkpPublicKey?: string | undefined;
                        authConfig?: unknown;
                    }>, import("zod").ZodObject<{
                        account: import("zod").ZodAny;
                        authenticator: import("zod").ZodAny;
                        authData: import("zod").ZodLazy<import("zod").ZodObject<{
                            authMethodId: import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>;
                            authMethodType: import("zod").ZodPipeline<import("zod").ZodNumber, import("zod").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: import("zod").ZodString;
                            publicKey: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodEffects<import("zod").ZodString, string, string>, string, string>>;
                            metadata: import("zod").ZodOptional<import("zod").ZodAny>;
                        }, "strip", import("zod").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: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodUnknown>;
                        sessionKeyPair: import("zod").ZodObject<{
                            publicKey: import("zod").ZodString;
                            secretKey: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authConfig: import("zod").ZodLazy<import("zod").ZodEffects<import("zod").ZodObject<{
                            capabilityAuthSigs: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                sig: import("zod").ZodString;
                                derivedVia: import("zod").ZodString;
                                signedMessage: import("zod").ZodString;
                                address: import("zod").ZodString;
                                algo: import("zod").ZodOptional<import("zod").ZodString>;
                            }, "strip", import("zod").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: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            statement: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
                            domain: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>, string, string | undefined>>>;
                            resources: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                                resource: import("zod").ZodObject<{
                                    getResourceKey: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    isValidLitAbility: import("zod").ZodFunction<import("zod").ZodTuple<[import("zod").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";
                                    }>], import("zod").ZodUnknown>, import("zod").ZodBoolean>;
                                    toString: import("zod").ZodFunction<import("zod").ZodTuple<[], import("zod").ZodUnknown>, import("zod").ZodString>;
                                    resourcePrefix: import("zod").ZodReadonly<import("zod").ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: import("zod").ZodReadonly<import("zod").ZodString>;
                                }, "strip", import("zod").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: import("zod").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: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodType<import("dist/packages/schemas/src").DefinedJson, import("zod").ZodTypeDef, import("dist/packages/schemas/src").DefinedJson>>>;
                            }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                        }, "strip", import("zod").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("dist/packages/schemas/src").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("dist/packages/schemas/src").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("dist/packages/schemas/src").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", import("zod").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("dist/packages/schemas/src").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;
                    }>]>;
                    sessionSigs: import("zod").ZodOptional<import("zod").ZodUndefined>;
                }, "strip", import("zod").ZodTypeAny, {
                    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("dist/packages/schemas/src").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("dist/packages/schemas/src").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;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    sessionSigs?: undefined;
                }, {
                    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;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    sessionSigs?: undefined;
                }>, import("zod").ZodObject<{
                    code: import("zod").ZodOptional<import("zod").ZodString>;
                    ipfsId: import("zod").ZodOptional<import("zod").ZodString>;
                    jsParams: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodAny, import("zod").ZodObject<{
                        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
                        sigName: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodAny, import("zod").objectOutputType<{
                        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
                        sigName: import("zod").ZodOptional<import("zod").ZodString>;
                    }, import("zod").ZodAny, "strip">, import("zod").objectInputType<{
                        publicKey: import("zod").ZodOptional<import("zod").ZodString>;
                        sigName: import("zod").ZodOptional<import("zod").ZodString>;
                    }, import("zod").ZodAny, "strip">>]>>;
                    keySetIdentifier: import("zod").ZodOptional<import("zod").ZodString>;
                    userMaxPrice: import("zod").ZodOptional<import("zod").ZodBigInt>;
                    useSingleNode: import("zod").ZodOptional<import("zod").ZodBoolean>;
                    responseStrategy: import("zod").ZodOptional<import("zod").ZodType<{
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }, import("zod").ZodTypeDef, {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }>>;
                } & {
                    sessionSigs: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
                        sig: import("zod").ZodString;
                        derivedVia: import("zod").ZodString;
                        signedMessage: import("zod").ZodString;
                        address: import("zod").ZodString;
                        algo: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>>;
                    authContext: import("zod").ZodOptional<import("zod").ZodUndefined>;
                }, "strip", import("zod").ZodTypeAny, {
                    sessionSigs: Record<string, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    keySetIdentifier?: string | undefined;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    authContext?: undefined;
                }, {
                    sessionSigs: Record<string, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    keySetIdentifier?: string | undefined;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    authContext?: undefined;
                }>]>, {
                    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("dist/packages/schemas/src").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("dist/packages/schemas/src").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;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    sessionSigs?: undefined;
                } | {
                    sessionSigs: Record<string, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    keySetIdentifier?: string | undefined;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    authContext?: undefined;
                }, {
                    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;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    sessionSigs?: undefined;
                } | {
                    sessionSigs: Record<string, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    keySetIdentifier?: string | undefined;
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    userMaxPrice?: bigint | undefined;
                    responseStrategy?: {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    } | undefined;
                    jsParams?: any;
                    useSingleNode?: boolean | undefined;
                    authContext?: undefined;
                }>;
                RequestData: import("zod").ZodObject<{
                    code: import("zod").ZodOptional<import("zod").ZodString>;
                    ipfsId: import("zod").ZodOptional<import("zod").ZodString>;
                    jsParams: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
                    authSig: import("zod").ZodObject<{
                        sig: import("zod").ZodString;
                        derivedVia: import("zod").ZodString;
                        signedMessage: import("zod").ZodString;
                        address: import("zod").ZodString;
                        algo: import("zod").ZodOptional<import("zod").ZodString>;
                    }, "strip", import("zod").ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    nodeSet: import("zod").ZodEffects<import("zod").ZodArray<import("zod").ZodString, "many">, {
                        value: number;
                        socketAddress: string;
                    }[], string[]>;
                    keySetId: import("zod").ZodString;
                }, "strip", import("zod").ZodTypeAny, {
                    keySetId: string;
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    nodeSet: {
                        value: number;
                        socketAddress: string;
                    }[];
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    jsParams?: Record<string, any> | undefined;
                }, {
                    keySetId: string;
                    authSig: {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    };
                    nodeSet: string[];
                    code?: string | undefined;
                    ipfsId?: string | undefined;
                    jsParams?: Record<string, any> | undefined;
                }>;
                ResponseData: import("zod").ZodObject<{
                    success: import("zod").ZodBoolean;
                    values: import("zod").ZodArray<import("zod").ZodObject<{
                        nodeUrl: import("zod").ZodOptional<import("zod").ZodString>;
                        success: import("zod").ZodBoolean;
                        claimData: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
                            signatures: import("zod").ZodArray<import("zod").ZodAny, "many">;
                            derivedKeyId: import("zod").ZodString;
                        }, "strip", import("zod").ZodTypeAny, {
                            derivedKeyId: string;
                            signatures: any[];
                        }, {
                            derivedKeyId: string;
                            signatures: any[];
                        }>>;
                        decryptedData: import("zod").ZodAny;
                        logs: import("zod").ZodString;
                        response: import("zod").ZodString;
                        signedData: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>;
                        paymentDetail: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
                            component: import("zod").ZodString;
                            quantity: import("zod").ZodNumber;
                            price: import("zod").ZodEffects<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNumber]>, bigint, string | number>;
                        }, "strip", import("zod").ZodTypeAny, {
                            price: bigint;
                            component: string;
                            quantity: number;
                        }, {
                            price: string | number;
                            component: string;
                            quantity: number;
                        }>, "many">>;
                    }, "strip", import("zod").ZodTypeAny, {
                        success: boolean;
                        signedData: Record<string, any>;
                        claimData: Record<string, {
                            derivedKeyId: string;
                            signatures: any[];
                        }>;
                        logs: string;
                        response: string;
                        nodeUrl?: string | undefined;
                        decryptedData?: any;
                        paymentDetail?: {
                            price: bigint;
                            component: string;
                            quantity: number;
                        }[] | undefined;
                    }, {
                        success: boolean;
                        signedData: Record<string, any>;
                        claimData: Record<string, {
                            derivedKeyId: string;
                            signatures: any[];
                        }>;
                        logs: string;
                        response: string;
                        nodeUrl?: string | undefined;
                        decryptedData?: any;
                        paymentDetail?: {
                            price: string | number;
                            component: string;
                            quantity: number;
                        }[] | undefined;
                    }>, "many">;
                }, "strip", import("zod").ZodTypeAny, {
                    success: boolean;
                    values: {
                        success: boolean;
                        signedData: Record<string, any>;
                        claimData: Record<string, {
                            derivedKeyId: string;
                            signatures: any[];
                        }>;
                        logs: string;
                        response: string;
                        nodeUrl?: string | undefined;
                        decryptedData?: any;
                        paymentDetail?: {
                            price: bigint;
                            component: string;
                            quantity: number;
                        }[] | undefined;
                    }[];
                }, {
                    success: boolean;
                    values: {
                        success: boolean;
                        signedData: Record<string, any>;
                        claimData: Record<string, {
                            derivedKeyId: string;
                            signatures: any[];
                        }>;
                        logs: string;
                        response: string;
                        nodeUrl?: string | undefined;
                        decryptedData?: any;
                        paymentDetail?: {
                            price: string | number;
                            component: string;
                            quantity: number;
                        }[] | undefined;
                    }[];
                }>;
            };
            createRequest: (params: import("../../shared").ExecuteJsCreateRequestParams) => Promise<import("dist/packages/types/src").RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: import("zod").TypeOf<typeof import("dist/packages/schemas/src").GenericEncryptedPayloadSchema>, requestId: string, jitContext: import("dist/packages/types/src").NagaJitContext) => Promise<import("dist/packages/types/src").ExecuteJsResponse>;
        };
    };
    withOverrides: (overrides: {
        rpcUrl?: string;
    }) => /*elided*/ any;
};
export type NagaDevUnifiedModule = typeof nagaDev;
export { nagaDev };