import { AuthData, AuthDataInput, EncryptedVersion1Schema, GenericEncryptedPayloadSchema, JsonSignCustomSessionKeyRequestForPkpReturnSchema, JsonSignSessionKeyRequestForPkpReturnSchema, ScopeStringSchema } from '@lit-protocol/schemas';
import { Hex } from 'viem';
import { z } from 'zod';
import type { INetworkConfig } from '../interfaces/NetworkContext';
import type { ExpectedAccountOrWalletClient } from '../managers/contract-manager/createContractsManager';
import { createChainManagerFactory } from './BaseChainManagerFactory';
import { ReleaseVerificationConfig } from '@lit-protocol/crypto';
import { CallbackParams, NagaJitContext, NodeAttestation, Optional, OrchestrateHandshakeResponse, RequestItem } from '@lit-protocol/types';
import type { PKPStorageProvider } from '../../../../storage/types';
import { PKPPermissionsManager } from '../managers/LitChainClient/apis/highLevelApis';
import { MintWithMultiAuthsRequest } from '../managers/LitChainClient/apis/highLevelApis/mintPKP/mintWithMultiAuths';
import { PaymentManager } from '../managers/LitChainClient/apis/highLevelApis/PaymentManager/PaymentManager';
import { PkpIdentifierRaw } from '../managers/LitChainClient/apis/rawContractApis/permissions/utils/resolvePkpTokenId';
import type { GenericTxRes, LitTxRes } from '../managers/LitChainClient/apis/types';
import type { PKPData } from '../managers/LitChainClient/schemas/shared/PKPDataSchema';
import { ConnectionInfo } from '../managers/LitChainClient/types';
import { getMaxPricesForNodeProduct } from '../managers/pricing-manager/getMaxPricesForNodeProduct';
import { createStateManager } from '../managers/state-manager/createStateManager';
import { DecryptCreateRequestParams } from '../managers/api-manager/decrypt/decrypt.CreateRequestParams';
import { ExecuteJsCreateRequestParams } from '../managers/api-manager/executeJs/executeJs.CreateRequestParams';
import { PKPSignCreateRequestParams } from '../managers/api-manager/pkpSign/pkpSign.CreateRequestParams';
export interface BaseModuleConfig<T, M> {
    networkConfig: INetworkConfig<T, M>;
    moduleName: string;
    createChainManager: (account: ExpectedAccountOrWalletClient) => ReturnType<typeof createChainManagerFactory>;
    verifyReleaseId?: (attestation: NodeAttestation, config: ReleaseVerificationConfig) => Promise<void>;
}
/**
 * Factory function that creates a complete network module for any environment
 * This eliminates code duplication by providing a single implementation
 * that can be configured for different environments
 */
