import { TypedData } from 'abitype';
import { z } from 'zod';

type Contract = {
    authors: Array<string> | string;
    name: string;
    filename: string;
    license: string;
    solidity: string;
};
type Dangerous = {
    excludeCoreTypes: boolean;
    useOverloads: boolean;
    useDocs: boolean;
    packetHashName: (typeName: string) => string;
};
type Config = {
    contract: Contract;
    types: TypedData;
    out: string;
    outDocs: string;
    dangerous: Dangerous;
};
declare function config({ contract, types, out, outDocs, dangerous }?: Partial<{
    contract: Partial<Contract>;
    types: TypedData;
    out: string;
    outDocs: string;
    dangerous: Partial<Dangerous>;
}>): Config;

declare const BASE_AUTH = "0x0000000000000000000000000000000000000000000000000000000000000000";
declare const EIP712_TYPES: {
    readonly EIP712Domain: readonly [{
        readonly name: "name";
        readonly type: "string";
    }, {
        readonly name: "version";
        readonly type: "string";
    }, {
        readonly name: "chainId";
        readonly type: "uint256";
    }, {
        readonly name: "verifyingContract";
        readonly type: "address";
    }];
};
declare const PLUGS_TYPES: {
    readonly Plug: readonly [{
        readonly name: "target";
        readonly type: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly name: "data";
        readonly type: "bytes";
    }];
    readonly Plugs: readonly [{
        readonly name: "socket";
        readonly type: "address";
    }, {
        readonly name: "plugs";
        readonly type: "Plug[]";
    }, {
        readonly name: "solver";
        readonly type: "bytes";
    }, {
        readonly name: "salt";
        readonly type: "bytes32";
    }];
};
declare const LIVE_PLUGS_TYPES: {
    readonly LivePlugs: readonly [{
        readonly name: "plugs";
        readonly type: "Plugs";
    }, {
        readonly name: "signature";
        readonly type: "bytes";
    }];
    readonly Plug: readonly [{
        readonly name: "target";
        readonly type: "address";
    }, {
        readonly name: "value";
        readonly type: "uint256";
    }, {
        readonly name: "data";
        readonly type: "bytes";
    }];
    readonly Plugs: readonly [{
        readonly name: "socket";
        readonly type: "address";
    }, {
        readonly name: "plugs";
        readonly type: "Plug[]";
    }, {
        readonly name: "solver";
        readonly type: "bytes";
    }, {
        readonly name: "salt";
        readonly type: "bytes32";
    }];
};
declare const constants: {
    readonly config: Config;
    readonly types: {
        readonly LivePlugs: readonly [{
            readonly name: "plugs";
            readonly type: "Plugs";
        }, {
            readonly name: "signature";
            readonly type: "bytes";
        }];
        readonly Plug: readonly [{
            readonly name: "target";
            readonly type: "address";
        }, {
            readonly name: "value";
            readonly type: "uint256";
        }, {
            readonly name: "data";
            readonly type: "bytes";
        }];
        readonly Plugs: readonly [{
            readonly name: "socket";
            readonly type: "address";
        }, {
            readonly name: "plugs";
            readonly type: "Plug[]";
        }, {
            readonly name: "solver";
            readonly type: "bytes";
        }, {
            readonly name: "salt";
            readonly type: "bytes32";
        }];
    };
};

