import { z } from 'zod';
declare const ExecuteJsInputWithAuthContextSchema: z.ZodObject<{
    /**
     * JS code to run on the nodes
     */
    code: z.ZodOptional<z.ZodString>;
    /**
     * The IPFS ID of some JS code to run on the nodes
     */
    ipfsId: z.ZodOptional<z.ZodString>;
    /**
     * An object that contains params to expose to the Lit Action.
     * These will be injected to the JS runtime before your code runs.
     */
    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">>]>>;
    /**
     * Key set identifier used to select the signing key set
     */
    keySetIdentifier: z.ZodOptional<z.ZodString>;
    /**
     * User's maximum price they're willing to pay for the request
     */
    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
    /**
     * Only run the action on a single node; this will only work if all code in your action is non-interactive
     */
    useSingleNode: z.ZodOptional<z.ZodBoolean>;
    /**
     * Response strategy for processing Lit Action responses
     */
    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;
    }>>;
} & {
    /**
     * Authentication context - either PKP or EOA based
     */
    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;
    }>]>;
    /**
     * Session signatures must not be supplied when an auth context is provided.
     */
    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;
}>;
declare const ExecuteJsInputWithSessionSigsSchema: z.ZodObject<{
    /**
     * JS code to run on the nodes
     */
    code: z.ZodOptional<z.ZodString>;
    /**
     * The IPFS ID of some JS code to run on the nodes
     */
    ipfsId: z.ZodOptional<z.ZodString>;
    /**
     * An object that contains params to expose to the Lit Action.
     * These will be injected to the JS runtime before your code runs.
     */
    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">>]>>;
    /**
     * Key set identifier used to select the signing key set
     */
    keySetIdentifier: z.ZodOptional<z.ZodString>;
    /**
     * User's maximum price they're willing to pay for the request
     */
    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
    /**
     * Only run the action on a single node; this will only work if all code in your action is non-interactive
     */
    useSingleNode: z.ZodOptional<z.ZodBoolean>;
    /**
     * Response strategy for processing Lit Action responses
     */
    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;
    }>>;
} & {
    /**
     * Pre-generated session signatures; when provided, authContext must be omitted.
     */
    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 is intentionally unsupported in this branch.
     */
    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;
}>;
export declare const ExecuteJsInputSchema: z.ZodEffects<z.ZodUnion<[z.ZodObject<{
    /**
     * JS code to run on the nodes
     */
    code: z.ZodOptional<z.ZodString>;
    /**
     * The IPFS ID of some JS code to run on the nodes
     */
    ipfsId: z.ZodOptional<z.ZodString>;
    /**
     * An object that contains params to expose to the Lit Action.
     * These will be injected to the JS runtime before your code runs.
     */
    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">>]>>;
    /**
     * Key set identifier used to select the signing key set
     */
    keySetIdentifier: z.ZodOptional<z.ZodString>;
    /**
     * User's maximum price they're willing to pay for the request
     */
    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
    /**
     * Only run the action on a single node; this will only work if all code in your action is non-interactive
     */
    useSingleNode: z.ZodOptional<z.ZodBoolean>;
    /**
     * Response strategy for processing Lit Action responses
     */
    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;
    }>>;
} & {
    /**
     * Authentication context - either PKP or EOA based
     */
    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;
    }>]>;
    /**
     * Session signatures must not be supplied when an auth context is provided.
     */
    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<{
    /**
     * JS code to run on the nodes
     */
    code: z.ZodOptional<z.ZodString>;
    /**
     * The IPFS ID of some JS code to run on the nodes
     */
    ipfsId: z.ZodOptional<z.ZodString>;
    /**
     * An object that contains params to expose to the Lit Action.
     * These will be injected to the JS runtime before your code runs.
     */
    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">>]>>;
    /**
     * Key set identifier used to select the signing key set
     */
    keySetIdentifier: z.ZodOptional<z.ZodString>;
    /**
     * User's maximum price they're willing to pay for the request
     */
    userMaxPrice: z.ZodOptional<z.ZodBigInt>;
    /**
     * Only run the action on a single node; this will only work if all code in your action is non-interactive
     */
    useSingleNode: z.ZodOptional<z.ZodBoolean>;
    /**
     * Response strategy for processing Lit Action responses
     */
    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;
    }>>;
} & {
    /**
     * Pre-generated session signatures; when provided, authContext must be omitted.
     */
    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 is intentionally unsupported in this branch.
     */
    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;
}>;
export type ExecuteJsInput = z.infer<typeof ExecuteJsInputWithAuthContextSchema> | z.infer<typeof ExecuteJsInputWithSessionSigsSchema>;
export {};