/* Autogenerated file. Do not edit manually. */
/* tslint:disable */

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, PromiseOrValue } from './common';

export type PriceFeederStruct = {
    ftype: PromiseOrValue<BigNumberish>;
    scaler0: PromiseOrValue<BigNumberish>;
    aggregator0: PromiseOrValue<string>;
    heartBeat0: PromiseOrValue<BigNumberish>;
    scaler1: PromiseOrValue<BigNumberish>;
    aggregator1: PromiseOrValue<string>;
    heartBeat1: PromiseOrValue<BigNumberish>;
};

export type PriceFeederStructOutput = [number, BigNumber, string, number, BigNumber, string, number] & {
    ftype: number;
    scaler0: BigNumber;
    aggregator0: string;
    heartBeat0: number;
    scaler1: BigNumber;
    aggregator1: string;
    heartBeat1: number;
};

export type CexAccStateStruct = {
    time: PromiseOrValue<BigNumberish>;
    raw: PromiseOrValue<BigNumberish>;
    initTime: PromiseOrValue<BigNumberish>;
    initMark: PromiseOrValue<BigNumberish>;
    accumulation: PromiseOrValue<BigNumberish>;
};

export type CexAccStateStructOutput = [number, BigNumber, number, BigNumber, BigNumber] & {
    time: number;
    raw: BigNumber;
    initTime: number;
    initMark: BigNumber;
    accumulation: BigNumber;
};

export type EmaParamStruct = {
    emaHalfTime: PromiseOrValue<BigNumberish>;
    maxTimeDelta: PromiseOrValue<BigNumberish>;
    maxRawTimeDelta: PromiseOrValue<BigNumberish>;
    maxChangeRatioPerSecond: PromiseOrValue<BigNumberish>;
};

export type EmaParamStructOutput = [number, number, number, number] & {
    emaHalfTime: number;
    maxTimeDelta: number;
    maxRawTimeDelta: number;
    maxChangeRatioPerSecond: number;
};

export type SpotStateStruct = {
    time: PromiseOrValue<BigNumberish>;
    spot: PromiseOrValue<BigNumberish>;
    raw: PromiseOrValue<BigNumberish>;
};

export type SpotStateStructOutput = [number, BigNumber, BigNumber] & {
    time: number;
    spot: BigNumber;
    raw: BigNumber;
};

export interface CexMarketInterface extends utils.Interface {
    functions: {
        'clearStates(uint32)': FunctionFragment;
        'config()': FunctionFragment;
        'feeders(address)': FunctionFragment;
        'gate()': FunctionFragment;
        'getAccState(address,uint32)': FunctionFragment;
        'getAllInstruments()': FunctionFragment;
        'getBenchmarkPrice(address,uint32)': FunctionFragment;
        'getCompactEmaParam()': FunctionFragment;
        'getEmaParam(address)': FunctionFragment;
        'getMarkPrice(address,uint32,uint8)': FunctionFragment;
        'getMarketType()': FunctionFragment;
        'getRawPrice(address)': FunctionFragment;
        'getSpotPrice(address)': FunctionFragment;
        'getSpotState(address)': FunctionFragment;
        'initialize(uint256)': FunctionFragment;
        'instruments(uint256)': FunctionFragment;
        'instrumentsLength()': FunctionFragment;
        'markPrice(uint32,uint8)': FunctionFragment;
        'prepareInstrument(address,bytes)': FunctionFragment;
        'setCompactEmaParam(uint256)': FunctionFragment;
        'setFeeder(address[],(uint8,uint64,address,uint24,uint64,address,uint24)[])': FunctionFragment;
        'syncEmaParam(uint8)': FunctionFragment;
    };

    getFunction(
        nameOrSignatureOrTopic:
            | 'clearStates'
            | 'config'
            | 'feeders'
            | 'gate'
            | 'getAccState'
            | 'getAllInstruments'
            | 'getBenchmarkPrice'
            | 'getCompactEmaParam'
            | 'getEmaParam'
            | 'getMarkPrice'
            | 'getMarketType'
            | 'getRawPrice'
            | 'getSpotPrice'
            | 'getSpotState'
            | 'initialize'
            | 'instruments'
            | 'instrumentsLength'
            | 'markPrice'
            | 'prepareInstrument'
            | 'setCompactEmaParam'
            | 'setFeeder'
            | 'syncEmaParam',
    ): FunctionFragment;