declare const PlugSchema: z.ZodObject<{
    target: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    value: z.ZodBigInt;
    data: z.ZodEffects<z.ZodString, `0x${string}`, string>;
}, "strip", z.ZodTypeAny, {
    target: `0x${string}`;
    value: bigint;
    data: `0x${string}`;
}, {
    target: string;
    value: bigint;
    data: string;
}>;
type Plug = z.infer<typeof PlugSchema>;
declare const PlugsSchema: z.ZodObject<{
    socket: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    plugs: z.ZodArray<z.ZodObject<{
        target: z.ZodEffects<z.ZodString, `0x${string}`, string>;
        value: z.ZodBigInt;
        data: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    }, "strip", z.ZodTypeAny, {
        target: `0x${string}`;
        value: bigint;
        data: `0x${string}`;
    }, {
        target: string;
        value: bigint;
        data: string;
    }>, "many">;
    solver: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    salt: z.ZodEffects<z.ZodString, `0x${string}`, string>;
}, "strip", z.ZodTypeAny, {
    socket: `0x${string}`;
    plugs: {
        target: `0x${string}`;
        value: bigint;
        data: `0x${string}`;
    }[];
    solver: `0x${string}`;
    salt: `0x${string}`;
}, {
    socket: string;
    plugs: {
        target: string;
        value: bigint;
        data: string;
    }[];
    solver: string;
    salt: string;
}>;
type Plugs = z.infer<typeof PlugsSchema>;
declare const LivePlugsSchema: z.ZodObject<{
    plugs: z.ZodObject<{
        socket: z.ZodEffects<z.ZodString, `0x${string}`, string>;
        plugs: z.ZodArray<z.ZodObject<{
            target: z.ZodEffects<z.ZodString, `0x${string}`, string>;
            value: z.ZodBigInt;
            data: z.ZodEffects<z.ZodString, `0x${string}`, string>;
        }, "strip", z.ZodTypeAny, {
            target: `0x${string}`;
            value: bigint;
            data: `0x${string}`;
        }, {
            target: string;
            value: bigint;
            data: string;
        }>, "many">;
        solver: z.ZodEffects<z.ZodString, `0x${string}`, string>;
        salt: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    }, "strip", z.ZodTypeAny, {
        socket: `0x${string}`;
        plugs: {
            target: `0x${string}`;
            value: bigint;
            data: `0x${string}`;
        }[];
        solver: `0x${string}`;
        salt: `0x${string}`;
    }, {
        socket: string;
        plugs: {
            target: string;
            value: bigint;
            data: string;
        }[];
        solver: string;
        salt: string;
    }>;
    signature: z.ZodEffects<z.ZodString, `0x${string}`, string>;
}, "strip", z.ZodTypeAny, {
    plugs: {
        socket: `0x${string}`;
        plugs: {
            target: `0x${string}`;
            value: bigint;
            data: `0x${string}`;
        }[];
        solver: `0x${string}`;
        salt: `0x${string}`;
    };
    signature: `0x${string}`;
}, {
    plugs: {
        socket: string;
        plugs: {
            target: string;
            value: bigint;
            data: string;
        }[];
        solver: string;
        salt: string;
    };
    signature: string;
}>;
type LivePlugs = z.infer<typeof LivePlugsSchema>;
declare const EIP712DomainSchema: z.ZodObject<{
    name: z.ZodString;
    version: z.ZodString;
    chainId: z.ZodNumber;
    verifyingContract: z.ZodEffects<z.ZodString, `0x${string}`, string>;
}, "strip", z.ZodTypeAny, {
    name: string;
    version: string;
    chainId: number;
    verifyingContract: `0x${string}`;
}, {
    name: string;
    version: string;
    chainId: number;
    verifyingContract: string;
}>;
type EIP712Domain = z.infer<typeof EIP712DomainSchema>;

declare const ADDRESS_REGEX: RegExp;
declare const Address: z.ZodEffects<z.ZodString, `0x${string}`, string>;
type AddressType = z.infer<typeof Address>;
declare const BYTES32_REGEX: RegExp;
declare const Bytes32: z.ZodEffects<z.ZodString, `0x${string}`, string>;
type Bytes32Type = z.infer<typeof Bytes32>;
declare const BYTES_REGEX: RegExp;
declare const Bytes: z.ZodEffects<z.ZodString, `0x${string}`, string>;
type BytesType = z.infer<typeof Bytes>;
declare const getTypeSchema: (type: string) => string;

export { ADDRESS_REGEX as A, BASE_AUTH as B, type Config as C, EIP712_TYPES as E, LIVE_PLUGS_TYPES as L, PLUGS_TYPES as P, constants as a, PlugSchema as b, config as c, type Plug as d, PlugsSchema as e, type Plugs as f, LivePlugsSchema as g, type LivePlugs as h, EIP712DomainSchema as i, type EIP712Domain as j, Address as k, type AddressType as l, BYTES32_REGEX as m, Bytes32 as n, type Bytes32Type as o, BYTES_REGEX as p, Bytes as q, type BytesType as r, getTypeSchema as s };