export declare function createBaseModule<T, M>(config: BaseModuleConfig<T, M>): {
    id: string;
    version: string;
    config: {
        requiredAttestation: boolean;
        abortTimeout: number;
        minimumThreshold: number;
        httpProtocol: "http://" | "https://";
    };
    schemas: {
        GenericResponseSchema: <T_1 extends z.ZodTypeAny>(dataSchema: T_1) => z.ZodEffects<z.ZodObject<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }>, any> extends infer T_1_1 ? { [k in keyof T_1_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }>, any>[k]; } : never, z.baseObjectInputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }>[k_1]; } : never>, (z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }>, any> extends infer T_3 ? { [k in keyof T_3]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }>, any>[k]; } : never) & {
            parseData: () => z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
                ok: z.ZodBoolean;
                error: z.ZodNullable<z.ZodString>;
                errorObject: z.ZodNullable<z.ZodAny>;
                data: T_1;
            }>, any>["data"] | undefined;
        }, z.baseObjectInputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }> extends infer T_4 ? { [k_1 in keyof T_4]: z.baseObjectInputType<{
            ok: z.ZodBoolean;
            error: z.ZodNullable<z.ZodString>;
            errorObject: z.ZodNullable<z.ZodAny>;
            data: T_1;
        }>[k_1]; } : never>;
    };
    getNetworkName: () => string;
    getHttpProtocol: () => "http://" | "https://";
    getEndpoints: () => import("../managers/endpoints-manager/endpoints").NagaEndpointsType;
    getRpcUrl: () => string;
    getChainConfig: () => import("viem").Chain;
    getDefaultLoginBaseUrl: () => string;
    getMinimumThreshold: () => number;
    createStateManager: <StateT, ModuleT>(params: {
        callback: (params: CallbackParams) => Promise<StateT>;
        networkModule: ModuleT;
    }) => Promise<Awaited<ReturnType<typeof createStateManager<StateT>>>>;
    getMaxPricesForNodeProduct: typeof getMaxPricesForNodeProduct;
    getUserMaxPrice: (params: {
        product: keyof typeof import("../managers/pricing-manager/constants").PRODUCT_IDS;
    }) => bigint;
    getVerifyReleaseId: () => (attestation: NodeAttestation, config: ReleaseVerificationConfig) => Promise<void>;
    chainApi: {
        getPKPPermissionsManager: (params: {
            pkpIdentifier: PkpIdentifierRaw;
            account: ExpectedAccountOrWalletClient;
        }) => Promise<PKPPermissionsManager>;
        getPaymentManager: (params: {
            account: ExpectedAccountOrWalletClient;
        }) => Promise<PaymentManager>;
        getPKPsByAuthData: (params: {
            authData: Partial<AuthData>;
            pagination?: {
                limit?: number;
                offset?: number;
            };
            storageProvider?: PKPStorageProvider;
            account: ExpectedAccountOrWalletClient;
        }) => Promise<import("../managers/LitChainClient/apis/highLevelApis/PKPPermissionsManager/handlers/getPKPsByAuthMethod").PaginatedPKPsResponse>;
        getPKPsByAddress: (params: {
            ownerAddress: string;
            pagination?: {
                limit?: number;
                offset?: number;
            };
            storageProvider?: PKPStorageProvider;
            account: ExpectedAccountOrWalletClient;
        }) => Promise<import("../managers/LitChainClient/apis/highLevelApis/PKPPermissionsManager/handlers/getPKPsByAuthMethod").PaginatedPKPsResponse>;
        mintWithEoa: (params: {
            account: ExpectedAccountOrWalletClient;
        }) => Promise<GenericTxRes<LitTxRes<PKPData>, PKPData>>;
        mintWithAuth: (params: {
            account: ExpectedAccountOrWalletClient;
            authData: Optional<AuthDataInput, "accessToken">;
            scopes: z.infer<typeof ScopeStringSchema>[];
        }) => Promise<GenericTxRes<LitTxRes<PKPData>, PKPData>>;
        mintWithMultiAuths: (params: {
            account: ExpectedAccountOrWalletClient;
        } & MintWithMultiAuthsRequest) => Promise<GenericTxRes<LitTxRes<PKPData>, PKPData>>;
    };
    authService: {
        pkpMint: (params: {
            authData: AuthData;
            authServiceBaseUrl: string;
            scopes?: ("sign-anything" | "personal-sign" | "no-permissions")[];
            apiKey?: string;
        }) => Promise<import("@lit-protocol/types").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: {
        /**
         * Creates JIT context for network operations
         */
        createJitContext: (connectionInfo: ConnectionInfo, handshakeResult: OrchestrateHandshakeResponse) => Promise<NagaJitContext>;
        /**
         * Handshake API
         */
        handshake: {
            schemas: {
                Input: {
                    ResponseData: z.ZodEffects<z.ZodObject<{
                        ok: z.ZodBoolean;
                        error: z.ZodNullable<z.ZodString>;
                        errorObject: z.ZodNullable<z.ZodAny>;
                        data: z.ZodObject<{
                            serverPublicKey: z.ZodString;
                            subnetPublicKey: z.ZodString;
                            networkPublicKey: z.ZodString;
                            networkPublicKeySet: z.ZodString;
                            clientSdkVersion: z.ZodString;
                            hdRootPubkeys: z.ZodArray<z.ZodString, "many">;
                            attestation: z.ZodOptional<z.ZodAny>;
                            latestBlockhash: z.ZodString;
                            nodeIdentityKey: z.ZodString;
                            nodeVersion: z.ZodString;
                            epoch: z.ZodNumber;
                        }, "strip", z.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", z.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;
                    }>;
                };
            };
        };
        /**
         * PKP Sign API - shared implementation
         */
        pkpSign: {
            schemas: {
                Input: {
                    raw: z.ZodObject<{
                        chain: z.ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                        signingScheme: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
                        pubKey: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                        toSign: z.ZodAny;
                        authContext: z.ZodUnion<[z.ZodObject<{
                            pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                            chain: z.ZodString;
                            sessionKeyPair: z.ZodObject<{
                                publicKey: z.ZodString;
                                secretKey: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                            authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                                capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    sig: z.ZodString;
                                    derivedVia: z.ZodString;
                                    signedMessage: z.ZodString;
                                    address: z.ZodString;
                                    algo: z.ZodOptional<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }>, "many">>>;
                                expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                                domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    resource: z.ZodObject<{
                                        getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                            readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                            readonly AccessControlConditionSigning: "access-control-condition-signing";
                                            readonly PKPSigning: "pkp-signing";
                                            readonly PaymentDelegation: "lit-payment-delegation";
                                            readonly LitActionExecution: "lit-action-execution";
                                        }>], z.ZodUnknown>, z.ZodBoolean>;
                                        toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: z.ZodReadonly<z.ZodString>;
                                    }, "strip", z.ZodTypeAny, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }>;
                                    ability: z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>;
                                    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                                }, "strip", z.ZodTypeAny, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, {
                                keySetIdentifier?: string | undefined;
                                capabilityAuthSigs?: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[] | undefined;
                                expiration?: string | undefined;
                                statement?: string | undefined;
                                domain?: string | undefined;
                                resources?: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[] | undefined;
                            }>, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", z.ZodTypeAny, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        }, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        }>, z.ZodObject<{
                            account: z.ZodAny;
                            authenticator: z.ZodAny;
                            authData: z.ZodLazy<z.ZodObject<{
                                authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                                authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                                    readonly EthWallet: 1;
                                    readonly LitAction: 2;
                                    readonly WebAuthn: 3;
                                    readonly Discord: 4;
                                    readonly Google: 5;
                                    readonly GoogleJwt: 6;
                                    readonly AppleJwt: 8;
                                    readonly StytchOtp: 9;
                                    readonly StytchEmailFactorOtp: 10;
                                    readonly StytchSmsFactorOtp: 11;
                                    readonly StytchWhatsAppFactorOtp: 12;
                                    readonly StytchTotpFactorOtp: 13;
                                }>>;
                                accessToken: z.ZodString;
                                publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                                metadata: z.ZodOptional<z.ZodAny>;
                            }, "strip", z.ZodTypeAny, {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            }, {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            }>>;
                            authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                            sessionKeyPair: z.ZodObject<{
                                publicKey: z.ZodString;
                                secretKey: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                                capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    sig: z.ZodString;
                                    derivedVia: z.ZodString;
                                    signedMessage: z.ZodString;
                                    address: z.ZodString;
                                    algo: z.ZodOptional<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }>, "many">>>;
                                expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                                domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    resource: z.ZodObject<{
                                        getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                            readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                            readonly AccessControlConditionSigning: "access-control-condition-signing";
                                            readonly PKPSigning: "pkp-signing";
                                            readonly PaymentDelegation: "lit-payment-delegation";
                                            readonly LitActionExecution: "lit-action-execution";
                                        }>], z.ZodUnknown>, z.ZodBoolean>;
                                        toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: z.ZodReadonly<z.ZodString>;
                                    }, "strip", z.ZodTypeAny, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }>;
                                    ability: z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>;
                                    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                                }, "strip", z.ZodTypeAny, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, {
                                keySetIdentifier?: string | undefined;
                                capabilityAuthSigs?: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[] | undefined;
                                expiration?: string | undefined;
                                statement?: string | undefined;
                                domain?: string | undefined;
                                resources?: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[] | undefined;
                            }>, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", z.ZodTypeAny, {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        }, {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        }>]>;
                        userMaxPrice: z.ZodOptional<z.ZodBigInt>;
                        bypassAutoHashing: z.ZodOptional<z.ZodBoolean>;
                        keySetIdentifier: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        pubKey: string;
                        chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        };
                        signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }, {
                        pubKey: string;
                        chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        };
                        signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }>;
                    ethereum: z.ZodEffects<z.ZodObject<Omit<{
                        chain: z.ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                        signingScheme: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
                        pubKey: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                        toSign: z.ZodAny;
                        authContext: z.ZodUnion<[z.ZodObject<{
                            pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                            chain: z.ZodString;
                            sessionKeyPair: z.ZodObject<{
                                publicKey: z.ZodString;
                                secretKey: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                            authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                                capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    sig: z.ZodString;
                                    derivedVia: z.ZodString;
                                    signedMessage: z.ZodString;
                                    address: z.ZodString;
                                    algo: z.ZodOptional<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }>, "many">>>;
                                expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                                domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    resource: z.ZodObject<{
                                        getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                            readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                            readonly AccessControlConditionSigning: "access-control-condition-signing";
                                            readonly PKPSigning: "pkp-signing";
                                            readonly PaymentDelegation: "lit-payment-delegation";
                                            readonly LitActionExecution: "lit-action-execution";
                                        }>], z.ZodUnknown>, z.ZodBoolean>;
                                        toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: z.ZodReadonly<z.ZodString>;
                                    }, "strip", z.ZodTypeAny, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }>;
                                    ability: z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>;
                                    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                                }, "strip", z.ZodTypeAny, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, {
                                keySetIdentifier?: string | undefined;
                                capabilityAuthSigs?: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[] | undefined;
                                expiration?: string | undefined;
                                statement?: string | undefined;
                                domain?: string | undefined;
                                resources?: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[] | undefined;
                            }>, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", z.ZodTypeAny, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        }, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        }>, z.ZodObject<{
                            account: z.ZodAny;
                            authenticator: z.ZodAny;
                            authData: z.ZodLazy<z.ZodObject<{
                                authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                                authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                                    readonly EthWallet: 1;
                                    readonly LitAction: 2;
                                    readonly WebAuthn: 3;
                                    readonly Discord: 4;
                                    readonly Google: 5;
                                    readonly GoogleJwt: 6;
                                    readonly AppleJwt: 8;
                                    readonly StytchOtp: 9;
                                    readonly StytchEmailFactorOtp: 10;
                                    readonly StytchSmsFactorOtp: 11;
                                    readonly StytchWhatsAppFactorOtp: 12;
                                    readonly StytchTotpFactorOtp: 13;
                                }>>;
                                accessToken: z.ZodString;
                                publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                                metadata: z.ZodOptional<z.ZodAny>;
                            }, "strip", z.ZodTypeAny, {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            }, {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            }>>;
                            authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                            sessionKeyPair: z.ZodObject<{
                                publicKey: z.ZodString;
                                secretKey: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                                capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    sig: z.ZodString;
                                    derivedVia: z.ZodString;
                                    signedMessage: z.ZodString;
                                    address: z.ZodString;
                                    algo: z.ZodOptional<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }>, "many">>>;
                                expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                                domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    resource: z.ZodObject<{
                                        getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                            readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                            readonly AccessControlConditionSigning: "access-control-condition-signing";
                                            readonly PKPSigning: "pkp-signing";
                                            readonly PaymentDelegation: "lit-payment-delegation";
                                            readonly LitActionExecution: "lit-action-execution";
                                        }>], z.ZodUnknown>, z.ZodBoolean>;
                                        toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: z.ZodReadonly<z.ZodString>;
                                    }, "strip", z.ZodTypeAny, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }>;
                                    ability: z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>;
                                    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                                }, "strip", z.ZodTypeAny, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, {
                                keySetIdentifier?: string | undefined;
                                capabilityAuthSigs?: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[] | undefined;
                                expiration?: string | undefined;
                                statement?: string | undefined;
                                domain?: string | undefined;
                                resources?: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[] | undefined;
                            }>, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", z.ZodTypeAny, {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        }, {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        }>]>;
                        userMaxPrice: z.ZodOptional<z.ZodBigInt>;
                        bypassAutoHashing: z.ZodOptional<z.ZodBoolean>;
                        keySetIdentifier: z.ZodOptional<z.ZodString>;
                    }, "chain" | "signingScheme">, "strip", z.ZodTypeAny, {
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        };
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }, {
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        };
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }>, {
                        signingScheme: "EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate";
                        chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        };
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }, {
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        };
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }>;
                    bitcoin: z.ZodEffects<z.ZodObject<Omit<{
                        chain: z.ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                        signingScheme: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
                        pubKey: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                        toSign: z.ZodAny;
                        authContext: z.ZodUnion<[z.ZodObject<{
                            pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                            chain: z.ZodString;
                            sessionKeyPair: z.ZodObject<{
                                publicKey: z.ZodString;
                                secretKey: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                            authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                                capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    sig: z.ZodString;
                                    derivedVia: z.ZodString;
                                    signedMessage: z.ZodString;
                                    address: z.ZodString;
                                    algo: z.ZodOptional<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }>, "many">>>;
                                expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                                domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    resource: z.ZodObject<{
                                        getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                            readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                            readonly AccessControlConditionSigning: "access-control-condition-signing";
                                            readonly PKPSigning: "pkp-signing";
                                            readonly PaymentDelegation: "lit-payment-delegation";
                                            readonly LitActionExecution: "lit-action-execution";
                                        }>], z.ZodUnknown>, z.ZodBoolean>;
                                        toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: z.ZodReadonly<z.ZodString>;
                                    }, "strip", z.ZodTypeAny, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }>;
                                    ability: z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>;
                                    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                                }, "strip", z.ZodTypeAny, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, {
                                keySetIdentifier?: string | undefined;
                                capabilityAuthSigs?: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[] | undefined;
                                expiration?: string | undefined;
                                statement?: string | undefined;
                                domain?: string | undefined;
                                resources?: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[] | undefined;
                            }>, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", z.ZodTypeAny, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        }, {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        }>, z.ZodObject<{
                            account: z.ZodAny;
                            authenticator: z.ZodAny;
                            authData: z.ZodLazy<z.ZodObject<{
                                authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                                authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                                    readonly EthWallet: 1;
                                    readonly LitAction: 2;
                                    readonly WebAuthn: 3;
                                    readonly Discord: 4;
                                    readonly Google: 5;
                                    readonly GoogleJwt: 6;
                                    readonly AppleJwt: 8;
                                    readonly StytchOtp: 9;
                                    readonly StytchEmailFactorOtp: 10;
                                    readonly StytchSmsFactorOtp: 11;
                                    readonly StytchWhatsAppFactorOtp: 12;
                                    readonly StytchTotpFactorOtp: 13;
                                }>>;
                                accessToken: z.ZodString;
                                publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                                metadata: z.ZodOptional<z.ZodAny>;
                            }, "strip", z.ZodTypeAny, {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            }, {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            }>>;
                            authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                            sessionKeyPair: z.ZodObject<{
                                publicKey: z.ZodString;
                                secretKey: z.ZodString;
                            }, "strip", z.ZodTypeAny, {
                                publicKey: string;
                                secretKey: string;
                            }, {
                                publicKey: string;
                                secretKey: string;
                            }>;
                            authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                                capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    sig: z.ZodString;
                                    derivedVia: z.ZodString;
                                    signedMessage: z.ZodString;
                                    address: z.ZodString;
                                    algo: z.ZodOptional<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }, {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }>, "many">>>;
                                expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                                domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                                resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                    resource: z.ZodObject<{
                                        getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                            readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                            readonly AccessControlConditionSigning: "access-control-condition-signing";
                                            readonly PKPSigning: "pkp-signing";
                                            readonly PaymentDelegation: "lit-payment-delegation";
                                            readonly LitActionExecution: "lit-action-execution";
                                        }>], z.ZodUnknown>, z.ZodBoolean>;
                                        toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                        resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                            readonly AccessControlCondition: "lit-accesscontrolcondition";
                                            readonly PKP: "lit-pkp";
                                            readonly RLI: "lit-ratelimitincrease";
                                            readonly PaymentDelegation: "lit-paymentdelegation";
                                            readonly LitAction: "lit-litaction";
                                        }>>;
                                        resource: z.ZodReadonly<z.ZodString>;
                                    }, "strip", z.ZodTypeAny, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }, {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    }>;
                                    ability: z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>;
                                    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                                }, "strip", z.ZodTypeAny, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }, {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }>, "many">>>;
                                keySetIdentifier: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, {
                                keySetIdentifier?: string | undefined;
                                capabilityAuthSigs?: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[] | undefined;
                                expiration?: string | undefined;
                                statement?: string | undefined;
                                domain?: string | undefined;
                                resources?: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[] | undefined;
                            }>, {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            }, unknown>>;
                        }, "strip", z.ZodTypeAny, {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        }, {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        }>]>;
                        userMaxPrice: z.ZodOptional<z.ZodBigInt>;
                        bypassAutoHashing: z.ZodOptional<z.ZodBoolean>;
                        keySetIdentifier: z.ZodOptional<z.ZodString>;
                    }, "chain" | "signingScheme"> & {
                        signingScheme: z.ZodEnum<["EcdsaK256Sha256", "SchnorrK256Sha256", "SchnorrK256Taproot"]>;
                    }, "strip", z.ZodTypeAny, {
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        };
                        signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }, {
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        };
                        signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }>, {
                        chain: "ethereum" | "bitcoin" | "cosmos" | "solana";
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            pkpPublicKey?: string | undefined;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authConfig: {
                                capabilityAuthSigs: {
                                    sig: string;
                                    derivedVia: string;
                                    signedMessage: string;
                                    address: string;
                                    algo?: string | undefined;
                                }[];
                                expiration: string;
                                statement: string;
                                domain: string;
                                resources: {
                                    resource: {
                                        toString: (...args: unknown[]) => string;
                                        getResourceKey: (...args: unknown[]) => string;
                                        isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                        resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                        resource: string;
                                    };
                                    ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                    data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                                }[];
                                keySetIdentifier?: string | undefined;
                            };
                            authData: {
                                authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            account?: any;
                            authenticator?: any;
                        };
                        signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }, {
                        pubKey: string;
                        authContext: {
                            chain: string;
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            pkpPublicKey?: string | undefined;
                            authConfig?: unknown;
                        } | {
                            sessionKeyPair: {
                                publicKey: string;
                                secretKey: string;
                            };
                            authNeededCallback: (...args: unknown[]) => unknown;
                            authData: {
                                authMethodType: number;
                                accessToken: string;
                                authMethodId: string;
                                publicKey?: string | undefined;
                                metadata?: any;
                            };
                            authConfig?: unknown;
                            account?: any;
                            authenticator?: any;
                        };
                        signingScheme: "EcdsaK256Sha256" | "SchnorrK256Sha256" | "SchnorrK256Taproot";
                        keySetIdentifier?: string | undefined;
                        userMaxPrice?: bigint | undefined;
                        toSign?: any;
                        bypassAutoHashing?: boolean | undefined;
                    }>;
                };
                RequestData: z.ZodEffects<z.ZodObject<{
                    toSign: z.ZodEffects<z.ZodAny, number[], any>;
                    signingScheme: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
                    pubkey: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                    authSig: z.ZodObject<{
                        sig: z.ZodString;
                        derivedVia: z.ZodString;
                        signedMessage: z.ZodString;
                        address: z.ZodString;
                        algo: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    nodeSet: z.ZodEffects<z.ZodArray<z.ZodString, "many">, {
                        value: number;
                        socketAddress: string;
                    }[], string[]>;
                    chain: z.ZodEnum<["ethereum", "bitcoin", "cosmos", "solana"]>;
                    bypassAutoHashing: z.ZodOptional<z.ZodBoolean>;
                    keySetId: z.ZodString;
                    epoch: z.ZodDefault<z.ZodNumber>;
                    authMethods: z.ZodDefault<z.ZodArray<z.ZodObject<{
                        authMethodType: z.ZodNumber;
                        accessToken: z.ZodString;
                    }, "strip", z.ZodTypeAny, {
                        authMethodType: number;
                        accessToken: string;
                    }, {
                        authMethodType: number;
                        accessToken: string;
                    }>, "many">>;
                }, "strip", z.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: z.ZodObject<{
                    success: z.ZodLiteral<true>;
                    values: z.ZodArray<z.ZodObject<{
                        success: z.ZodBoolean;
                        signedData: z.ZodArray<z.ZodNumber, "many">;
                        signatureShare: z.ZodUnion<[z.ZodObject<{
                            EcdsaSignedMessageShare: z.ZodObject<{
                                digest: z.ZodString;
                                result: z.ZodString;
                                share_id: z.ZodString;
                                peer_id: z.ZodString;
                                signature_share: z.ZodString;
                                big_r: z.ZodString;
                                compressed_public_key: z.ZodString;
                                public_key: z.ZodString;
                                sig_type: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
                            }, "strip", z.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", z.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";
                            };
                        }>, z.ZodObject<{
                            FrostSignedMessageShare: z.ZodObject<{
                                message: z.ZodString;
                                result: z.ZodString;
                                share_id: z.ZodString;
                                peer_id: z.ZodString;
                                signature_share: z.ZodString;
                                signing_commitments: z.ZodString;
                                verifying_share: z.ZodString;
                                public_key: z.ZodString;
                                sig_type: z.ZodEnum<["EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate", ...("EcdsaK256Sha256" | "EcdsaP256Sha256" | "EcdsaP384Sha384" | "SchnorrEd25519Sha512" | "SchnorrK256Sha256" | "SchnorrP256Sha256" | "SchnorrP384Sha384" | "SchnorrRistretto25519Sha512" | "SchnorrEd448Shake256" | "SchnorrRedJubjubBlake2b512" | "SchnorrK256Taproot" | "SchnorrRedDecaf377Blake2b512" | "SchnorrkelSubstrate")[]]>;
                            }, "strip", z.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", z.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", z.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", z.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: PKPSignCreateRequestParams) => Promise<RequestItem<z.infer<typeof EncryptedVersion1Schema>>[]>;
            handleResponse: (result: z.infer<typeof GenericEncryptedPayloadSchema>, requestId: string, jitContext: NagaJitContext) => Promise<import("@lit-protocol/types").LitNodeSignature>;
        };
        /**
         * Decrypt API - shared implementation
         */
        decrypt: {
            schemas: {
                Input: z.ZodUnion<[z.ZodObject<{
                    ciphertext: z.ZodString;
                    dataToEncryptHash: z.ZodString;
                    metadata: z.ZodOptional<z.ZodObject<{
                        dataType: z.ZodOptional<z.ZodEnum<["uint8array", "string", "json", "buffer", "image", "video", "file"]>>;
                        mimeType: z.ZodOptional<z.ZodString>;
                        filename: z.ZodOptional<z.ZodString>;
                        size: z.ZodOptional<z.ZodNumber>;
                        custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    }, "strip", z.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: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[]>>;
                    evmContractConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[]>>;
                    solRpcConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[]>>;
                    unifiedAccessControlConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[]>>;
                } & {
                    chain: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                } & {
                    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
                } & {
                    authContext: z.ZodUnion<[z.ZodObject<{
                        pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                        chain: z.ZodString;
                        sessionKeyPair: z.ZodObject<{
                            publicKey: z.ZodString;
                            secretKey: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                sig: z.ZodString;
                                derivedVia: z.ZodString;
                                signedMessage: z.ZodString;
                                address: z.ZodString;
                                algo: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }>, "many">>>;
                            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                resource: z.ZodObject<{
                                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>], z.ZodUnknown>, z.ZodBoolean>;
                                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: z.ZodReadonly<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }>;
                                ability: z.ZodNativeEnum<{
                                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                                    readonly PKPSigning: "pkp-signing";
                                    readonly PaymentDelegation: "lit-payment-delegation";
                                    readonly LitActionExecution: "lit-action-execution";
                                }>;
                                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                            }, "strip", z.ZodTypeAny, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: z.ZodOptional<z.ZodString>;
                        }, "strip", z.ZodTypeAny, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, {
                            keySetIdentifier?: string | undefined;
                            capabilityAuthSigs?: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[] | undefined;
                            expiration?: string | undefined;
                            statement?: string | undefined;
                            domain?: string | undefined;
                            resources?: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[] | undefined;
                        }>, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", z.ZodTypeAny, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    }, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        pkpPublicKey?: string | undefined;
                        authConfig?: unknown;
                    }>, z.ZodObject<{
                        account: z.ZodAny;
                        authenticator: z.ZodAny;
                        authData: z.ZodLazy<z.ZodObject<{
                            authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                            authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                                readonly EthWallet: 1;
                                readonly LitAction: 2;
                                readonly WebAuthn: 3;
                                readonly Discord: 4;
                                readonly Google: 5;
                                readonly GoogleJwt: 6;
                                readonly AppleJwt: 8;
                                readonly StytchOtp: 9;
                                readonly StytchEmailFactorOtp: 10;
                                readonly StytchSmsFactorOtp: 11;
                                readonly StytchWhatsAppFactorOtp: 12;
                                readonly StytchTotpFactorOtp: 13;
                            }>>;
                            accessToken: z.ZodString;
                            publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                            metadata: z.ZodOptional<z.ZodAny>;
                        }, "strip", z.ZodTypeAny, {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        }, {
                            authMethodType: number;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        }>>;
                        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                        sessionKeyPair: z.ZodObject<{
                            publicKey: z.ZodString;
                            secretKey: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                sig: z.ZodString;
                                derivedVia: z.ZodString;
                                signedMessage: z.ZodString;
                                address: z.ZodString;
                                algo: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }>, "many">>>;
                            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                resource: z.ZodObject<{
                                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>], z.ZodUnknown>, z.ZodBoolean>;
                                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: z.ZodReadonly<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }>;
                                ability: z.ZodNativeEnum<{
                                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                                    readonly PKPSigning: "pkp-signing";
                                    readonly PaymentDelegation: "lit-payment-delegation";
                                    readonly LitActionExecution: "lit-action-execution";
                                }>;
                                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                            }, "strip", z.ZodTypeAny, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: z.ZodOptional<z.ZodString>;
                        }, "strip", z.ZodTypeAny, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, {
                            keySetIdentifier?: string | undefined;
                            capabilityAuthSigs?: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[] | undefined;
                            expiration?: string | undefined;
                            statement?: string | undefined;
                            domain?: string | undefined;
                            resources?: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[] | undefined;
                        }>, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", z.ZodTypeAny, {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        authData: {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        account?: any;
                        authenticator?: any;
                    }, {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authData: {
                            authMethodType: number;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        authConfig?: unknown;
                        account?: any;
                        authenticator?: any;
                    }>]>;
                    authSig: z.ZodOptional<z.ZodObject<{
                        sig: z.ZodString;
                        derivedVia: z.ZodString;
                        signedMessage: z.ZodString;
                        address: z.ZodString;
                        algo: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>>;
                    keySetIdentifier: z.ZodOptional<z.ZodString>;
                }, "strip", z.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("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    } | {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        authData: {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        account?: any;
                        authenticator?: any;
                    };
                    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;
                }>, z.ZodObject<{
                    accessControlConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[]>>;
                    evmContractConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[]>>;
                    solRpcConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[]>>;
                    unifiedAccessControlConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[]>>;
                } & {
                    chain: z.ZodOptional<z.ZodDefault<z.ZodString>>;
                } & {
                    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
                } & {
                    authContext: z.ZodUnion<[z.ZodObject<{
                        pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                        chain: z.ZodString;
                        sessionKeyPair: z.ZodObject<{
                            publicKey: z.ZodString;
                            secretKey: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                sig: z.ZodString;
                                derivedVia: z.ZodString;
                                signedMessage: z.ZodString;
                                address: z.ZodString;
                                algo: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }>, "many">>>;
                            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                resource: z.ZodObject<{
                                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>], z.ZodUnknown>, z.ZodBoolean>;
                                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: z.ZodReadonly<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }>;
                                ability: z.ZodNativeEnum<{
                                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                                    readonly PKPSigning: "pkp-signing";
                                    readonly PaymentDelegation: "lit-payment-delegation";
                                    readonly LitActionExecution: "lit-action-execution";
                                }>;
                                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                            }, "strip", z.ZodTypeAny, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: z.ZodOptional<z.ZodString>;
                        }, "strip", z.ZodTypeAny, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, {
                            keySetIdentifier?: string | undefined;
                            capabilityAuthSigs?: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[] | undefined;
                            expiration?: string | undefined;
                            statement?: string | undefined;
                            domain?: string | undefined;
                            resources?: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[] | undefined;
                        }>, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", z.ZodTypeAny, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    }, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        pkpPublicKey?: string | undefined;
                        authConfig?: unknown;
                    }>, z.ZodObject<{
                        account: z.ZodAny;
                        authenticator: z.ZodAny;
                        authData: z.ZodLazy<z.ZodObject<{
                            authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                            authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                                readonly EthWallet: 1;
                                readonly LitAction: 2;
                                readonly WebAuthn: 3;
                                readonly Discord: 4;
                                readonly Google: 5;
                                readonly GoogleJwt: 6;
                                readonly AppleJwt: 8;
                                readonly StytchOtp: 9;
                                readonly StytchEmailFactorOtp: 10;
                                readonly StytchSmsFactorOtp: 11;
                                readonly StytchWhatsAppFactorOtp: 12;
                                readonly StytchTotpFactorOtp: 13;
                            }>>;
                            accessToken: z.ZodString;
                            publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                            metadata: z.ZodOptional<z.ZodAny>;
                        }, "strip", z.ZodTypeAny, {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        }, {
                            authMethodType: number;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        }>>;
                        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                        sessionKeyPair: z.ZodObject<{
                            publicKey: z.ZodString;
                            secretKey: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                sig: z.ZodString;
                                derivedVia: z.ZodString;
                                signedMessage: z.ZodString;
                                address: z.ZodString;
                                algo: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }>, "many">>>;
                            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                resource: z.ZodObject<{
                                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>], z.ZodUnknown>, z.ZodBoolean>;
                                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: z.ZodReadonly<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }>;
                                ability: z.ZodNativeEnum<{
                                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                                    readonly PKPSigning: "pkp-signing";
                                    readonly PaymentDelegation: "lit-payment-delegation";
                                    readonly LitActionExecution: "lit-action-execution";
                                }>;
                                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                            }, "strip", z.ZodTypeAny, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: z.ZodOptional<z.ZodString>;
                        }, "strip", z.ZodTypeAny, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, {
                            keySetIdentifier?: string | undefined;
                            capabilityAuthSigs?: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[] | undefined;
                            expiration?: string | undefined;
                            statement?: string | undefined;
                            domain?: string | undefined;
                            resources?: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[] | undefined;
                        }>, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", z.ZodTypeAny, {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        authData: {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        account?: any;
                        authenticator?: any;
                    }, {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authData: {
                            authMethodType: number;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        authConfig?: unknown;
                        account?: any;
                        authenticator?: any;
                    }>]>;
                    authSig: z.ZodOptional<z.ZodObject<{
                        sig: z.ZodString;
                        derivedVia: z.ZodString;
                        signedMessage: z.ZodString;
                        address: z.ZodString;
                        algo: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>>;
                    keySetIdentifier: z.ZodOptional<z.ZodString>;
                } & {
                    data: z.ZodObject<{
                        ciphertext: z.ZodString;
                        dataToEncryptHash: z.ZodString;
                        metadata: z.ZodOptional<z.ZodObject<{
                            dataType: z.ZodOptional<z.ZodEnum<["uint8array", "string", "json", "buffer", "image", "video", "file"]>>;
                            mimeType: z.ZodOptional<z.ZodString>;
                            filename: z.ZodOptional<z.ZodString>;
                            size: z.ZodOptional<z.ZodNumber>;
                            custom: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                        }, "strip", z.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", z.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", z.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("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    } | {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        authData: {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        account?: any;
                        authenticator?: any;
                    };
                    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: z.ZodEffects<z.ZodObject<{
                    accessControlConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmBasicCondition[]>>;
                    evmContractConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").EvmContractCondition[]>>;
                    solRpcConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").SolRpcCondition[]>>;
                    unifiedAccessControlConditions: z.ZodOptional<z.ZodType<import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[], z.ZodTypeDef, import("dist/packages/access-control-conditions-schemas/src").UnifiedAccessControlCondition[]>>;
                } & {
                    ciphertext: z.ZodString;
                    dataToEncryptHash: z.ZodString;
                    authSig: z.ZodObject<{
                        sig: z.ZodString;
                        derivedVia: z.ZodString;
                        signedMessage: z.ZodString;
                        address: z.ZodString;
                        algo: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    chain: z.ZodString;
                    keySetId: z.ZodString;
                }, "strip", z.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: z.ZodObject<{
                    signatureShare: z.ZodObject<{
                        ProofOfPossession: z.ZodObject<{
                            identifier: z.ZodString;
                            value: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            value: string;
                            identifier: string;
                        }, {
                            value: string;
                            identifier: string;
                        }>;
                    }, "strip", z.ZodTypeAny, {
                        ProofOfPossession: {
                            value: string;
                            identifier: string;
                        };
                    }, {
                        ProofOfPossession: {
                            value: string;
                            identifier: string;
                        };
                    }>;
                    shareId: z.ZodString;
                    share_id: z.ZodOptional<z.ZodString>;
                    signature_share: z.ZodOptional<z.ZodString>;
                }, "strip", z.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: DecryptCreateRequestParams) => Promise<RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: z.infer<typeof GenericEncryptedPayloadSchema>, requestId: string, identityParam: string, ciphertext: string, subnetPubKey: string, jitContext: NagaJitContext) => Promise<{
                decryptedData: Uint8Array<ArrayBufferLike>;
            }>;
        };
        /**
         * Session Key Signing APIs - shared implementation
         */
        signSessionKey: {
            schemas: {};
            createRequest: (requestBody: z.infer<typeof JsonSignSessionKeyRequestForPkpReturnSchema>, httpProtocol: "http://" | "https://", version: string, jitContext: NagaJitContext) => Promise<RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: z.infer<typeof GenericEncryptedPayloadSchema>, pkpPublicKey: Hex | string, jitContext: NagaJitContext, requestId: string) => Promise<{
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>;
        };
        signCustomSessionKey: {
            schemas: {};
            createRequest: (requestBody: z.infer<typeof JsonSignCustomSessionKeyRequestForPkpReturnSchema>, httpProtocol: "http://" | "https://", version: string, jitContext: NagaJitContext) => Promise<RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: z.infer<typeof GenericEncryptedPayloadSchema>, pkpPublicKey: Hex | string, jitContext: NagaJitContext, requestId: string) => Promise<{
                sig: string;
                derivedVia: string;
                signedMessage: string;
                address: string;
                algo?: string | undefined;
            }>;
        };
        /**
         * Execute JS API - shared implementation
         */
        executeJs: {
            schemas: {
                Input: z.ZodEffects<z.ZodUnion<[z.ZodObject<{
                    code: z.ZodOptional<z.ZodString>;
                    ipfsId: z.ZodOptional<z.ZodString>;
                    jsParams: z.ZodOptional<z.ZodUnion<[z.ZodAny, z.ZodObject<{
                        publicKey: z.ZodOptional<z.ZodString>;
                        sigName: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodAny, z.objectOutputType<{
                        publicKey: z.ZodOptional<z.ZodString>;
                        sigName: z.ZodOptional<z.ZodString>;
                    }, z.ZodAny, "strip">, z.objectInputType<{
                        publicKey: z.ZodOptional<z.ZodString>;
                        sigName: z.ZodOptional<z.ZodString>;
                    }, z.ZodAny, "strip">>]>>;
                    keySetIdentifier: z.ZodOptional<z.ZodString>;
                    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
                    useSingleNode: z.ZodOptional<z.ZodBoolean>;
                    responseStrategy: z.ZodOptional<z.ZodType<{
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }, z.ZodTypeDef, {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }>>;
                } & {
                    authContext: z.ZodUnion<[z.ZodObject<{
                        pkpPublicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                        chain: z.ZodString;
                        sessionKeyPair: z.ZodObject<{
                            publicKey: z.ZodString;
                            secretKey: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                sig: z.ZodString;
                                derivedVia: z.ZodString;
                                signedMessage: z.ZodString;
                                address: z.ZodString;
                                algo: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }>, "many">>>;
                            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                resource: z.ZodObject<{
                                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>], z.ZodUnknown>, z.ZodBoolean>;
                                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: z.ZodReadonly<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }>;
                                ability: z.ZodNativeEnum<{
                                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                                    readonly PKPSigning: "pkp-signing";
                                    readonly PaymentDelegation: "lit-payment-delegation";
                                    readonly LitActionExecution: "lit-action-execution";
                                }>;
                                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                            }, "strip", z.ZodTypeAny, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: z.ZodOptional<z.ZodString>;
                        }, "strip", z.ZodTypeAny, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, {
                            keySetIdentifier?: string | undefined;
                            capabilityAuthSigs?: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[] | undefined;
                            expiration?: string | undefined;
                            statement?: string | undefined;
                            domain?: string | undefined;
                            resources?: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[] | undefined;
                        }>, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", z.ZodTypeAny, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    }, {
                        chain: string;
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        pkpPublicKey?: string | undefined;
                        authConfig?: unknown;
                    }>, z.ZodObject<{
                        account: z.ZodAny;
                        authenticator: z.ZodAny;
                        authData: z.ZodLazy<z.ZodObject<{
                            authMethodId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
                            authMethodType: z.ZodPipeline<z.ZodNumber, z.ZodNativeEnum<{
                                readonly EthWallet: 1;
                                readonly LitAction: 2;
                                readonly WebAuthn: 3;
                                readonly Discord: 4;
                                readonly Google: 5;
                                readonly GoogleJwt: 6;
                                readonly AppleJwt: 8;
                                readonly StytchOtp: 9;
                                readonly StytchEmailFactorOtp: 10;
                                readonly StytchSmsFactorOtp: 11;
                                readonly StytchWhatsAppFactorOtp: 12;
                                readonly StytchTotpFactorOtp: 13;
                            }>>;
                            accessToken: z.ZodString;
                            publicKey: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>>;
                            metadata: z.ZodOptional<z.ZodAny>;
                        }, "strip", z.ZodTypeAny, {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        }, {
                            authMethodType: number;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        }>>;
                        authNeededCallback: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
                        sessionKeyPair: z.ZodObject<{
                            publicKey: z.ZodString;
                            secretKey: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            publicKey: string;
                            secretKey: string;
                        }, {
                            publicKey: string;
                            secretKey: string;
                        }>;
                        authConfig: z.ZodLazy<z.ZodEffects<z.ZodObject<{
                            capabilityAuthSigs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                sig: z.ZodString;
                                derivedVia: z.ZodString;
                                signedMessage: z.ZodString;
                                address: z.ZodString;
                                algo: z.ZodOptional<z.ZodString>;
                            }, "strip", z.ZodTypeAny, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }, {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }>, "many">>>;
                            expiration: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            statement: z.ZodDefault<z.ZodOptional<z.ZodString>>;
                            domain: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodOptional<z.ZodString>>, string, string | undefined>>>;
                            resources: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
                                resource: z.ZodObject<{
                                    getResourceKey: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    isValidLitAbility: z.ZodFunction<z.ZodTuple<[z.ZodNativeEnum<{
                                        readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                        readonly AccessControlConditionSigning: "access-control-condition-signing";
                                        readonly PKPSigning: "pkp-signing";
                                        readonly PaymentDelegation: "lit-payment-delegation";
                                        readonly LitActionExecution: "lit-action-execution";
                                    }>], z.ZodUnknown>, z.ZodBoolean>;
                                    toString: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>;
                                    resourcePrefix: z.ZodReadonly<z.ZodNativeEnum<{
                                        readonly AccessControlCondition: "lit-accesscontrolcondition";
                                        readonly PKP: "lit-pkp";
                                        readonly RLI: "lit-ratelimitincrease";
                                        readonly PaymentDelegation: "lit-paymentdelegation";
                                        readonly LitAction: "lit-litaction";
                                    }>>;
                                    resource: z.ZodReadonly<z.ZodString>;
                                }, "strip", z.ZodTypeAny, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }, {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                }>;
                                ability: z.ZodNativeEnum<{
                                    readonly AccessControlConditionDecryption: "access-control-condition-decryption";
                                    readonly AccessControlConditionSigning: "access-control-condition-signing";
                                    readonly PKPSigning: "pkp-signing";
                                    readonly PaymentDelegation: "lit-payment-delegation";
                                    readonly LitActionExecution: "lit-action-execution";
                                }>;
                                data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("@lit-protocol/schemas").DefinedJson, z.ZodTypeDef, import("@lit-protocol/schemas").DefinedJson>>>;
                            }, "strip", z.ZodTypeAny, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }, {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }>, "many">>>;
                            keySetIdentifier: z.ZodOptional<z.ZodString>;
                        }, "strip", z.ZodTypeAny, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, {
                            keySetIdentifier?: string | undefined;
                            capabilityAuthSigs?: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[] | undefined;
                            expiration?: string | undefined;
                            statement?: string | undefined;
                            domain?: string | undefined;
                            resources?: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[] | undefined;
                        }>, {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        }, unknown>>;
                    }, "strip", z.ZodTypeAny, {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        authData: {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        account?: any;
                        authenticator?: any;
                    }, {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authData: {
                            authMethodType: number;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        authConfig?: unknown;
                        account?: any;
                        authenticator?: any;
                    }>]>;
                    sessionSigs: z.ZodOptional<z.ZodUndefined>;
                }, "strip", z.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("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    } | {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        authData: {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        account?: any;
                        authenticator?: any;
                    };
                    keySetIdentifier?: string | undefined;
                    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;
                }>, z.ZodObject<{
                    code: z.ZodOptional<z.ZodString>;
                    ipfsId: z.ZodOptional<z.ZodString>;
                    jsParams: z.ZodOptional<z.ZodUnion<[z.ZodAny, z.ZodObject<{
                        publicKey: z.ZodOptional<z.ZodString>;
                        sigName: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodAny, z.objectOutputType<{
                        publicKey: z.ZodOptional<z.ZodString>;
                        sigName: z.ZodOptional<z.ZodString>;
                    }, z.ZodAny, "strip">, z.objectInputType<{
                        publicKey: z.ZodOptional<z.ZodString>;
                        sigName: z.ZodOptional<z.ZodString>;
                    }, z.ZodAny, "strip">>]>>;
                    keySetIdentifier: z.ZodOptional<z.ZodString>;
                    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
                    useSingleNode: z.ZodOptional<z.ZodBoolean>;
                    responseStrategy: z.ZodOptional<z.ZodType<{
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }, z.ZodTypeDef, {
                        strategy: "custom" | "leastCommon" | "mostCommon";
                        customFilter?: ((args_0: Record<string, string>[], ...args: unknown[]) => Record<string, string>) | undefined;
                    }>>;
                } & {
                    sessionSigs: z.ZodRecord<z.ZodString, z.ZodObject<{
                        sig: z.ZodString;
                        derivedVia: z.ZodString;
                        signedMessage: z.ZodString;
                        address: z.ZodString;
                        algo: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>>;
                    authContext: z.ZodOptional<z.ZodUndefined>;
                }, "strip", z.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("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        pkpPublicKey?: string | undefined;
                    } | {
                        sessionKeyPair: {
                            publicKey: string;
                            secretKey: string;
                        };
                        authNeededCallback: (...args: unknown[]) => unknown;
                        authConfig: {
                            capabilityAuthSigs: {
                                sig: string;
                                derivedVia: string;
                                signedMessage: string;
                                address: string;
                                algo?: string | undefined;
                            }[];
                            expiration: string;
                            statement: string;
                            domain: string;
                            resources: {
                                resource: {
                                    toString: (...args: unknown[]) => string;
                                    getResourceKey: (...args: unknown[]) => string;
                                    isValidLitAbility: (args_0: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution", ...args: unknown[]) => boolean;
                                    resourcePrefix: "lit-accesscontrolcondition" | "lit-pkp" | "lit-ratelimitincrease" | "lit-paymentdelegation" | "lit-litaction";
                                    resource: string;
                                };
                                ability: "access-control-condition-decryption" | "access-control-condition-signing" | "pkp-signing" | "lit-payment-delegation" | "lit-action-execution";
                                data?: Record<string, import("@lit-protocol/schemas").DefinedJson> | undefined;
                            }[];
                            keySetIdentifier?: string | undefined;
                        };
                        authData: {
                            authMethodType: 1 | 2 | 4 | 3 | 5 | 6 | 8 | 9 | 10 | 11 | 12 | 13;
                            accessToken: string;
                            authMethodId: string;
                            publicKey?: string | undefined;
                            metadata?: any;
                        };
                        account?: any;
                        authenticator?: any;
                    };
                    keySetIdentifier?: string | undefined;
                    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: z.ZodObject<{
                    code: z.ZodOptional<z.ZodString>;
                    ipfsId: z.ZodOptional<z.ZodString>;
                    jsParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
                    authSig: z.ZodObject<{
                        sig: z.ZodString;
                        derivedVia: z.ZodString;
                        signedMessage: z.ZodString;
                        address: z.ZodString;
                        algo: z.ZodOptional<z.ZodString>;
                    }, "strip", z.ZodTypeAny, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }, {
                        sig: string;
                        derivedVia: string;
                        signedMessage: string;
                        address: string;
                        algo?: string | undefined;
                    }>;
                    nodeSet: z.ZodEffects<z.ZodArray<z.ZodString, "many">, {
                        value: number;
                        socketAddress: string;
                    }[], string[]>;
                    keySetId: z.ZodString;
                }, "strip", z.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: z.ZodObject<{
                    success: z.ZodBoolean;
                    values: z.ZodArray<z.ZodObject<{
                        nodeUrl: z.ZodOptional<z.ZodString>;
                        success: z.ZodBoolean;
                        claimData: z.ZodRecord<z.ZodString, z.ZodObject<{
                            signatures: z.ZodArray<z.ZodAny, "many">;
                            derivedKeyId: z.ZodString;
                        }, "strip", z.ZodTypeAny, {
                            derivedKeyId: string;
                            signatures: any[];
                        }, {
                            derivedKeyId: string;
                            signatures: any[];
                        }>>;
                        decryptedData: z.ZodAny;
                        logs: z.ZodString;
                        response: z.ZodString;
                        signedData: z.ZodRecord<z.ZodString, z.ZodAny>;
                        paymentDetail: z.ZodOptional<z.ZodArray<z.ZodObject<{
                            component: z.ZodString;
                            quantity: z.ZodNumber;
                            price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, bigint, string | number>;
                        }, "strip", z.ZodTypeAny, {
                            price: bigint;
                            component: string;
                            quantity: number;
                        }, {
                            price: string | number;
                            component: string;
                            quantity: number;
                        }>, "many">>;
                    }, "strip", z.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", z.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: ExecuteJsCreateRequestParams) => Promise<RequestItem<{
                version: string;
                payload: {
                    verification_key: string;
                    random: string;
                    created_at: string;
                    ciphertext_and_tag: string;
                };
            }>[]>;
            handleResponse: (result: z.infer<typeof GenericEncryptedPayloadSchema>, requestId: string, jitContext: NagaJitContext) => Promise<import("@lit-protocol/types").ExecuteJsResponse>;
        };
    };
    /**
     * Returns a wrapped module instance with runtime overrides while keeping the base immutable.
     * Currently supports overriding the RPC URL used by consumers of this module.
     *
     * @param overrides - The overrides to apply to the module.
     * @returns A wrapped module instance with the overrides applied.
     * @example
     *
     * import { nagaDev } from '@lit-protocol/networks';
     * const nagaDevWithOverride = nagaDev.withOverrides({ rpcUrl: 'https://custom-rpc-url.com' });
     * const litClient = await createLitClient({ network: nagaDevWithOverride });
     */
    withOverrides: (overrides: {
        rpcUrl?: string;
    }) => /*elided*/ any;
};