import { BigNumberish, Overrides } from "ethers";
import { HandlerOptions } from "@sentio/sdk";
import { BindOptions, BaseProcessor, BaseProcessorTemplate, BoundContractView, ContractContext, ContractView, EthChainId, TypedCallTrace, EthContext, EthFetchConfig, PreprocessResult } from "@sentio/sdk/eth";
import { EthCallParam, EthCallContext, PreparedData } from "@sentio/protos";
import { EACAggregatorProxy, AnswerUpdatedEvent, AnswerUpdatedEventFilter, NewRoundEvent, NewRoundEventFilter, OwnershipTransferRequestedEvent, OwnershipTransferRequestedEventFilter, OwnershipTransferredEvent, OwnershipTransferredEventFilter } from "./EACAggregatorProxy.js";
export interface AcceptOwnershipCallObject {
}
export type AcceptOwnershipCallTrace = TypedCallTrace<[
], AcceptOwnershipCallObject>;
export interface AccessControllerCallObject {
}
export type AccessControllerCallTrace = TypedCallTrace<[
], AccessControllerCallObject>;
export interface AggregatorCallObject {
}
export type AggregatorCallTrace = TypedCallTrace<[], AggregatorCallObject>;
export interface ConfirmAggregatorCallObject {
    _aggregator: string;
}
export type ConfirmAggregatorCallTrace = TypedCallTrace<[
    string
], ConfirmAggregatorCallObject>;
export interface DecimalsCallObject {
}
export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject>;
export interface DescriptionCallObject {
}
export type DescriptionCallTrace = TypedCallTrace<[], DescriptionCallObject>;
export interface GetAnswerCallObject {
    _roundId: bigint;
}
export type GetAnswerCallTrace = TypedCallTrace<[bigint], GetAnswerCallObject>;
export interface GetRoundDataCallObject {
    _roundId: bigint;
}
export type GetRoundDataCallTrace = TypedCallTrace<[
    bigint
], GetRoundDataCallObject>;
export interface GetTimestampCallObject {
    _roundId: bigint;
}
export type GetTimestampCallTrace = TypedCallTrace<[
    bigint
], GetTimestampCallObject>;
export interface LatestAnswerCallObject {
}
export type LatestAnswerCallTrace = TypedCallTrace<[], LatestAnswerCallObject>;
export interface LatestRoundCallObject {
}
export type LatestRoundCallTrace = TypedCallTrace<[], LatestRoundCallObject>;
export interface LatestRoundDataCallObject {
}
export type LatestRoundDataCallTrace = TypedCallTrace<[
], LatestRoundDataCallObject>;
export interface LatestTimestampCallObject {
}
export type LatestTimestampCallTrace = TypedCallTrace<[
], LatestTimestampCallObject>;
export interface OwnerCallObject {
}
export type OwnerCallTrace = TypedCallTrace<[], OwnerCallObject>;
export interface PhaseAggregatorsCallObject {
}
export type PhaseAggregatorsCallTrace = TypedCallTrace<[
    bigint
], PhaseAggregatorsCallObject>;
export interface PhaseIdCallObject {
}
export type PhaseIdCallTrace = TypedCallTrace<[], PhaseIdCallObject>;
export interface ProposeAggregatorCallObject {
    _aggregator: string;
}
export type ProposeAggregatorCallTrace = TypedCallTrace<[
    string
], ProposeAggregatorCallObject>;
export interface ProposedAggregatorCallObject {
}
export type ProposedAggregatorCallTrace = TypedCallTrace<[
], ProposedAggregatorCallObject>;
export interface ProposedGetRoundDataCallObject {
    _roundId: bigint;
}
export type ProposedGetRoundDataCallTrace = TypedCallTrace<[
    bigint
], ProposedGetRoundDataCallObject>;
export interface ProposedLatestRoundDataCallObject {
}
export type ProposedLatestRoundDataCallTrace = TypedCallTrace<[
], ProposedLatestRoundDataCallObject>;
export interface SetControllerCallObject {
    _accessController: string;
}
export type SetControllerCallTrace = TypedCallTrace<[
    string
], SetControllerCallObject>;
export interface TransferOwnershipCallObject {
    _to: string;
}
export type TransferOwnershipCallTrace = TypedCallTrace<[
    string
], TransferOwnershipCallObject>;
export interface VersionCallObject {
}
export type VersionCallTrace = TypedCallTrace<[], VersionCallObject>;
export declare class EACAggregatorProxyContractView extends ContractView<EACAggregatorProxy> {
    constructor(contract: EACAggregatorProxy);
    accessController(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    aggregator(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    decimals(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    description(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    getAnswer(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    getRoundData(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    getTimestamp(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    latestAnswer(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    latestRound(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    latestRoundData(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    latestTimestamp(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    owner(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    phaseAggregators(arg0: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    phaseId(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    proposedAggregator(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<string>;
    proposedGetRoundData(_roundId: BigNumberish, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    proposedLatestRoundData(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    version(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<bigint>;
    callStatic: {
        contract: EACAggregatorProxy;
        acceptOwnership(overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        confirmAggregator(_aggregator: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        proposeAggregator(_aggregator: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        setController(_accessController: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
        transferOwnership(_to: string, overrides?: Overrides, preparedData?: PreparedData, ethCallContext?: EthCallContext): Promise<void>;
    };
    encodeCall: {
        acceptOwnership(callContext: EthCallContext): EthCallParam;
        accessController(callContext: EthCallContext): EthCallParam;
        aggregator(callContext: EthCallContext): EthCallParam;
        confirmAggregator(_aggregator: string, callContext: EthCallContext): EthCallParam;
        decimals(callContext: EthCallContext): EthCallParam;
        description(callContext: EthCallContext): EthCallParam;
        getAnswer(_roundId: BigNumberish, callContext: EthCallContext): EthCallParam;
        getRoundData(_roundId: BigNumberish, callContext: EthCallContext): EthCallParam;
        getTimestamp(_roundId: BigNumberish, callContext: EthCallContext): EthCallParam;
        latestAnswer(callContext: EthCallContext): EthCallParam;
        latestRound(callContext: EthCallContext): EthCallParam;
        latestRoundData(callContext: EthCallContext): EthCallParam;
        latestTimestamp(callContext: EthCallContext): EthCallParam;
        owner(callContext: EthCallContext): EthCallParam;
        phaseAggregators(arg0: BigNumberish, callContext: EthCallContext): EthCallParam;
        phaseId(callContext: EthCallContext): EthCallParam;
        proposeAggregator(_aggregator: string, callContext: EthCallContext): EthCallParam;
        proposedAggregator(callContext: EthCallContext): EthCallParam;
        proposedGetRoundData(_roundId: BigNumberish, callContext: EthCallContext): EthCallParam;
        proposedLatestRoundData(callContext: EthCallContext): EthCallParam;
        setController(_accessController: string, callContext: EthCallContext): EthCallParam;
        transferOwnership(_to: string, callContext: EthCallContext): EthCallParam;
        version(callContext: EthCallContext): EthCallParam;
    };
}
export declare class EACAggregatorProxyBoundContractView extends BoundContractView<EACAggregatorProxy, EACAggregatorProxyContractView> {
    accessController(overrides?: Overrides): Promise<string>;
    aggregator(overrides?: Overrides): Promise<string>;
    decimals(overrides?: Overrides): Promise<bigint>;
    description(overrides?: Overrides): Promise<string>;
    getAnswer(_roundId: BigNumberish, overrides?: Overrides): Promise<bigint>;
    getRoundData(_roundId: BigNumberish, overrides?: Overrides): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    getTimestamp(_roundId: BigNumberish, overrides?: Overrides): Promise<bigint>;
    latestAnswer(overrides?: Overrides): Promise<bigint>;
    latestRound(overrides?: Overrides): Promise<bigint>;
    latestRoundData(overrides?: Overrides): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    latestTimestamp(overrides?: Overrides): Promise<bigint>;
    owner(overrides?: Overrides): Promise<string>;
    phaseAggregators(arg0: BigNumberish, overrides?: Overrides): Promise<string>;
    phaseId(overrides?: Overrides): Promise<bigint>;
    proposedAggregator(overrides?: Overrides): Promise<string>;
    proposedGetRoundData(_roundId: BigNumberish, overrides?: Overrides): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    proposedLatestRoundData(overrides?: Overrides): Promise<[
        bigint,
        bigint,
        bigint,
        bigint,
        bigint
    ] & {
        roundId: bigint;
        answer: bigint;
        startedAt: bigint;
        updatedAt: bigint;
        answeredInRound: bigint;
    }>;
    version(overrides?: Overrides): Promise<bigint>;
    callStatic: {
        view: EACAggregatorProxyContractView;
        context: EthContext;
        acceptOwnership(overrides?: Overrides): Promise<void>;
        confirmAggregator(_aggregator: string, overrides?: Overrides): Promise<void>;
        proposeAggregator(_aggregator: string, overrides?: Overrides): Promise<void>;
        setController(_accessController: string, overrides?: Overrides): Promise<void>;
        transferOwnership(_to: string, overrides?: Overrides): Promise<void>;
    };
    encodeCall: {
        view: EACAggregatorProxyContractView;
        context: EthContext;
        acceptOwnership(overrides?: Overrides): EthCallParam;
        accessController(overrides?: Overrides): EthCallParam;
        aggregator(overrides?: Overrides): EthCallParam;
        confirmAggregator(_aggregator: string, overrides?: Overrides): EthCallParam;
        decimals(overrides?: Overrides): EthCallParam;
        description(overrides?: Overrides): EthCallParam;
        getAnswer(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
        getRoundData(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
        getTimestamp(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
        latestAnswer(overrides?: Overrides): EthCallParam;
        latestRound(overrides?: Overrides): EthCallParam;
        latestRoundData(overrides?: Overrides): EthCallParam;
        latestTimestamp(overrides?: Overrides): EthCallParam;
        owner(overrides?: Overrides): EthCallParam;
        phaseAggregators(arg0: BigNumberish, overrides?: Overrides): EthCallParam;
        phaseId(overrides?: Overrides): EthCallParam;
        proposeAggregator(_aggregator: string, overrides?: Overrides): EthCallParam;
        proposedAggregator(overrides?: Overrides): EthCallParam;
        proposedGetRoundData(_roundId: BigNumberish, overrides?: Overrides): EthCallParam;
        proposedLatestRoundData(overrides?: Overrides): EthCallParam;
        setController(_accessController: string, overrides?: Overrides): EthCallParam;
        transferOwnership(_to: string, overrides?: Overrides): EthCallParam;
        version(overrides?: Overrides): EthCallParam;
    };
}
export type EACAggregatorProxyContext = ContractContext<EACAggregatorProxy, EACAggregatorProxyBoundContractView>;
export declare class EACAggregatorProxyProcessor extends BaseProcessor<EACAggregatorProxy, EACAggregatorProxyBoundContractView> {
    onEventAnswerUpdated(handler: (event: AnswerUpdatedEvent, ctx: EACAggregatorProxyContext) => void, filter?: AnswerUpdatedEventFilter | AnswerUpdatedEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, AnswerUpdatedEvent>, preprocessHandler?: (event: AnswerUpdatedEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventNewRound(handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void, filter?: NewRoundEventFilter | NewRoundEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, NewRoundEvent>, preprocessHandler?: (event: NewRoundEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventOwnershipTransferRequested(handler: (event: OwnershipTransferRequestedEvent, ctx: EACAggregatorProxyContext) => void, filter?: OwnershipTransferRequestedEventFilter | OwnershipTransferRequestedEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferRequestedEvent>, preprocessHandler?: (event: OwnershipTransferRequestedEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventOwnershipTransferred(handler: (event: OwnershipTransferredEvent, ctx: EACAggregatorProxyContext) => void, filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferredEvent>, preprocessHandler?: (event: OwnershipTransferredEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onCallAcceptOwnership(handler: (call: AcceptOwnershipCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, AcceptOwnershipCallTrace>, preprocessHandler?: (call: AcceptOwnershipCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallAccessController(handler: (call: AccessControllerCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, AccessControllerCallTrace>, preprocessHandler?: (call: AccessControllerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallAggregator(handler: (call: AggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, AggregatorCallTrace>, preprocessHandler?: (call: AggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallConfirmAggregator(handler: (call: ConfirmAggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ConfirmAggregatorCallTrace>, preprocessHandler?: (call: ConfirmAggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallDecimals(handler: (call: DecimalsCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, DecimalsCallTrace>, preprocessHandler?: (call: DecimalsCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallDescription(handler: (call: DescriptionCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, DescriptionCallTrace>, preprocessHandler?: (call: DescriptionCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallGetAnswer(handler: (call: GetAnswerCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, GetAnswerCallTrace>, preprocessHandler?: (call: GetAnswerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallGetRoundData(handler: (call: GetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, GetRoundDataCallTrace>, preprocessHandler?: (call: GetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallGetTimestamp(handler: (call: GetTimestampCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, GetTimestampCallTrace>, preprocessHandler?: (call: GetTimestampCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallLatestAnswer(handler: (call: LatestAnswerCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, LatestAnswerCallTrace>, preprocessHandler?: (call: LatestAnswerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallLatestRound(handler: (call: LatestRoundCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, LatestRoundCallTrace>, preprocessHandler?: (call: LatestRoundCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallLatestRoundData(handler: (call: LatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, LatestRoundDataCallTrace>, preprocessHandler?: (call: LatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallLatestTimestamp(handler: (call: LatestTimestampCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, LatestTimestampCallTrace>, preprocessHandler?: (call: LatestTimestampCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallOwner(handler: (call: OwnerCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, OwnerCallTrace>, preprocessHandler?: (call: OwnerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallPhaseAggregators(handler: (call: PhaseAggregatorsCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, PhaseAggregatorsCallTrace>, preprocessHandler?: (call: PhaseAggregatorsCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallPhaseId(handler: (call: PhaseIdCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, PhaseIdCallTrace>, preprocessHandler?: (call: PhaseIdCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallProposeAggregator(handler: (call: ProposeAggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ProposeAggregatorCallTrace>, preprocessHandler?: (call: ProposeAggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallProposedAggregator(handler: (call: ProposedAggregatorCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ProposedAggregatorCallTrace>, preprocessHandler?: (call: ProposedAggregatorCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallProposedGetRoundData(handler: (call: ProposedGetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ProposedGetRoundDataCallTrace>, preprocessHandler?: (call: ProposedGetRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallProposedLatestRoundData(handler: (call: ProposedLatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, ProposedLatestRoundDataCallTrace>, preprocessHandler?: (call: ProposedLatestRoundDataCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallSetController(handler: (call: SetControllerCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, SetControllerCallTrace>, preprocessHandler?: (call: SetControllerCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallTransferOwnership(handler: (call: TransferOwnershipCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, TransferOwnershipCallTrace>, preprocessHandler?: (call: TransferOwnershipCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    onCallVersion(handler: (call: VersionCallTrace, ctx: EACAggregatorProxyContext) => void, handlerOptions?: HandlerOptions<EthFetchConfig, VersionCallTrace>, preprocessHandler?: (call: VersionCallTrace, ctx: EACAggregatorProxyContext) => Promise<PreprocessResult>): this;
    static filters: {
        AnswerUpdated(current?: BigNumberish | null, roundId?: BigNumberish | null, updatedAt?: null): AnswerUpdatedEventFilter;
        NewRound(roundId?: BigNumberish | null, startedBy?: string | null, startedAt?: null): NewRoundEventFilter;
        OwnershipTransferRequested(from?: string | null, to?: string | null): OwnershipTransferRequestedEventFilter;
        OwnershipTransferred(from?: string | null, to?: string | null): OwnershipTransferredEventFilter;
    };
    protected CreateBoundContractView(): EACAggregatorProxyBoundContractView;
    static bind(options: BindOptions): EACAggregatorProxyProcessor;
}
export declare class EACAggregatorProxyProcessorTemplate extends BaseProcessorTemplate<EACAggregatorProxy, EACAggregatorProxyBoundContractView> {
    bindInternal(options: BindOptions): EACAggregatorProxyProcessor;
    onEventAnswerUpdated(handler: (event: AnswerUpdatedEvent, ctx: EACAggregatorProxyContext) => void, filter?: AnswerUpdatedEventFilter | AnswerUpdatedEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, AnswerUpdatedEvent>, preprocessHandler?: (event: AnswerUpdatedEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventNewRound(handler: (event: NewRoundEvent, ctx: EACAggregatorProxyContext) => void, filter?: NewRoundEventFilter | NewRoundEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, NewRoundEvent>, preprocessHandler?: (event: NewRoundEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventOwnershipTransferRequested(handler: (event: OwnershipTransferRequestedEvent, ctx: EACAggregatorProxyContext) => void, filter?: OwnershipTransferRequestedEventFilter | OwnershipTransferRequestedEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferRequestedEvent>, preprocessHandler?: (event: OwnershipTransferRequestedEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
    onEventOwnershipTransferred(handler: (event: OwnershipTransferredEvent, ctx: EACAggregatorProxyContext) => void, filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[], handlerOptions?: HandlerOptions<EthFetchConfig, OwnershipTransferredEvent>, preprocessHandler?: (event: OwnershipTransferredEvent, ctx: EACAggregatorProxyContext, preprocessStore: {
        [k: string]: any;
    }) => Promise<PreprocessResult>): this;
}
export declare function getEACAggregatorProxyContract(chainId: EthChainId, address: string): EACAggregatorProxyContractView;
export declare function getEACAggregatorProxyContractOnContext(context: EthContext, address: string): EACAggregatorProxyBoundContractView;
//# sourceMappingURL=eacaggregatorproxy-processor.d.ts.map