@reclaimprotocol/attestor-core/lib/avs/contracts/ReclaimServiceManager.d.ts

<div> <div> <img src="https://raw.githubusercontent.com/reclaimprotocol/.github/main/assets/banners/Attestor-Core.png" /> </div> </div>

import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
export declare namespace IReclaimServiceManager {
    type ClaimRequestStruct = {
        provider: string;
        claimUserId: BytesLike;
        claimHash: BytesLike;
        requestedAt: BigNumberish;
        owner: string;
    };
    type ClaimRequestStructOutput = [
        string,
        string,
        string,
        number,
        string
    ] & {
        provider: string;
        claimUserId: string;
        claimHash: string;
        requestedAt: number;
        owner: string;
    };
    type OperatorMetadataStruct = {
        addr: string;
        url: string;
    };
    type OperatorMetadataStructOutput = [string, string] & {
        addr: string;
        url: string;
    };
    type OperatorStruct = {
        addr: string;
        url: string;
    };
    type OperatorStructOutput = [string, string] & {
        addr: string;
        url: string;
    };
    type TaskStruct = {
        request: IReclaimServiceManager.ClaimRequestStruct;
        createdAt: BigNumberish;
        expiresAt: BigNumberish;
        minimumSignatures: BigNumberish;
        operators: IReclaimServiceManager.OperatorStruct[];
        feePaid: BigNumberish;
    };
    type TaskStructOutput = [
        IReclaimServiceManager.ClaimRequestStructOutput,
        number,
        number,
        number,
        IReclaimServiceManager.OperatorStructOutput[],
        BigNumber
    ] & {
        request: IReclaimServiceManager.ClaimRequestStructOutput;
        createdAt: number;
        expiresAt: number;
        minimumSignatures: number;
        operators: IReclaimServiceManager.OperatorStructOutput[];
        feePaid: BigNumber;
    };
    type CompletedTaskStruct = {
        task: IReclaimServiceManager.TaskStruct;
        signatures: BytesLike[];
    };
    type CompletedTaskStructOutput = [
        IReclaimServiceManager.TaskStructOutput,
        string[]
    ] & {
        task: IReclaimServiceManager.TaskStructOutput;
        signatures: string[];
    };
    type TaskCreationMetadataStruct = {
        maxTaskLifetimeS: BigNumberish;
        minSignaturesPerTask: BigNumberish;
        maxTaskCreationDelayS: BigNumberish;
    };
    type TaskCreationMetadataStructOutput = [number, number, number] & {
        maxTaskLifetimeS: number;
        minSignaturesPerTask: number;
        maxTaskCreationDelayS: number;
    };
}
export declare namespace IPaymentCoordinator {
    type StrategyAndMultiplierStruct = {
        strategy: string;
        multiplier: BigNumberish;
    };
    type StrategyAndMultiplierStructOutput = [string, BigNumber] & {
        strategy: string;
        multiplier: BigNumber;
    };
    type RangePaymentStruct = {
        strategiesAndMultipliers: IPaymentCoordinator.StrategyAndMultiplierStruct[];
        token: string;
        amount: BigNumberish;
        startTimestamp: BigNumberish;
        duration: BigNumberish;
    };
    type RangePaymentStructOutput = [
        IPaymentCoordinator.StrategyAndMultiplierStructOutput[],
        string,
        BigNumber,
        number,
        number
    ] & {
        strategiesAndMultipliers: IPaymentCoordinator.StrategyAndMultiplierStructOutput[];
        token: string;
        amount: BigNumber;
        startTimestamp: number;
        duration: number;
    };
}
export declare namespace ISignatureUtils {
    type SignatureWithSaltAndExpiryStruct = {
        signature: BytesLike;
        salt: BytesLike;
        expiry: BigNumberish;
    };
    type SignatureWithSaltAndExpiryStructOutput = [
        string,
        string,
        BigNumber
    ] & {
        signature: string;
        salt: string;
        expiry: BigNumber;
    };
}
export interface ReclaimServiceManagerInterface extends utils.Interface {
    functions: {
        "admins(uint256)": FunctionFragment;
        "allTaskHashes(uint32)": FunctionFragment;
        "avsDirectory()": FunctionFragment;
        "checkSignerAddress((string,bytes32,bytes32,uint32,address),bytes)": FunctionFragment;
        "createNewTask((string,bytes32,bytes32,uint32,address),bytes)": FunctionFragment;
        "deregisterOperatorFromAVS(address)": FunctionFragment;
        "encodeClaimRequest((string,bytes32,bytes32,uint32,address))": FunctionFragment;
        "getMetadataForOperator(address)": FunctionFragment;
        "getOperatorRestakedStrategies(address)": FunctionFragment;
        "getRestakeableStrategies()": FunctionFragment;
        "isAdmin(address)": FunctionFragment;
        "isOperatorWhitelisted(address)": FunctionFragment;
        "latestTaskNum()": FunctionFragment;
        "operatorHasMinimumWeight(address)": FunctionFragment;
        "owner()": FunctionFragment;
        "pause(uint256)": FunctionFragment;
        "pauseAll()": FunctionFragment;
        "paused(uint8)": FunctionFragment;
        "paused()": FunctionFragment;
        "pauserRegistry()": FunctionFragment;
        "payForRange(((address,uint96)[],address,uint256,uint32,uint32)[])": FunctionFragment;
        "registerOperatorToAVS(address,(bytes,bytes32,uint256))": FunctionFragment;
        "registeredOperators(uint256)": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "setPauserRegistry(address)": FunctionFragment;
        "setup(address)": FunctionFragment;
        "stakeRegistry()": FunctionFragment;
        "taskCompleted((((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256),bytes[]),uint32)": FunctionFragment;
        "taskCreationMetadata()": FunctionFragment;
        "transferOwnership(address)": FunctionFragment;
        "unpause(uint256)": FunctionFragment;
        "updateAVSMetadataURI(string)": FunctionFragment;
        "updateOperatorMetadata((address,string))": FunctionFragment;
        "updateTaskCreationMetadata((uint32,uint8,uint32))": FunctionFragment;
        "whitelistAddressAsOperator(address,bool)": FunctionFragment;
        "whitelistedOperators(uint256)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "admins" | "allTaskHashes" | "avsDirectory" | "checkSignerAddress" | "createNewTask" | "deregisterOperatorFromAVS" | "encodeClaimRequest" | "getMetadataForOperator" | "getOperatorRestakedStrategies" | "getRestakeableStrategies" | "isAdmin" | "isOperatorWhitelisted" | "latestTaskNum" | "operatorHasMinimumWeight" | "owner" | "pause" | "pauseAll" | "paused(uint8)" | "paused()" | "pauserRegistry" | "payForRange" | "registerOperatorToAVS" | "registeredOperators" | "renounceOwnership" | "setPauserRegistry" | "setup" | "stakeRegistry" | "taskCompleted" | "taskCreationMetadata" | "transferOwnership" | "unpause" | "updateAVSMetadataURI" | "updateOperatorMetadata" | "updateTaskCreationMetadata" | "whitelistAddressAsOperator" | "whitelistedOperators"): FunctionFragment;
    encodeFunctionData(functionFragment: "admins", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "allTaskHashes", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "avsDirectory", values?: undefined): string;
    encodeFunctionData(functionFragment: "checkSignerAddress", values: [IReclaimServiceManager.ClaimRequestStruct, BytesLike]): string;
    encodeFunctionData(functionFragment: "createNewTask", values: [IReclaimServiceManager.ClaimRequestStruct, BytesLike]): string;
    encodeFunctionData(functionFragment: "deregisterOperatorFromAVS", values: [string]): string;
    encodeFunctionData(functionFragment: "encodeClaimRequest", values: [IReclaimServiceManager.ClaimRequestStruct]): string;
    encodeFunctionData(functionFragment: "getMetadataForOperator", values: [string]): string;
    encodeFunctionData(functionFragment: "getOperatorRestakedStrategies", values: [string]): string;
    encodeFunctionData(functionFragment: "getRestakeableStrategies", values?: undefined): string;
    encodeFunctionData(functionFragment: "isAdmin", values: [string]): string;
    encodeFunctionData(functionFragment: "isOperatorWhitelisted", values: [string]): string;
    encodeFunctionData(functionFragment: "latestTaskNum", values?: undefined): string;
    encodeFunctionData(functionFragment: "operatorHasMinimumWeight", values: [string]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "pause", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "pauseAll", values?: undefined): string;
    encodeFunctionData(functionFragment: "paused(uint8)", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "paused()", values?: undefined): string;
    encodeFunctionData(functionFragment: "pauserRegistry", values?: undefined): string;
    encodeFunctionData(functionFragment: "payForRange", values: [IPaymentCoordinator.RangePaymentStruct[]]): string;
    encodeFunctionData(functionFragment: "registerOperatorToAVS", values: [string, ISignatureUtils.SignatureWithSaltAndExpiryStruct]): string;
    encodeFunctionData(functionFragment: "registeredOperators", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "setPauserRegistry", values: [string]): string;
    encodeFunctionData(functionFragment: "setup", values: [string]): string;
    encodeFunctionData(functionFragment: "stakeRegistry", values?: undefined): string;
    encodeFunctionData(functionFragment: "taskCompleted", values: [IReclaimServiceManager.CompletedTaskStruct, BigNumberish]): string;
    encodeFunctionData(functionFragment: "taskCreationMetadata", values?: undefined): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    encodeFunctionData(functionFragment: "unpause", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "updateAVSMetadataURI", values: [string]): string;
    encodeFunctionData(functionFragment: "updateOperatorMetadata", values: [IReclaimServiceManager.OperatorMetadataStruct]): string;
    encodeFunctionData(functionFragment: "updateTaskCreationMetadata", values: [IReclaimServiceManager.TaskCreationMetadataStruct]): string;
    encodeFunctionData(functionFragment: "whitelistAddressAsOperator", values: [string, boolean]): string;
    encodeFunctionData(functionFragment: "whitelistedOperators", values: [BigNumberish]): string;
    decodeFunctionResult(functionFragment: "admins", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "allTaskHashes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "avsDirectory", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "checkSignerAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "createNewTask", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deregisterOperatorFromAVS", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "encodeClaimRequest", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getMetadataForOperator", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getOperatorRestakedStrategies", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRestakeableStrategies", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isAdmin", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isOperatorWhitelisted", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "latestTaskNum", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "operatorHasMinimumWeight", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pauseAll", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "paused(uint8)", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "paused()", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pauserRegistry", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "payForRange", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "registerOperatorToAVS", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "registeredOperators", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setPauserRegistry", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setup", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakeRegistry", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "taskCompleted", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "taskCreationMetadata", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateAVSMetadataURI", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateOperatorMetadata", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateTaskCreationMetadata", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "whitelistAddressAsOperator", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "whitelistedOperators", data: BytesLike): Result;
    events: {
        "Initialized(uint8)": EventFragment;
        "NewTaskCreated(uint32,((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256))": EventFragment;
        "OwnershipTransferred(address,address)": EventFragment;
        "Paused(address,uint256)": EventFragment;
        "PauserRegistrySet(address,address)": EventFragment;
        "TaskCompleted(uint32,(((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256),bytes[]))": EventFragment;
        "Unpaused(address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "NewTaskCreated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PauserRegistrySet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TaskCompleted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
}
export interface InitializedEventObject {
    version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface NewTaskCreatedEventObject {
    taskIndex: number;
    task: IReclaimServiceManager.TaskStructOutput;
}
export type NewTaskCreatedEvent = TypedEvent<[
    number,
    IReclaimServiceManager.TaskStructOutput
], NewTaskCreatedEventObject>;
export type NewTaskCreatedEventFilter = TypedEventFilter<NewTaskCreatedEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface PausedEventObject {
    account: string;
    newPausedStatus: BigNumber;
}
export type PausedEvent = TypedEvent<[string, BigNumber], PausedEventObject>;
export type PausedEventFilter = TypedEventFilter<PausedEvent>;
export interface PauserRegistrySetEventObject {
    pauserRegistry: string;
    newPauserRegistry: string;
}
export type PauserRegistrySetEvent = TypedEvent<[
    string,
    string
], PauserRegistrySetEventObject>;
export type PauserRegistrySetEventFilter = TypedEventFilter<PauserRegistrySetEvent>;
export interface TaskCompletedEventObject {
    taskIndex: number;
    task: IReclaimServiceManager.CompletedTaskStructOutput;
}
export type TaskCompletedEvent = TypedEvent<[
    number,
    IReclaimServiceManager.CompletedTaskStructOutput
], TaskCompletedEventObject>;
export type TaskCompletedEventFilter = TypedEventFilter<TaskCompletedEvent>;
export interface UnpausedEventObject {
    account: string;
    newPausedStatus: BigNumber;
}
export type UnpausedEvent = TypedEvent<[
    string,
    BigNumber
], UnpausedEventObject>;
export type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
export interface ReclaimServiceManager extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: ReclaimServiceManagerInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
        avsDirectory(overrides?: CallOverrides): Promise<[string]>;
        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<[string]>;
        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<[string]>;
        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<[IReclaimServiceManager.OperatorMetadataStructOutput]>;
        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<[string[]]>;
        getRestakeableStrategies(overrides?: CallOverrides): Promise<[string[]]>;
        isAdmin(_admin: string, overrides?: CallOverrides): Promise<[boolean]>;
        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<[boolean]>;
        latestTaskNum(overrides?: CallOverrides): Promise<[number]>;
        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<[boolean]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        pauseAll(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
        "paused()"(overrides?: CallOverrides): Promise<[BigNumber]>;
        pauserRegistry(overrides?: CallOverrides): Promise<[string]>;
        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
            addr: string;
            url: string;
        }>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setup(initialAdmin: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakeRegistry(overrides?: CallOverrides): Promise<[string]>;
        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        taskCreationMetadata(overrides?: CallOverrides): Promise<[
            number,
            number,
            number
        ] & {
            maxTaskLifetimeS: number;
            minSignaturesPerTask: number;
            maxTaskCreationDelayS: number;
        }>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
    };
    admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
    allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
    avsDirectory(overrides?: CallOverrides): Promise<string>;
    checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<string>;
    createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<string>;
    getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<IReclaimServiceManager.OperatorMetadataStructOutput>;
    getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<string[]>;
    getRestakeableStrategies(overrides?: CallOverrides): Promise<string[]>;
    isAdmin(_admin: string, overrides?: CallOverrides): Promise<boolean>;
    isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<boolean>;
    latestTaskNum(overrides?: CallOverrides): Promise<number>;
    operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<boolean>;
    owner(overrides?: CallOverrides): Promise<string>;
    pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    pauseAll(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
    "paused()"(overrides?: CallOverrides): Promise<BigNumber>;
    pauserRegistry(overrides?: CallOverrides): Promise<string>;
    payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
        addr: string;
        url: string;
    }>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setup(initialAdmin: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakeRegistry(overrides?: CallOverrides): Promise<string>;
    taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    taskCreationMetadata(overrides?: CallOverrides): Promise<[
        number,
        number,
        number
    ] & {
        maxTaskLifetimeS: number;
        minSignaturesPerTask: number;
        maxTaskCreationDelayS: number;
    }>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
    callStatic: {
        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
        avsDirectory(overrides?: CallOverrides): Promise<string>;
        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<string>;
        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<void>;
        deregisterOperatorFromAVS(operator: string, overrides?: CallOverrides): Promise<void>;
        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<string>;
        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<IReclaimServiceManager.OperatorMetadataStructOutput>;
        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<string[]>;
        getRestakeableStrategies(overrides?: CallOverrides): Promise<string[]>;
        isAdmin(_admin: string, overrides?: CallOverrides): Promise<boolean>;
        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<boolean>;
        latestTaskNum(overrides?: CallOverrides): Promise<number>;
        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<boolean>;
        owner(overrides?: CallOverrides): Promise<string>;
        pause(newPausedStatus: BigNumberish, overrides?: CallOverrides): Promise<void>;
        pauseAll(overrides?: CallOverrides): Promise<void>;
        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        "paused()"(overrides?: CallOverrides): Promise<BigNumber>;
        pauserRegistry(overrides?: CallOverrides): Promise<string>;
        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: CallOverrides): Promise<void>;
        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: CallOverrides): Promise<void>;
        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string, string] & {
            addr: string;
            url: string;
        }>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        setPauserRegistry(newPauserRegistry: string, overrides?: CallOverrides): Promise<void>;
        setup(initialAdmin: string, overrides?: CallOverrides): Promise<void>;
        stakeRegistry(overrides?: CallOverrides): Promise<string>;
        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: CallOverrides): Promise<void>;
        taskCreationMetadata(overrides?: CallOverrides): Promise<[
            number,
            number,
            number
        ] & {
            maxTaskLifetimeS: number;
            minSignaturesPerTask: number;
            maxTaskCreationDelayS: number;
        }>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
        unpause(newPausedStatus: BigNumberish, overrides?: CallOverrides): Promise<void>;
        updateAVSMetadataURI(_metadataURI: string, overrides?: CallOverrides): Promise<void>;
        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: CallOverrides): Promise<void>;
        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: CallOverrides): Promise<void>;
        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: CallOverrides): Promise<void>;
        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        "Initialized(uint8)"(version?: null): InitializedEventFilter;
        Initialized(version?: null): InitializedEventFilter;
        "NewTaskCreated(uint32,((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256))"(taskIndex?: BigNumberish | null, task?: null): NewTaskCreatedEventFilter;
        NewTaskCreated(taskIndex?: BigNumberish | null, task?: null): NewTaskCreatedEventFilter;
        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "Paused(address,uint256)"(account?: string | null, newPausedStatus?: null): PausedEventFilter;
        Paused(account?: string | null, newPausedStatus?: null): PausedEventFilter;
        "PauserRegistrySet(address,address)"(pauserRegistry?: null, newPauserRegistry?: null): PauserRegistrySetEventFilter;
        PauserRegistrySet(pauserRegistry?: null, newPauserRegistry?: null): PauserRegistrySetEventFilter;
        "TaskCompleted(uint32,(((string,bytes32,bytes32,uint32,address),uint32,uint32,uint8,(address,string)[],uint256),bytes[]))"(taskIndex?: BigNumberish | null, task?: null): TaskCompletedEventFilter;
        TaskCompleted(taskIndex?: BigNumberish | null, task?: null): TaskCompletedEventFilter;
        "Unpaused(address,uint256)"(account?: string | null, newPausedStatus?: null): UnpausedEventFilter;
        Unpaused(account?: string | null, newPausedStatus?: null): UnpausedEventFilter;
    };
    estimateGas: {
        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        avsDirectory(overrides?: CallOverrides): Promise<BigNumber>;
        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<BigNumber>;
        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<BigNumber>;
        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<BigNumber>;
        getRestakeableStrategies(overrides?: CallOverrides): Promise<BigNumber>;
        isAdmin(_admin: string, overrides?: CallOverrides): Promise<BigNumber>;
        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<BigNumber>;
        latestTaskNum(overrides?: CallOverrides): Promise<BigNumber>;
        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        pauseAll(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        "paused()"(overrides?: CallOverrides): Promise<BigNumber>;
        pauserRegistry(overrides?: CallOverrides): Promise<BigNumber>;
        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setup(initialAdmin: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakeRegistry(overrides?: CallOverrides): Promise<BigNumber>;
        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        taskCreationMetadata(overrides?: CallOverrides): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        admins(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        allTaskHashes(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        avsDirectory(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        checkSignerAddress(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        createNewTask(request: IReclaimServiceManager.ClaimRequestStruct, requestSignature: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        deregisterOperatorFromAVS(operator: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        encodeClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getMetadataForOperator(operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getOperatorRestakedStrategies(_operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getRestakeableStrategies(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isAdmin(_admin: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isOperatorWhitelisted(operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        latestTaskNum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        operatorHasMinimumWeight(operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pause(newPausedStatus: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        pauseAll(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        "paused(uint8)"(index: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        "paused()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pauserRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        payForRange(rangePayments: IPaymentCoordinator.RangePaymentStruct[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        registerOperatorToAVS(operator: string, operatorSignature: ISignatureUtils.SignatureWithSaltAndExpiryStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        registeredOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setPauserRegistry(newPauserRegistry: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setup(initialAdmin: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakeRegistry(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        taskCompleted(completedTask: IReclaimServiceManager.CompletedTaskStruct, referenceTaskIndex: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        taskCreationMetadata(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        unpause(newPausedStatus: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        updateAVSMetadataURI(_metadataURI: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        updateOperatorMetadata(metadata: IReclaimServiceManager.OperatorMetadataStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        updateTaskCreationMetadata(newMetadata: IReclaimServiceManager.TaskCreationMetadataStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        whitelistAddressAsOperator(operator: string, isWhitelisted: boolean, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        whitelistedOperators(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}