    encodeFunctionData(functionFragment: 'clearStates', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'config', values?: undefined): string;
    encodeFunctionData(functionFragment: 'feeders', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'gate', values?: undefined): string;
    encodeFunctionData(
        functionFragment: 'getAccState',
        values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>],
    ): string;
    encodeFunctionData(functionFragment: 'getAllInstruments', values?: undefined): string;
    encodeFunctionData(
        functionFragment: 'getBenchmarkPrice',
        values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>],
    ): string;
    encodeFunctionData(functionFragment: 'getCompactEmaParam', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getEmaParam', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(
        functionFragment: 'getMarkPrice',
        values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>],
    ): string;
    encodeFunctionData(functionFragment: 'getMarketType', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getRawPrice', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'getSpotPrice', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'getSpotState', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'initialize', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'instruments', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'instrumentsLength', values?: undefined): string;
    encodeFunctionData(
        functionFragment: 'markPrice',
        values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>],
    ): string;
    encodeFunctionData(
        functionFragment: 'prepareInstrument',
        values: [PromiseOrValue<string>, PromiseOrValue<BytesLike>],
    ): string;
    encodeFunctionData(functionFragment: 'setCompactEmaParam', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setFeeder', values: [PromiseOrValue<string>[], PriceFeederStruct[]]): string;
    encodeFunctionData(functionFragment: 'syncEmaParam', values: [PromiseOrValue<BigNumberish>]): string;

    decodeFunctionResult(functionFragment: 'clearStates', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'config', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'feeders', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'gate', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getAccState', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getAllInstruments', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getBenchmarkPrice', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getCompactEmaParam', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getEmaParam', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getMarkPrice', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getMarketType', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getRawPrice', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getSpotPrice', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getSpotState', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'initialize', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'instruments', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'instrumentsLength', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'markPrice', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'prepareInstrument', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setCompactEmaParam', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setFeeder', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'syncEmaParam', data: BytesLike): Result;

    events: {
        'ClearStates(address,uint32)': EventFragment;
        'Initialized(uint8)': EventFragment;
        'SetCompactEmaParam(uint256)': EventFragment;
        'SetFeeder(address,tuple)': EventFragment;
        'UpdateAccState(address,uint32,tuple)': EventFragment;
        'UpdateEmaParam(address,tuple)': EventFragment;
        'UpdateSpotState(address,tuple)': EventFragment;
    };

    getEvent(nameOrSignatureOrTopic: 'ClearStates'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'Initialized'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetCompactEmaParam'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetFeeder'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateAccState'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateEmaParam'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateSpotState'): EventFragment;
}

export interface ClearStatesEventObject {
    instrument: string;
    expiry: number;
}
export type ClearStatesEvent = TypedEvent<[string, number], ClearStatesEventObject>;

export type ClearStatesEventFilter = TypedEventFilter<ClearStatesEvent>;

export interface InitializedEventObject {
    version: number;
}
export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;

export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;

export interface SetCompactEmaParamEventObject {
    compactEmaParam: BigNumber;
}
export type SetCompactEmaParamEvent = TypedEvent<[BigNumber], SetCompactEmaParamEventObject>;

export type SetCompactEmaParamEventFilter = TypedEventFilter<SetCompactEmaParamEvent>;

export interface SetFeederEventObject {
    instrument: string;
    feeder: PriceFeederStructOutput;
}
export type SetFeederEvent = TypedEvent<[string, PriceFeederStructOutput], SetFeederEventObject>;

export type SetFeederEventFilter = TypedEventFilter<SetFeederEvent>;

export interface UpdateAccStateEventObject {
    instrument: string;
    expiry: number;
    state: CexAccStateStructOutput;
}
export type UpdateAccStateEvent = TypedEvent<[string, number, CexAccStateStructOutput], UpdateAccStateEventObject>;

export type UpdateAccStateEventFilter = TypedEventFilter<UpdateAccStateEvent>;

export interface UpdateEmaParamEventObject {
    instrument: string;
    emaParam: EmaParamStructOutput;
}
export type UpdateEmaParamEvent = TypedEvent<[string, EmaParamStructOutput], UpdateEmaParamEventObject>;

export type UpdateEmaParamEventFilter = TypedEventFilter<UpdateEmaParamEvent>;

export interface UpdateSpotStateEventObject {
    instrument: string;
    spotState: SpotStateStructOutput;
}
export type UpdateSpotStateEvent = TypedEvent<[string, SpotStateStructOutput], UpdateSpotStateEventObject>;

export type UpdateSpotStateEventFilter = TypedEventFilter<UpdateSpotStateEvent>;

export interface CexMarket extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;

    interface: CexMarketInterface;

    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: {
        clearStates(
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<ContractTransaction>;

        config(overrides?: CallOverrides): Promise<[string]>;

        feeders(
            instrument: PromiseOrValue<string>,
            overrides?: CallOverrides,
        ): Promise<
            [number, BigNumber, string, number, BigNumber, string, number] & {
                ftype: number;
                scaler0: BigNumber;
                aggregator0: string;
                heartBeat0: number;
                scaler1: BigNumber;
                aggregator1: string;
                heartBeat1: number;
            }
        >;

        gate(overrides?: CallOverrides): Promise<[string]>;

        getAccState(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<[CexAccStateStructOutput]>;

        getAllInstruments(overrides?: CallOverrides): Promise<[string[]]>;

        getBenchmarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<[BigNumber] & { benchmark: BigNumber }>;

        getCompactEmaParam(overrides?: CallOverrides): Promise<[BigNumber]>;

        getEmaParam(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[EmaParamStructOutput]>;

        getMarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<[BigNumber] & { mark: BigNumber }>;

        getMarketType(overrides?: CallOverrides): Promise<[string]>;

        getRawPrice(
            instrument: PromiseOrValue<string>,
            overrides?: CallOverrides,
        ): Promise<[BigNumber] & { raw: BigNumber }>;

        getSpotPrice(
            instrument: PromiseOrValue<string>,
            overrides?: CallOverrides,
        ): Promise<[BigNumber] & { spot: BigNumber }>;

        getSpotState(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[SpotStateStructOutput]>;

        initialize(
            _compactEmaParam: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<ContractTransaction>;

        instruments(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[string]>;

        instrumentsLength(overrides?: CallOverrides): Promise<[BigNumber]>;

        markPrice(
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<ContractTransaction>;

        prepareInstrument(
            instrument: PromiseOrValue<string>,
            data: PromiseOrValue<BytesLike>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<ContractTransaction>;

        setCompactEmaParam(
            newCompactEmaParam: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<ContractTransaction>;

        setFeeder(
            instruments: PromiseOrValue<string>[],
            priceFeeders: PriceFeederStruct[],
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<ContractTransaction>;

        syncEmaParam(
            leverage: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<ContractTransaction>;
    };

    clearStates(
        expiry: PromiseOrValue<BigNumberish>,
        overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    config(overrides?: CallOverrides): Promise<string>;

    feeders(
        instrument: PromiseOrValue<string>,
        overrides?: CallOverrides,
    ): Promise<
        [number, BigNumber, string, number, BigNumber, string, number] & {
            ftype: number;
            scaler0: BigNumber;
            aggregator0: string;
            heartBeat0: number;
            scaler1: BigNumber;
            aggregator1: string;
            heartBeat1: number;
        }
    >;

    gate(overrides?: CallOverrides): Promise<string>;

    getAccState(
        instrument: PromiseOrValue<string>,
        expiry: PromiseOrValue<BigNumberish>,
        overrides?: CallOverrides,
    ): Promise<CexAccStateStructOutput>;

    getAllInstruments(overrides?: CallOverrides): Promise<string[]>;

    getBenchmarkPrice(
        instrument: PromiseOrValue<string>,
        expiry: PromiseOrValue<BigNumberish>,
        overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getCompactEmaParam(overrides?: CallOverrides): Promise<BigNumber>;

    getEmaParam(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<EmaParamStructOutput>;

    getMarkPrice(
        instrument: PromiseOrValue<string>,
        expiry: PromiseOrValue<BigNumberish>,
        status: PromiseOrValue<BigNumberish>,
        overrides?: CallOverrides,
    ): Promise<BigNumber>;

    getMarketType(overrides?: CallOverrides): Promise<string>;

    getRawPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

    getSpotPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

    getSpotState(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<SpotStateStructOutput>;

    initialize(
        _compactEmaParam: PromiseOrValue<BigNumberish>,
        overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    instruments(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;

    instrumentsLength(overrides?: CallOverrides): Promise<BigNumber>;

    markPrice(
        expiry: PromiseOrValue<BigNumberish>,
        status: PromiseOrValue<BigNumberish>,
        overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    prepareInstrument(
        instrument: PromiseOrValue<string>,
        data: PromiseOrValue<BytesLike>,
        overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    setCompactEmaParam(
        newCompactEmaParam: PromiseOrValue<BigNumberish>,
        overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    setFeeder(
        instruments: PromiseOrValue<string>[],
        priceFeeders: PriceFeederStruct[],
        overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    syncEmaParam(
        leverage: PromiseOrValue<BigNumberish>,
        overrides?: Overrides & { from?: PromiseOrValue<string> },
    ): Promise<ContractTransaction>;

    callStatic: {
        clearStates(expiry: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;

        config(overrides?: CallOverrides): Promise<string>;

        feeders(
            instrument: PromiseOrValue<string>,
            overrides?: CallOverrides,
        ): Promise<
            [number, BigNumber, string, number, BigNumber, string, number] & {
                ftype: number;
                scaler0: BigNumber;
                aggregator0: string;
                heartBeat0: number;
                scaler1: BigNumber;
                aggregator1: string;
                heartBeat1: number;
            }
        >;

        gate(overrides?: CallOverrides): Promise<string>;

        getAccState(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<CexAccStateStructOutput>;

        getAllInstruments(overrides?: CallOverrides): Promise<string[]>;

        getBenchmarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<BigNumber>;

        getCompactEmaParam(overrides?: CallOverrides): Promise<BigNumber>;

        getEmaParam(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<EmaParamStructOutput>;

        getMarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<BigNumber>;

        getMarketType(overrides?: CallOverrides): Promise<string>;

        getRawPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

        getSpotPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

        getSpotState(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<SpotStateStructOutput>;

        initialize(_compactEmaParam: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;

        instruments(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<string>;

        instrumentsLength(overrides?: CallOverrides): Promise<BigNumber>;

        markPrice(
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<BigNumber>;

        prepareInstrument(
            instrument: PromiseOrValue<string>,
            data: PromiseOrValue<BytesLike>,
            overrides?: CallOverrides,
        ): Promise<
            [string, string, string] & {
                index: string;
                base: string;
                initData: string;
            }
        >;

        setCompactEmaParam(newCompactEmaParam: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;

        setFeeder(
            instruments: PromiseOrValue<string>[],
            priceFeeders: PriceFeederStruct[],
            overrides?: CallOverrides,
        ): Promise<void>;

        syncEmaParam(leverage: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
    };

    filters: {
        'ClearStates(address,uint32)'(
            instrument?: PromiseOrValue<string> | null,
            expiry?: null,
        ): ClearStatesEventFilter;
        ClearStates(instrument?: PromiseOrValue<string> | null, expiry?: null): ClearStatesEventFilter;

        'Initialized(uint8)'(version?: null): InitializedEventFilter;
        Initialized(version?: null): InitializedEventFilter;

        'SetCompactEmaParam(uint256)'(compactEmaParam?: null): SetCompactEmaParamEventFilter;
        SetCompactEmaParam(compactEmaParam?: null): SetCompactEmaParamEventFilter;

        'SetFeeder(address,tuple)'(instrument?: PromiseOrValue<string> | null, feeder?: null): SetFeederEventFilter;
        SetFeeder(instrument?: PromiseOrValue<string> | null, feeder?: null): SetFeederEventFilter;

        'UpdateAccState(address,uint32,tuple)'(
            instrument?: PromiseOrValue<string> | null,
            expiry?: null,
            state?: null,
        ): UpdateAccStateEventFilter;
        UpdateAccState(
            instrument?: PromiseOrValue<string> | null,
            expiry?: null,
            state?: null,
        ): UpdateAccStateEventFilter;

        'UpdateEmaParam(address,tuple)'(
            instrument?: PromiseOrValue<string> | null,
            emaParam?: null,
        ): UpdateEmaParamEventFilter;
        UpdateEmaParam(instrument?: PromiseOrValue<string> | null, emaParam?: null): UpdateEmaParamEventFilter;

        'UpdateSpotState(address,tuple)'(
            instrument?: PromiseOrValue<string> | null,
            spotState?: null,
        ): UpdateSpotStateEventFilter;
        UpdateSpotState(instrument?: PromiseOrValue<string> | null, spotState?: null): UpdateSpotStateEventFilter;
    };

    estimateGas: {
        clearStates(
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<BigNumber>;

        config(overrides?: CallOverrides): Promise<BigNumber>;

        feeders(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

        gate(overrides?: CallOverrides): Promise<BigNumber>;

        getAccState(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<BigNumber>;

        getAllInstruments(overrides?: CallOverrides): Promise<BigNumber>;

        getBenchmarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<BigNumber>;

        getCompactEmaParam(overrides?: CallOverrides): Promise<BigNumber>;

        getEmaParam(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

        getMarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<BigNumber>;

        getMarketType(overrides?: CallOverrides): Promise<BigNumber>;

        getRawPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

        getSpotPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

        getSpotState(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;

        initialize(
            _compactEmaParam: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<BigNumber>;

        instruments(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;

        instrumentsLength(overrides?: CallOverrides): Promise<BigNumber>;

        markPrice(
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<BigNumber>;

        prepareInstrument(
            instrument: PromiseOrValue<string>,
            data: PromiseOrValue<BytesLike>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<BigNumber>;

        setCompactEmaParam(
            newCompactEmaParam: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<BigNumber>;

        setFeeder(
            instruments: PromiseOrValue<string>[],
            priceFeeders: PriceFeederStruct[],
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<BigNumber>;

        syncEmaParam(
            leverage: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<BigNumber>;
    };

    populateTransaction: {
        clearStates(
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<PopulatedTransaction>;

        config(overrides?: CallOverrides): Promise<PopulatedTransaction>;

        feeders(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;

        gate(overrides?: CallOverrides): Promise<PopulatedTransaction>;

        getAccState(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<PopulatedTransaction>;

        getAllInstruments(overrides?: CallOverrides): Promise<PopulatedTransaction>;

        getBenchmarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<PopulatedTransaction>;

        getCompactEmaParam(overrides?: CallOverrides): Promise<PopulatedTransaction>;

        getEmaParam(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;

        getMarkPrice(
            instrument: PromiseOrValue<string>,
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: CallOverrides,
        ): Promise<PopulatedTransaction>;

        getMarketType(overrides?: CallOverrides): Promise<PopulatedTransaction>;

        getRawPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;

        getSpotPrice(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;

        getSpotState(instrument: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;

        initialize(
            _compactEmaParam: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<PopulatedTransaction>;

        instruments(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;

        instrumentsLength(overrides?: CallOverrides): Promise<PopulatedTransaction>;

        markPrice(
            expiry: PromiseOrValue<BigNumberish>,
            status: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<PopulatedTransaction>;

        prepareInstrument(
            instrument: PromiseOrValue<string>,
            data: PromiseOrValue<BytesLike>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<PopulatedTransaction>;

        setCompactEmaParam(
            newCompactEmaParam: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<PopulatedTransaction>;

        setFeeder(
            instruments: PromiseOrValue<string>[],
            priceFeeders: PriceFeederStruct[],
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<PopulatedTransaction>;

        syncEmaParam(
            leverage: PromiseOrValue<BigNumberish>,
            overrides?: Overrides & { from?: PromiseOrValue<string> },
        ): Promise<PopulatedTransaction>;
    };
}