import type { BaseContract, BigNumber, 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.js';
export interface HoprNetworkRegistryInterface extends utils.Interface {
    functions: {
        'countRegisterdNodesPerAccount(address)': FunctionFragment;
        'disableRegistry()': FunctionFragment;
        'enableRegistry()': FunctionFragment;
        'enabled()': FunctionFragment;
        'isAccountRegisteredAndEligible(address)': FunctionFragment;
        'isNodeRegisteredAndEligible(string)': FunctionFragment;
        'nodePeerIdToAccount(string)': FunctionFragment;
        'owner()': FunctionFragment;
        'ownerDeregister(string[])': FunctionFragment;
        'ownerForceEligibility(address[],bool[])': FunctionFragment;
        'ownerRegister(address[],string[])': FunctionFragment;
        'renounceOwnership()': FunctionFragment;
        'requirementImplementation()': FunctionFragment;
        'selfDeregister(string[])': FunctionFragment;
        'selfRegister(string[])': FunctionFragment;
        'sync(string[])': FunctionFragment;
        'transferOwnership(address)': FunctionFragment;
        'updateRequirementImplementation(address)': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'countRegisterdNodesPerAccount' | 'disableRegistry' | 'enableRegistry' | 'enabled' | 'isAccountRegisteredAndEligible' | 'isNodeRegisteredAndEligible' | 'nodePeerIdToAccount' | 'owner' | 'ownerDeregister' | 'ownerForceEligibility' | 'ownerRegister' | 'renounceOwnership' | 'requirementImplementation' | 'selfDeregister' | 'selfRegister' | 'sync' | 'transferOwnership' | 'updateRequirementImplementation'): FunctionFragment;
    encodeFunctionData(functionFragment: 'countRegisterdNodesPerAccount', values: [string]): string;
    encodeFunctionData(functionFragment: 'disableRegistry', values?: undefined): string;
    encodeFunctionData(functionFragment: 'enableRegistry', values?: undefined): string;
    encodeFunctionData(functionFragment: 'enabled', values?: undefined): string;
    encodeFunctionData(functionFragment: 'isAccountRegisteredAndEligible', values: [string]): string;
    encodeFunctionData(functionFragment: 'isNodeRegisteredAndEligible', values: [string]): string;
    encodeFunctionData(functionFragment: 'nodePeerIdToAccount', values: [string]): string;
    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
    encodeFunctionData(functionFragment: 'ownerDeregister', values: [string[]]): string;
    encodeFunctionData(functionFragment: 'ownerForceEligibility', values: [string[], boolean[]]): string;
    encodeFunctionData(functionFragment: 'ownerRegister', values: [string[], string[]]): string;
    encodeFunctionData(functionFragment: 'renounceOwnership', values?: undefined): string;
    encodeFunctionData(functionFragment: 'requirementImplementation', values?: undefined): string;
    encodeFunctionData(functionFragment: 'selfDeregister', values: [string[]]): string;
    encodeFunctionData(functionFragment: 'selfRegister', values: [string[]]): string;
    encodeFunctionData(functionFragment: 'sync', values: [string[]]): string;
    encodeFunctionData(functionFragment: 'transferOwnership', values: [string]): string;
    encodeFunctionData(functionFragment: 'updateRequirementImplementation', values: [string]): string;
    decodeFunctionResult(functionFragment: 'countRegisterdNodesPerAccount', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'disableRegistry', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'enableRegistry', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'enabled', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'isAccountRegisteredAndEligible', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'isNodeRegisteredAndEligible', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'nodePeerIdToAccount', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'ownerDeregister', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'ownerForceEligibility', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'ownerRegister', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'renounceOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'requirementImplementation', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'selfDeregister', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'selfRegister', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'sync', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'transferOwnership', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'updateRequirementImplementation', data: BytesLike): Result;
    events: {
        'Deregistered(address,string)': EventFragment;
        'DeregisteredByOwner(address,string)': EventFragment;
        'EligibilityUpdated(address,bool)': EventFragment;
        'EnabledNetworkRegistry(bool)': EventFragment;
        'OwnershipTransferred(address,address)': EventFragment;
        'Registered(address,string)': EventFragment;
        'RegisteredByOwner(address,string)': EventFragment;
        'RequirementUpdated(address)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'Deregistered'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'DeregisteredByOwner'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'EligibilityUpdated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'EnabledNetworkRegistry'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OwnershipTransferred'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Registered'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RegisteredByOwner'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'RequirementUpdated'): EventFragment;
}
export interface DeregisteredEventObject {
    account: string;
    hoprPeerId: string;
}
export type DeregisteredEvent = TypedEvent<[string, string], DeregisteredEventObject>;
export type DeregisteredEventFilter = TypedEventFilter<DeregisteredEvent>;
export interface DeregisteredByOwnerEventObject {
    account: string;
    hoprPeerId: string;
}
export type DeregisteredByOwnerEvent = TypedEvent<[string, string], DeregisteredByOwnerEventObject>;
export type DeregisteredByOwnerEventFilter = TypedEventFilter<DeregisteredByOwnerEvent>;
export interface EligibilityUpdatedEventObject {
    account: string;
    eligibility: boolean;
}
export type EligibilityUpdatedEvent = TypedEvent<[string, boolean], EligibilityUpdatedEventObject>;
export type EligibilityUpdatedEventFilter = TypedEventFilter<EligibilityUpdatedEvent>;
export interface EnabledNetworkRegistryEventObject {
    isEnabled: boolean;
}
export type EnabledNetworkRegistryEvent = TypedEvent<[boolean], EnabledNetworkRegistryEventObject>;
export type EnabledNetworkRegistryEventFilter = TypedEventFilter<EnabledNetworkRegistryEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[string, string], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
export interface RegisteredEventObject {
    account: string;
    hoprPeerId: string;
}
export type RegisteredEvent = TypedEvent<[string, string], RegisteredEventObject>;
export type RegisteredEventFilter = TypedEventFilter<RegisteredEvent>;
export interface RegisteredByOwnerEventObject {
    account: string;
    hoprPeerId: string;
}
export type RegisteredByOwnerEvent = TypedEvent<[string, string], RegisteredByOwnerEventObject>;
export type RegisteredByOwnerEventFilter = TypedEventFilter<RegisteredByOwnerEvent>;
export interface RequirementUpdatedEventObject {
    requirementImplementation: string;
}
export type RequirementUpdatedEvent = TypedEvent<[string], RequirementUpdatedEventObject>;
export type RequirementUpdatedEventFilter = TypedEventFilter<RequirementUpdatedEvent>;
export interface HoprNetworkRegistry extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: HoprNetworkRegistryInterface;
    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: {
        countRegisterdNodesPerAccount(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        disableRegistry(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        enableRegistry(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        enabled(overrides?: CallOverrides): Promise<[boolean]>;
        isAccountRegisteredAndEligible(account: string, overrides?: CallOverrides): Promise<[boolean]>;
        isNodeRegisteredAndEligible(hoprPeerId: string, overrides?: CallOverrides): Promise<[boolean]>;
        nodePeerIdToAccount(arg0: string, overrides?: CallOverrides): Promise<[string]>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        ownerDeregister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        ownerForceEligibility(accounts: string[], eligibility: boolean[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        ownerRegister(accounts: string[], hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        requirementImplementation(overrides?: CallOverrides): Promise<[string]>;
        selfDeregister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        selfRegister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        sync(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
        updateRequirementImplementation(_requirementImplementation: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<ContractTransaction>;
    };
    countRegisterdNodesPerAccount(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    disableRegistry(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    enableRegistry(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    enabled(overrides?: CallOverrides): Promise<boolean>;
    isAccountRegisteredAndEligible(account: string, overrides?: CallOverrides): Promise<boolean>;
    isNodeRegisteredAndEligible(hoprPeerId: string, overrides?: CallOverrides): Promise<boolean>;
    nodePeerIdToAccount(arg0: string, overrides?: CallOverrides): Promise<string>;
    owner(overrides?: CallOverrides): Promise<string>;
    ownerDeregister(hoprPeerIds: string[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    ownerForceEligibility(accounts: string[], eligibility: boolean[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    ownerRegister(accounts: string[], hoprPeerIds: string[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    renounceOwnership(overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    requirementImplementation(overrides?: CallOverrides): Promise<string>;
    selfDeregister(hoprPeerIds: string[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    selfRegister(hoprPeerIds: string[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    sync(hoprPeerIds: string[], overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    updateRequirementImplementation(_requirementImplementation: string, overrides?: Overrides & {
        from?: string | Promise<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        countRegisterdNodesPerAccount(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        disableRegistry(overrides?: CallOverrides): Promise<void>;
        enableRegistry(overrides?: CallOverrides): Promise<void>;
        enabled(overrides?: CallOverrides): Promise<boolean>;
        isAccountRegisteredAndEligible(account: string, overrides?: CallOverrides): Promise<boolean>;
        isNodeRegisteredAndEligible(hoprPeerId: string, overrides?: CallOverrides): Promise<boolean>;
        nodePeerIdToAccount(arg0: string, overrides?: CallOverrides): Promise<string>;
        owner(overrides?: CallOverrides): Promise<string>;
        ownerDeregister(hoprPeerIds: string[], overrides?: CallOverrides): Promise<void>;
        ownerForceEligibility(accounts: string[], eligibility: boolean[], overrides?: CallOverrides): Promise<void>;
        ownerRegister(accounts: string[], hoprPeerIds: string[], overrides?: CallOverrides): Promise<void>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        requirementImplementation(overrides?: CallOverrides): Promise<string>;
        selfDeregister(hoprPeerIds: string[], overrides?: CallOverrides): Promise<void>;
        selfRegister(hoprPeerIds: string[], overrides?: CallOverrides): Promise<void>;
        sync(hoprPeerIds: string[], overrides?: CallOverrides): Promise<void>;
        transferOwnership(newOwner: string, overrides?: CallOverrides): Promise<void>;
        updateRequirementImplementation(_requirementImplementation: string, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        'Deregistered(address,string)'(account?: string | null, hoprPeerId?: null): DeregisteredEventFilter;
        Deregistered(account?: string | null, hoprPeerId?: null): DeregisteredEventFilter;
        'DeregisteredByOwner(address,string)'(account?: string | null, hoprPeerId?: null): DeregisteredByOwnerEventFilter;
        DeregisteredByOwner(account?: string | null, hoprPeerId?: null): DeregisteredByOwnerEventFilter;
        'EligibilityUpdated(address,bool)'(account?: string | null, eligibility?: boolean | null): EligibilityUpdatedEventFilter;
        EligibilityUpdated(account?: string | null, eligibility?: boolean | null): EligibilityUpdatedEventFilter;
        'EnabledNetworkRegistry(bool)'(isEnabled?: boolean | null): EnabledNetworkRegistryEventFilter;
        EnabledNetworkRegistry(isEnabled?: boolean | null): EnabledNetworkRegistryEventFilter;
        'OwnershipTransferred(address,address)'(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        'Registered(address,string)'(account?: string | null, hoprPeerId?: null): RegisteredEventFilter;
        Registered(account?: string | null, hoprPeerId?: null): RegisteredEventFilter;
        'RegisteredByOwner(address,string)'(account?: string | null, hoprPeerId?: null): RegisteredByOwnerEventFilter;
        RegisteredByOwner(account?: string | null, hoprPeerId?: null): RegisteredByOwnerEventFilter;
        'RequirementUpdated(address)'(requirementImplementation?: string | null): RequirementUpdatedEventFilter;
        RequirementUpdated(requirementImplementation?: string | null): RequirementUpdatedEventFilter;
    };
    estimateGas: {
        countRegisterdNodesPerAccount(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        disableRegistry(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        enableRegistry(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        enabled(overrides?: CallOverrides): Promise<BigNumber>;
        isAccountRegisteredAndEligible(account: string, overrides?: CallOverrides): Promise<BigNumber>;
        isNodeRegisteredAndEligible(hoprPeerId: string, overrides?: CallOverrides): Promise<BigNumber>;
        nodePeerIdToAccount(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        ownerDeregister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        ownerForceEligibility(accounts: string[], eligibility: boolean[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        ownerRegister(accounts: string[], hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        requirementImplementation(overrides?: CallOverrides): Promise<BigNumber>;
        selfDeregister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        selfRegister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        sync(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
        updateRequirementImplementation(_requirementImplementation: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        countRegisterdNodesPerAccount(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        disableRegistry(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        enableRegistry(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        enabled(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isAccountRegisteredAndEligible(account: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isNodeRegisteredAndEligible(hoprPeerId: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nodePeerIdToAccount(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        ownerDeregister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        ownerForceEligibility(accounts: string[], eligibility: boolean[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        ownerRegister(accounts: string[], hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        requirementImplementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        selfDeregister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        selfRegister(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        sync(hoprPeerIds: string[], overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
        updateRequirementImplementation(_requirementImplementation: string, overrides?: Overrides & {
            from?: string | Promise<string>;
        }): Promise<PopulatedTransaction>;
    };
}
//# sourceMappingURL=HoprNetworkRegistry.d.ts.map