import type { ActionType } from 'hardhat/config';
export interface Task {
    run: ActionType<{
        run: ActionType<{}, any>;
    }, any>;
}
export declare const TASKS: {
    readonly "verify:verify": {
        run: ActionType<{
            address: string;
            constructorArgsParams: string[];
            constructorArgs?: string;
            contract?: string;
            libraries?: string;
        }, any>;
    };
    readonly verify: Task;
    readonly "verify:get-minimum-build": Task;
    readonly "verify:get-constructor-arguments": Task;
    readonly "verify:get-compiler-versions": Task;
    readonly "verify:get-etherscan-endpoint": Task;
    readonly "verify:get-contract-information": Task;
    readonly "verify:verify-minimum-build": Task;
    readonly "verify:get-libraries": Task;
    readonly "deploy:erc1820": {
        readonly name: "deploy:erc1820";
        readonly description: "deploy erc 1820";
        readonly run: (taskArguments: void, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly accounts: {
        readonly name: "accounts";
        readonly description: "Prints the list of accounts";
        readonly run: (_taskArguments: void, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly NCCR_V0: {
        readonly name: "NCCR_V0";
        readonly description: "Interact with the NCCR_V0 contract";
        readonly run: ({ func, args, from, }: {
            func: string;
            from?: number | undefined;
            args?: unknown[] | undefined;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
        readonly CONTRACT_FUNCTION_TASK_PARAMETERS: {
            readonly func: {
                readonly name: "func";
                readonly description: "the function to call";
                readonly defaultValue: undefined;
                readonly type: import("hardhat/types").CLIArgumentType<string>;
            };
            readonly from: {
                readonly name: "from";
                readonly description: "the index of the signer account to use";
                readonly defaultValue: 0;
                readonly type: import("hardhat/types").CLIArgumentType<number>;
            };
            readonly args: {
                readonly name: "args";
                readonly description: "the args to pass the function";
                readonly defaultValue: undefined;
                readonly type: undefined;
            };
        };
    };
    readonly Certificate: {
        readonly name: "Certificate";
        readonly description: "Interact with the Certificate contract";
        readonly run: ({ func, args, from, }: {
            func: string;
            from?: number | undefined;
            args?: unknown[] | undefined;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
        readonly CONTRACT_FUNCTION_TASK_PARAMETERS: {
            readonly func: {
                readonly name: "func";
                readonly description: "the function to call";
                readonly defaultValue: undefined;
                readonly type: import("hardhat/types").CLIArgumentType<string>;
            };
            readonly from: {
                readonly name: "from";
                readonly description: "the index of the signer account to use";
                readonly defaultValue: 0;
                readonly type: import("hardhat/types").CLIArgumentType<number>;
            };
            readonly args: {
                readonly name: "args";
                readonly description: "the args to pass the function";
                readonly defaultValue: undefined;
                readonly type: undefined;
            };
        };
    };
    readonly Market: {
        readonly name: "Market";
        readonly description: "Interact with the Market contract";
        readonly run: ({ func, args, from, }: {
            func: string;
            from?: number | undefined;
            args?: unknown[] | undefined;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
        readonly CONTRACT_FUNCTION_TASK_PARAMETERS: {
            readonly func: {
                readonly name: "func";
                readonly description: "the function to call";
                readonly defaultValue: undefined;
                readonly type: import("hardhat/types").CLIArgumentType<string>;
            };
            readonly from: {
                readonly name: "from";
                readonly description: "the index of the signer account to use";
                readonly defaultValue: 0;
                readonly type: import("hardhat/types").CLIArgumentType<number>;
            };
            readonly args: {
                readonly name: "args";
                readonly description: "the args to pass the function";
                readonly defaultValue: undefined;
                readonly type: undefined;
            };
        };
    };
    readonly Removal: {
        readonly name: "Removal";
        readonly description: "Interact with the Removal contract";
        readonly run: ({ func, args, from, }: {
            func: string;
            from?: number | undefined;
            args?: unknown[] | undefined;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
        readonly CONTRACT_FUNCTION_TASK_PARAMETERS: {
            readonly func: {
                readonly name: "func";
                readonly description: "the function to call";
                readonly defaultValue: undefined;
                readonly type: import("hardhat/types").CLIArgumentType<string>;
            };
            readonly from: {
                readonly name: "from";
                readonly description: "the index of the signer account to use";
                readonly defaultValue: 0;
                readonly type: import("hardhat/types").CLIArgumentType<number>;
            };
            readonly args: {
                readonly name: "args";
                readonly description: "the args to pass the function";
                readonly defaultValue: undefined;
                readonly type: undefined;
            };
        };
    };
    readonly NORI: {
        readonly name: "NORI";
        readonly description: "Interact with the NORI contract";
        readonly run: ({ func, args, from, }: {
            func: string;
            from?: number | undefined;
            args?: unknown[] | undefined;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
        readonly CONTRACT_FUNCTION_TASK_PARAMETERS: {
            readonly func: {
                readonly name: "func";
                readonly description: "the function to call";
                readonly defaultValue: undefined;
                readonly type: import("hardhat/types").CLIArgumentType<string>;
            };
            readonly from: {
                readonly name: "from";
                readonly description: "the index of the signer account to use";
                readonly defaultValue: 0;
                readonly type: import("hardhat/types").CLIArgumentType<number>;
            };
            readonly args: {
                readonly name: "args";
                readonly description: "the args to pass the function";
                readonly defaultValue: undefined;
                readonly type: undefined;
            };
        };
    };
    readonly LockedNORI: {
        readonly name: "LockedNORI";
        readonly description: "Interact with the LockedNORI contract";
        readonly run: ({ func, args, from, }: {
            func: string;
            from?: number | undefined;
            args?: unknown[] | undefined;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
        readonly CONTRACT_FUNCTION_TASK_PARAMETERS: {
            readonly func: {
                readonly name: "func";
                readonly description: "the function to call";
                readonly defaultValue: undefined;
                readonly type: import("hardhat/types").CLIArgumentType<string>;
            };
            readonly from: {
                readonly name: "from";
                readonly description: "the index of the signer account to use";
                readonly defaultValue: 0;
                readonly type: import("hardhat/types").CLIArgumentType<number>;
            };
            readonly args: {
                readonly name: "args";
                readonly description: "the args to pass the function";
                readonly defaultValue: undefined;
                readonly type: undefined;
            };
        };
    };
    readonly BridgedPolygonNORI: {
        readonly name: "BridgedPolygonNORI";
        readonly description: "Interact with the BridgedPolygonNORI contract";
        readonly run: ({ func, args, from, }: {
            func: string;
            from?: number | undefined;
            args?: unknown[] | undefined;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
        readonly CONTRACT_FUNCTION_TASK_PARAMETERS: {
            readonly func: {
                readonly name: "func";
                readonly description: "the function to call";
                readonly defaultValue: undefined;
                readonly type: import("hardhat/types").CLIArgumentType<string>;
            };
            readonly from: {
                readonly name: "from";
                readonly description: "the index of the signer account to use";
                readonly defaultValue: 0;
                readonly type: import("hardhat/types").CLIArgumentType<number>;
            };
            readonly args: {
                readonly name: "args";
                readonly description: "the args to pass the function";
                readonly defaultValue: undefined;
                readonly type: undefined;
            };
        };
    };
    readonly "defender:add": {
        readonly name: "defender:add";
        readonly description: "Adds contracts to defender";
        readonly run: ({ contractNames, }: {
            contractNames: (keyof Contracts)[];
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly upgrade: {
        readonly name: "upgrade";
        readonly description: "Interact with upgradeable contracts";
        readonly run: ({ contractNames, validate, }: {
            contractNames: (keyof Contracts)[];
            validate: boolean;
        }, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly vesting: {
        readonly name: "vesting";
        readonly description: "Utilities for handling vesting";
        readonly run: (options: import("./vesting").VestingTaskOptions, _: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly "migrate-removals": {
        readonly name: "migrate-removals";
        readonly description: "Utility to mint legacy removals";
        readonly run: (options: import("./migrate-removals").MigrateRemovalsTaskOptions, _: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly "migrate-certificates": {
        readonly name: "migrate-certificates";
        readonly description: "Utility to migrate legacy certificates";
        readonly run: (options: import("./migrate-certificates").MigrateCertificatesTaskOptions, _: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly "list-remaining-migrated-removals": {
        readonly name: "list-remaining-migrated-removals";
        readonly description: "Utility to list migrated removals for sale that were not included in migrated certificates";
        readonly run: (options: import("./list-remaining-migrated-removals").ListMigratedRemovalsTaskOptions, _: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly "force-upgrade": {
        readonly name: "force-upgrade";
        readonly description: "Force upgrades a contract when network file is lost";
        readonly run: (taskArguments: import("./force-ugrade").ForceUpgradeTaskParameters, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly "sign-message": {
        readonly name: "sign-message";
        readonly description: "Sign an arbitrary message";
        readonly run: (taskArguments: import("./sign-message").SignMessageTaskParameters, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
    readonly "test-sign-typed": {
        readonly name: "test-sign-typed";
        readonly description: "Test signing typed data";
        readonly run: (taskArguments: import("./test-sign-typed").TestSignTypesTaskParameters, hre: CustomHardHatRuntimeEnvironment) => Promise<void>;
    };
};