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 interface PolynomialPutSellingInterface extends utils.Interface {
    functions: {
        'GREEKS()': FunctionFragment;
        'MARKET()': FunctionFragment;
        'MARKET_WRAPPER()': FunctionFragment;
        'OPTION_TOKEN()': FunctionFragment;
        'OPTION_TYPE()': FunctionFragment;
        'RATES()': FunctionFragment;
        'SUSD()': FunctionFragment;
        'UNDERLYING_SYNTH_KEY()': FunctionFragment;
        'VAULT_TOKEN()': FunctionFragment;
        'addCollateral(uint256,uint256)': FunctionFragment;
        'authority()': FunctionFragment;
        'closePosition(uint256,uint256,uint256)': FunctionFragment;
        'collateralization()': FunctionFragment;
        'depositQueue(uint256)': FunctionFragment;
        'depositsPaused()': FunctionFragment;
        'feeReceipient()': FunctionFragment;
        'getLiveStrikes()': FunctionFragment;
        'getTokenPrice()': FunctionFragment;
        'getTotalSupply()': FunctionFragment;
        'initiateDeposit(address,uint256)': FunctionFragment;
        'initiateWithdrawal(address,uint256)': FunctionFragment;
        'liveStrikes(uint256)': FunctionFragment;
        'minDepositAmount()': FunctionFragment;
        'minDepositDelay()': FunctionFragment;
        'minWithdrawDelay()': FunctionFragment;
        'name()': FunctionFragment;
        'nextQueuedDepositId()': FunctionFragment;
        'nextQueuedWithdrawalId()': FunctionFragment;
        'openPosition(uint256,uint256)': FunctionFragment;
        'owner()': FunctionFragment;
        'pause()': FunctionFragment;
        'pauseDeposits()': FunctionFragment;
        'paused()': FunctionFragment;
        'performanceFee()': FunctionFragment;
        'positionDatas(uint256)': FunctionFragment;
        'processDepositQueue(uint256)': FunctionFragment;
        'processWithdrawalQueue(uint256)': FunctionFragment;
        'queuedDepositHead()': FunctionFragment;
        'queuedWithdrawalHead()': FunctionFragment;
        'saveToken(address,address,uint256)': FunctionFragment;
        'setAuthority(address)': FunctionFragment;
        'setCollateralization(uint256)': FunctionFragment;
        'setDelays(uint256,uint256)': FunctionFragment;
        'setFeeReceipient(address)': FunctionFragment;
        'setFees(uint256,uint256)': FunctionFragment;
        'setMinDepositAmount(uint256)': FunctionFragment;
        'setOwner(address)': FunctionFragment;
        'settleOptions(uint256[])': FunctionFragment;
        'totalFunds()': FunctionFragment;
        'totalPremiumCollected()': FunctionFragment;
        'totalQueuedDeposits()': FunctionFragment;
        'totalQueuedWithdrawals()': FunctionFragment;
        'unpause()': FunctionFragment;
        'unpauseDeposits()': FunctionFragment;
        'usedFunds()': FunctionFragment;
        'withdrawalFee()': FunctionFragment;
        'withdrawalQueue(uint256)': FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: 'GREEKS' | 'MARKET' | 'MARKET_WRAPPER' | 'OPTION_TOKEN' | 'OPTION_TYPE' | 'RATES' | 'SUSD' | 'UNDERLYING_SYNTH_KEY' | 'VAULT_TOKEN' | 'addCollateral' | 'authority' | 'closePosition' | 'collateralization' | 'depositQueue' | 'depositsPaused' | 'feeReceipient' | 'getLiveStrikes' | 'getTokenPrice' | 'getTotalSupply' | 'initiateDeposit' | 'initiateWithdrawal' | 'liveStrikes' | 'minDepositAmount' | 'minDepositDelay' | 'minWithdrawDelay' | 'name' | 'nextQueuedDepositId' | 'nextQueuedWithdrawalId' | 'openPosition' | 'owner' | 'pause' | 'pauseDeposits' | 'paused' | 'performanceFee' | 'positionDatas' | 'processDepositQueue' | 'processWithdrawalQueue' | 'queuedDepositHead' | 'queuedWithdrawalHead' | 'saveToken' | 'setAuthority' | 'setCollateralization' | 'setDelays' | 'setFeeReceipient' | 'setFees' | 'setMinDepositAmount' | 'setOwner' | 'settleOptions' | 'totalFunds' | 'totalPremiumCollected' | 'totalQueuedDeposits' | 'totalQueuedWithdrawals' | 'unpause' | 'unpauseDeposits' | 'usedFunds' | 'withdrawalFee' | 'withdrawalQueue'): FunctionFragment;
    encodeFunctionData(functionFragment: 'GREEKS', values?: undefined): string;
    encodeFunctionData(functionFragment: 'MARKET', values?: undefined): string;
    encodeFunctionData(functionFragment: 'MARKET_WRAPPER', values?: undefined): string;
    encodeFunctionData(functionFragment: 'OPTION_TOKEN', values?: undefined): string;
    encodeFunctionData(functionFragment: 'OPTION_TYPE', values?: undefined): string;
    encodeFunctionData(functionFragment: 'RATES', values?: undefined): string;
    encodeFunctionData(functionFragment: 'SUSD', values?: undefined): string;
    encodeFunctionData(functionFragment: 'UNDERLYING_SYNTH_KEY', values?: undefined): string;
    encodeFunctionData(functionFragment: 'VAULT_TOKEN', values?: undefined): string;
    encodeFunctionData(functionFragment: 'addCollateral', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'authority', values?: undefined): string;
    encodeFunctionData(functionFragment: 'closePosition', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'collateralization', values?: undefined): string;
    encodeFunctionData(functionFragment: 'depositQueue', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'depositsPaused', values?: undefined): string;
    encodeFunctionData(functionFragment: 'feeReceipient', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getLiveStrikes', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getTokenPrice', values?: undefined): string;
    encodeFunctionData(functionFragment: 'getTotalSupply', values?: undefined): string;
    encodeFunctionData(functionFragment: 'initiateDeposit', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'initiateWithdrawal', values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'liveStrikes', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'minDepositAmount', values?: undefined): string;
    encodeFunctionData(functionFragment: 'minDepositDelay', values?: undefined): string;
    encodeFunctionData(functionFragment: 'minWithdrawDelay', values?: undefined): string;
    encodeFunctionData(functionFragment: 'name', values?: undefined): string;
    encodeFunctionData(functionFragment: 'nextQueuedDepositId', values?: undefined): string;
    encodeFunctionData(functionFragment: 'nextQueuedWithdrawalId', values?: undefined): string;
    encodeFunctionData(functionFragment: 'openPosition', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'owner', values?: undefined): string;
    encodeFunctionData(functionFragment: 'pause', values?: undefined): string;
    encodeFunctionData(functionFragment: 'pauseDeposits', values?: undefined): string;
    encodeFunctionData(functionFragment: 'paused', values?: undefined): string;
    encodeFunctionData(functionFragment: 'performanceFee', values?: undefined): string;
    encodeFunctionData(functionFragment: 'positionDatas', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'processDepositQueue', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'processWithdrawalQueue', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'queuedDepositHead', values?: undefined): string;
    encodeFunctionData(functionFragment: 'queuedWithdrawalHead', values?: undefined): string;
    encodeFunctionData(functionFragment: 'saveToken', values: [PromiseOrValue<string>, PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setAuthority', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setCollateralization', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setDelays', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setFeeReceipient', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'setFees', values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setMinDepositAmount', values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: 'setOwner', values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: 'settleOptions', values: [PromiseOrValue<BigNumberish>[]]): string;
    encodeFunctionData(functionFragment: 'totalFunds', values?: undefined): string;
    encodeFunctionData(functionFragment: 'totalPremiumCollected', values?: undefined): string;
    encodeFunctionData(functionFragment: 'totalQueuedDeposits', values?: undefined): string;
    encodeFunctionData(functionFragment: 'totalQueuedWithdrawals', values?: undefined): string;
    encodeFunctionData(functionFragment: 'unpause', values?: undefined): string;
    encodeFunctionData(functionFragment: 'unpauseDeposits', values?: undefined): string;
    encodeFunctionData(functionFragment: 'usedFunds', values?: undefined): string;
    encodeFunctionData(functionFragment: 'withdrawalFee', values?: undefined): string;
    encodeFunctionData(functionFragment: 'withdrawalQueue', values: [PromiseOrValue<BigNumberish>]): string;
    decodeFunctionResult(functionFragment: 'GREEKS', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'MARKET', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'MARKET_WRAPPER', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'OPTION_TOKEN', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'OPTION_TYPE', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'RATES', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'SUSD', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'UNDERLYING_SYNTH_KEY', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'VAULT_TOKEN', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'addCollateral', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'authority', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'closePosition', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'collateralization', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'depositQueue', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'depositsPaused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'feeReceipient', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getLiveStrikes', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getTokenPrice', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'getTotalSupply', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'initiateDeposit', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'initiateWithdrawal', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'liveStrikes', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'minDepositAmount', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'minDepositDelay', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'minWithdrawDelay', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'name', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'nextQueuedDepositId', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'nextQueuedWithdrawalId', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'openPosition', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'owner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'pause', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'pauseDeposits', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'paused', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'performanceFee', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'positionDatas', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'processDepositQueue', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'processWithdrawalQueue', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'queuedDepositHead', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'queuedWithdrawalHead', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'saveToken', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setAuthority', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setCollateralization', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setDelays', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setFeeReceipient', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setFees', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setMinDepositAmount', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'setOwner', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'settleOptions', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalFunds', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalPremiumCollected', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalQueuedDeposits', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'totalQueuedWithdrawals', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'unpause', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'unpauseDeposits', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'usedFunds', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdrawalFee', data: BytesLike): Result;
    decodeFunctionResult(functionFragment: 'withdrawalQueue', data: BytesLike): Result;
    events: {
        'AddCollateral(uint256,uint256,uint256)': EventFragment;
        'AuthorityUpdated(address,address)': EventFragment;
        'ClosePosition(uint256,uint256,uint256,uint256,uint256)': EventFragment;
        'InitiateDeposit(uint256,address,address,uint256)': EventFragment;
        'InitiateWithdrawal(uint256,address,address,uint256)': EventFragment;
        'OpenPosition(uint256,uint256,uint256,uint256,uint256,int256)': EventFragment;
        'OwnerUpdated(address,address)': EventFragment;
        'ProcessDeposit(uint256,address,uint256,uint256,uint256)': EventFragment;
        'ProcessWithdrawal(uint256,address,uint256,uint256,uint256)': EventFragment;
        'ProcessWithdrawalPartially(uint256,address,uint256,uint256,uint256)': EventFragment;
        'SetDepositsPaused(address)': EventFragment;
        'SetDepositsUnpaused(address)': EventFragment;
        'SetPaused(address)': EventFragment;
        'SetUnpaused(address)': EventFragment;
        'SettleOption(uint256,uint256,uint256,uint256,int256,uint256)': EventFragment;
        'UpdateCollateralization(uint256,uint256)': EventFragment;
        'UpdateDelays(uint256,uint256,uint256,uint256)': EventFragment;
        'UpdateFeeReceipient(address,address)': EventFragment;
        'UpdateFees(uint256,uint256,uint256,uint256)': EventFragment;
        'UpdateMinDeposit(uint256,uint256)': EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: 'AddCollateral'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'AuthorityUpdated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ClosePosition'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'InitiateDeposit'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'InitiateWithdrawal'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OpenPosition'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'OwnerUpdated'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ProcessDeposit'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ProcessWithdrawal'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'ProcessWithdrawalPartially'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetDepositsPaused'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetDepositsUnpaused'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetPaused'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SetUnpaused'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'SettleOption'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateCollateralization'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateDelays'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateFeeReceipient'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateFees'): EventFragment;
    getEvent(nameOrSignatureOrTopic: 'UpdateMinDeposit'): EventFragment;
}
export interface AddCollateralEventObject {
    strikeId: BigNumber;
    positionId: BigNumber;
    amount: BigNumber;
}
export declare type AddCollateralEvent = TypedEvent<[BigNumber, BigNumber, BigNumber], AddCollateralEventObject>;
export declare type AddCollateralEventFilter = TypedEventFilter<AddCollateralEvent>;
export interface AuthorityUpdatedEventObject {
    user: string;
    newAuthority: string;
}
export declare type AuthorityUpdatedEvent = TypedEvent<[string, string], AuthorityUpdatedEventObject>;
export declare type AuthorityUpdatedEventFilter = TypedEventFilter<AuthorityUpdatedEvent>;
export interface ClosePositionEventObject {
    strikeId: BigNumber;
    positionId: BigNumber;
    amount: BigNumber;
    collateralWithdrawn: BigNumber;
    premiumPaid: BigNumber;
}
export declare type ClosePositionEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], ClosePositionEventObject>;
export declare type ClosePositionEventFilter = TypedEventFilter<ClosePositionEvent>;
export interface InitiateDepositEventObject {
    depositId: BigNumber;
    depositor: string;
    user: string;
    amount: BigNumber;
}
export declare type InitiateDepositEvent = TypedEvent<[BigNumber, string, string, BigNumber], InitiateDepositEventObject>;
export declare type InitiateDepositEventFilter = TypedEventFilter<InitiateDepositEvent>;
export interface InitiateWithdrawalEventObject {
    withdrawalId: BigNumber;
    withdrawer: string;
    user: string;
    tokens: BigNumber;
}
export declare type InitiateWithdrawalEvent = TypedEvent<[BigNumber, string, string, BigNumber], InitiateWithdrawalEventObject>;
export declare type InitiateWithdrawalEventFilter = TypedEventFilter<InitiateWithdrawalEvent>;
export interface OpenPositionEventObject {
    strikeId: BigNumber;
    positionId: BigNumber;
    amount: BigNumber;
    collateral: BigNumber;
    premiumCollected: BigNumber;
    putDelta: BigNumber;
}
export declare type OpenPositionEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], OpenPositionEventObject>;
export declare type OpenPositionEventFilter = TypedEventFilter<OpenPositionEvent>;
export interface OwnerUpdatedEventObject {
    user: string;
    newOwner: string;
}
export declare type OwnerUpdatedEvent = TypedEvent<[string, string], OwnerUpdatedEventObject>;
export declare type OwnerUpdatedEventFilter = TypedEventFilter<OwnerUpdatedEvent>;
export interface ProcessDepositEventObject {
    depositId: BigNumber;
    user: string;
    amount: BigNumber;
    tokens: BigNumber;
    requestedTime: BigNumber;
}
export declare type ProcessDepositEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber,
    BigNumber,
    BigNumber
], ProcessDepositEventObject>;
export declare type ProcessDepositEventFilter = TypedEventFilter<ProcessDepositEvent>;
export interface ProcessWithdrawalEventObject {
    withdrawalId: BigNumber;
    user: string;
    tokens: BigNumber;
    amount: BigNumber;
    requestedTime: BigNumber;
}
export declare type ProcessWithdrawalEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber,
    BigNumber,
    BigNumber
], ProcessWithdrawalEventObject>;
export declare type ProcessWithdrawalEventFilter = TypedEventFilter<ProcessWithdrawalEvent>;
export interface ProcessWithdrawalPartiallyEventObject {
    withdrawalId: BigNumber;
    user: string;
    tokens: BigNumber;
    amount: BigNumber;
    requestedTime: BigNumber;
}
export declare type ProcessWithdrawalPartiallyEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber,
    BigNumber,
    BigNumber
], ProcessWithdrawalPartiallyEventObject>;
export declare type ProcessWithdrawalPartiallyEventFilter = TypedEventFilter<ProcessWithdrawalPartiallyEvent>;
export interface SetDepositsPausedEventObject {
    account: string;
}
export declare type SetDepositsPausedEvent = TypedEvent<[string], SetDepositsPausedEventObject>;
export declare type SetDepositsPausedEventFilter = TypedEventFilter<SetDepositsPausedEvent>;
export interface SetDepositsUnpausedEventObject {
    account: string;
}
export declare type SetDepositsUnpausedEvent = TypedEvent<[string], SetDepositsUnpausedEventObject>;
export declare type SetDepositsUnpausedEventFilter = TypedEventFilter<SetDepositsUnpausedEvent>;
export interface SetPausedEventObject {
    account: string;
}
export declare type SetPausedEvent = TypedEvent<[string], SetPausedEventObject>;
export declare type SetPausedEventFilter = TypedEventFilter<SetPausedEvent>;
export interface SetUnpausedEventObject {
    account: string;
}
export declare type SetUnpausedEvent = TypedEvent<[string], SetUnpausedEventObject>;
export declare type SetUnpausedEventFilter = TypedEventFilter<SetUnpausedEvent>;
export interface SettleOptionEventObject {
    strikeId: BigNumber;
    positionId: BigNumber;
    amount: BigNumber;
    totalCollateral: BigNumber;
    totalPremium: BigNumber;
    loss: BigNumber;
}
export declare type SettleOptionEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], SettleOptionEventObject>;
export declare type SettleOptionEventFilter = TypedEventFilter<SettleOptionEvent>;
export interface UpdateCollateralizationEventObject {
    oldCollateralization: BigNumber;
    newCollateralization: BigNumber;
}
export declare type UpdateCollateralizationEvent = TypedEvent<[BigNumber, BigNumber], UpdateCollateralizationEventObject>;
export declare type UpdateCollateralizationEventFilter = TypedEventFilter<UpdateCollateralizationEvent>;
export interface UpdateDelaysEventObject {
    oldDepositDelay: BigNumber;
    newDepositDelay: BigNumber;
    oldWithdrawDelay: BigNumber;
    newWithdrawDelay: BigNumber;
}
export declare type UpdateDelaysEvent = TypedEvent<[BigNumber, BigNumber, BigNumber, BigNumber], UpdateDelaysEventObject>;
export declare type UpdateDelaysEventFilter = TypedEventFilter<UpdateDelaysEvent>;
export interface UpdateFeeReceipientEventObject {
    oldFeeReceipient: string;
    newFeeReceipient: string;
}
export declare type UpdateFeeReceipientEvent = TypedEvent<[string, string], UpdateFeeReceipientEventObject>;
export declare type UpdateFeeReceipientEventFilter = TypedEventFilter<UpdateFeeReceipientEvent>;
export interface UpdateFeesEventObject {
    oldPerf: BigNumber;
    oldWithdraw: BigNumber;
    newPerf: BigNumber;
    newWithdraw: BigNumber;
}
export declare type UpdateFeesEvent = TypedEvent<[BigNumber, BigNumber, BigNumber, BigNumber], UpdateFeesEventObject>;
export declare type UpdateFeesEventFilter = TypedEventFilter<UpdateFeesEvent>;
export interface UpdateMinDepositEventObject {
    oldMinimum: BigNumber;
    newMinimum: BigNumber;
}
export declare type UpdateMinDepositEvent = TypedEvent<[BigNumber, BigNumber], UpdateMinDepositEventObject>;
export declare type UpdateMinDepositEventFilter = TypedEventFilter<UpdateMinDepositEvent>;
export interface PolynomialPutSelling extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: PolynomialPutSellingInterface;
    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: {
        GREEKS(overrides?: CallOverrides): Promise<[string]>;
        MARKET(overrides?: CallOverrides): Promise<[string]>;
        MARKET_WRAPPER(overrides?: CallOverrides): Promise<[string]>;
        OPTION_TOKEN(overrides?: CallOverrides): Promise<[string]>;
        OPTION_TYPE(overrides?: CallOverrides): Promise<[number]>;
        RATES(overrides?: CallOverrides): Promise<[string]>;
        SUSD(overrides?: CallOverrides): Promise<[string]>;
        UNDERLYING_SYNTH_KEY(overrides?: CallOverrides): Promise<[string]>;
        VAULT_TOKEN(overrides?: CallOverrides): Promise<[string]>;
        addCollateral(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        authority(overrides?: CallOverrides): Promise<[string]>;
        closePosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, premiumAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        collateralization(overrides?: CallOverrides): Promise<[BigNumber]>;
        depositQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            string,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            id: BigNumber;
            user: string;
            depositedAmount: BigNumber;
            mintedTokens: BigNumber;
            requestedTime: BigNumber;
        }>;
        depositsPaused(overrides?: CallOverrides): Promise<[boolean]>;
        feeReceipient(overrides?: CallOverrides): Promise<[string]>;
        getLiveStrikes(overrides?: CallOverrides): Promise<[BigNumber[]]>;
        getTokenPrice(overrides?: CallOverrides): Promise<[BigNumber]>;
        getTotalSupply(overrides?: CallOverrides): Promise<[BigNumber]>;
        initiateDeposit(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        initiateWithdrawal(user: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        liveStrikes(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[BigNumber]>;
        minDepositAmount(overrides?: CallOverrides): Promise<[BigNumber]>;
        minDepositDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
        minWithdrawDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
        name(overrides?: CallOverrides): Promise<[string]>;
        nextQueuedDepositId(overrides?: CallOverrides): Promise<[BigNumber]>;
        nextQueuedWithdrawalId(overrides?: CallOverrides): Promise<[BigNumber]>;
        openPosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        owner(overrides?: CallOverrides): Promise<[string]>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        pauseDeposits(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        paused(overrides?: CallOverrides): Promise<[boolean]>;
        performanceFee(overrides?: CallOverrides): Promise<[BigNumber]>;
        positionDatas(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            positionId: BigNumber;
            amount: BigNumber;
            collateral: BigNumber;
            premiumCollected: BigNumber;
        }>;
        processDepositQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        processWithdrawalQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        queuedDepositHead(overrides?: CallOverrides): Promise<[BigNumber]>;
        queuedWithdrawalHead(overrides?: CallOverrides): Promise<[BigNumber]>;
        saveToken(token: PromiseOrValue<string>, receiver: PromiseOrValue<string>, amt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAuthority(newAuthority: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setCollateralization(_ratio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setDelays(_depositDelay: PromiseOrValue<BigNumberish>, _withdrawDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setFeeReceipient(_feeReceipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setFees(_performanceFee: PromiseOrValue<BigNumberish>, _withdrawalFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setMinDepositAmount(_minAmt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setOwner(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        settleOptions(strikeIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        totalFunds(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalPremiumCollected(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalQueuedDeposits(overrides?: CallOverrides): Promise<[BigNumber]>;
        totalQueuedWithdrawals(overrides?: CallOverrides): Promise<[BigNumber]>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unpauseDeposits(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        usedFunds(overrides?: CallOverrides): Promise<[BigNumber]>;
        withdrawalFee(overrides?: CallOverrides): Promise<[BigNumber]>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            string,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            id: BigNumber;
            user: string;
            withdrawnTokens: BigNumber;
            returnedAmount: BigNumber;
            requestedTime: BigNumber;
        }>;
    };
    GREEKS(overrides?: CallOverrides): Promise<string>;
    MARKET(overrides?: CallOverrides): Promise<string>;
    MARKET_WRAPPER(overrides?: CallOverrides): Promise<string>;
    OPTION_TOKEN(overrides?: CallOverrides): Promise<string>;
    OPTION_TYPE(overrides?: CallOverrides): Promise<number>;
    RATES(overrides?: CallOverrides): Promise<string>;
    SUSD(overrides?: CallOverrides): Promise<string>;
    UNDERLYING_SYNTH_KEY(overrides?: CallOverrides): Promise<string>;
    VAULT_TOKEN(overrides?: CallOverrides): Promise<string>;
    addCollateral(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    authority(overrides?: CallOverrides): Promise<string>;
    closePosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, premiumAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    collateralization(overrides?: CallOverrides): Promise<BigNumber>;
    depositQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        BigNumber,
        string,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        id: BigNumber;
        user: string;
        depositedAmount: BigNumber;
        mintedTokens: BigNumber;
        requestedTime: BigNumber;
    }>;
    depositsPaused(overrides?: CallOverrides): Promise<boolean>;
    feeReceipient(overrides?: CallOverrides): Promise<string>;
    getLiveStrikes(overrides?: CallOverrides): Promise<BigNumber[]>;
    getTokenPrice(overrides?: CallOverrides): Promise<BigNumber>;
    getTotalSupply(overrides?: CallOverrides): Promise<BigNumber>;
    initiateDeposit(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    initiateWithdrawal(user: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    liveStrikes(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    minDepositAmount(overrides?: CallOverrides): Promise<BigNumber>;
    minDepositDelay(overrides?: CallOverrides): Promise<BigNumber>;
    minWithdrawDelay(overrides?: CallOverrides): Promise<BigNumber>;
    name(overrides?: CallOverrides): Promise<string>;
    nextQueuedDepositId(overrides?: CallOverrides): Promise<BigNumber>;
    nextQueuedWithdrawalId(overrides?: CallOverrides): Promise<BigNumber>;
    openPosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    owner(overrides?: CallOverrides): Promise<string>;
    pause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    pauseDeposits(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    paused(overrides?: CallOverrides): Promise<boolean>;
    performanceFee(overrides?: CallOverrides): Promise<BigNumber>;
    positionDatas(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        positionId: BigNumber;
        amount: BigNumber;
        collateral: BigNumber;
        premiumCollected: BigNumber;
    }>;
    processDepositQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    processWithdrawalQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    queuedDepositHead(overrides?: CallOverrides): Promise<BigNumber>;
    queuedWithdrawalHead(overrides?: CallOverrides): Promise<BigNumber>;
    saveToken(token: PromiseOrValue<string>, receiver: PromiseOrValue<string>, amt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAuthority(newAuthority: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setCollateralization(_ratio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setDelays(_depositDelay: PromiseOrValue<BigNumberish>, _withdrawDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setFeeReceipient(_feeReceipient: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setFees(_performanceFee: PromiseOrValue<BigNumberish>, _withdrawalFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setMinDepositAmount(_minAmt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setOwner(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    settleOptions(strikeIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    totalFunds(overrides?: CallOverrides): Promise<BigNumber>;
    totalPremiumCollected(overrides?: CallOverrides): Promise<BigNumber>;
    totalQueuedDeposits(overrides?: CallOverrides): Promise<BigNumber>;
    totalQueuedWithdrawals(overrides?: CallOverrides): Promise<BigNumber>;
    unpause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unpauseDeposits(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    usedFunds(overrides?: CallOverrides): Promise<BigNumber>;
    withdrawalFee(overrides?: CallOverrides): Promise<BigNumber>;
    withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        BigNumber,
        string,
        BigNumber,
        BigNumber,
        BigNumber
    ] & {
        id: BigNumber;
        user: string;
        withdrawnTokens: BigNumber;
        returnedAmount: BigNumber;
        requestedTime: BigNumber;
    }>;
    callStatic: {
        GREEKS(overrides?: CallOverrides): Promise<string>;
        MARKET(overrides?: CallOverrides): Promise<string>;
        MARKET_WRAPPER(overrides?: CallOverrides): Promise<string>;
        OPTION_TOKEN(overrides?: CallOverrides): Promise<string>;
        OPTION_TYPE(overrides?: CallOverrides): Promise<number>;
        RATES(overrides?: CallOverrides): Promise<string>;
        SUSD(overrides?: CallOverrides): Promise<string>;
        UNDERLYING_SYNTH_KEY(overrides?: CallOverrides): Promise<string>;
        VAULT_TOKEN(overrides?: CallOverrides): Promise<string>;
        addCollateral(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        authority(overrides?: CallOverrides): Promise<string>;
        closePosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, premiumAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        collateralization(overrides?: CallOverrides): Promise<BigNumber>;
        depositQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            string,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            id: BigNumber;
            user: string;
            depositedAmount: BigNumber;
            mintedTokens: BigNumber;
            requestedTime: BigNumber;
        }>;
        depositsPaused(overrides?: CallOverrides): Promise<boolean>;
        feeReceipient(overrides?: CallOverrides): Promise<string>;
        getLiveStrikes(overrides?: CallOverrides): Promise<BigNumber[]>;
        getTokenPrice(overrides?: CallOverrides): Promise<BigNumber>;
        getTotalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        initiateDeposit(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        initiateWithdrawal(user: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        liveStrikes(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        minDepositAmount(overrides?: CallOverrides): Promise<BigNumber>;
        minDepositDelay(overrides?: CallOverrides): Promise<BigNumber>;
        minWithdrawDelay(overrides?: CallOverrides): Promise<BigNumber>;
        name(overrides?: CallOverrides): Promise<string>;
        nextQueuedDepositId(overrides?: CallOverrides): Promise<BigNumber>;
        nextQueuedWithdrawalId(overrides?: CallOverrides): Promise<BigNumber>;
        openPosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        owner(overrides?: CallOverrides): Promise<string>;
        pause(overrides?: CallOverrides): Promise<void>;
        pauseDeposits(overrides?: CallOverrides): Promise<void>;
        paused(overrides?: CallOverrides): Promise<boolean>;
        performanceFee(overrides?: CallOverrides): Promise<BigNumber>;
        positionDatas(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            positionId: BigNumber;
            amount: BigNumber;
            collateral: BigNumber;
            premiumCollected: BigNumber;
        }>;
        processDepositQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        processWithdrawalQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        queuedDepositHead(overrides?: CallOverrides): Promise<BigNumber>;
        queuedWithdrawalHead(overrides?: CallOverrides): Promise<BigNumber>;
        saveToken(token: PromiseOrValue<string>, receiver: PromiseOrValue<string>, amt: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setAuthority(newAuthority: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setCollateralization(_ratio: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setDelays(_depositDelay: PromiseOrValue<BigNumberish>, _withdrawDelay: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setFeeReceipient(_feeReceipient: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        setFees(_performanceFee: PromiseOrValue<BigNumberish>, _withdrawalFee: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setMinDepositAmount(_minAmt: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setOwner(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        settleOptions(strikeIds: PromiseOrValue<BigNumberish>[], overrides?: CallOverrides): Promise<void>;
        totalFunds(overrides?: CallOverrides): Promise<BigNumber>;
        totalPremiumCollected(overrides?: CallOverrides): Promise<BigNumber>;
        totalQueuedDeposits(overrides?: CallOverrides): Promise<BigNumber>;
        totalQueuedWithdrawals(overrides?: CallOverrides): Promise<BigNumber>;
        unpause(overrides?: CallOverrides): Promise<void>;
        unpauseDeposits(overrides?: CallOverrides): Promise<void>;
        usedFunds(overrides?: CallOverrides): Promise<BigNumber>;
        withdrawalFee(overrides?: CallOverrides): Promise<BigNumber>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            string,
            BigNumber,
            BigNumber,
            BigNumber
        ] & {
            id: BigNumber;
            user: string;
            withdrawnTokens: BigNumber;
            returnedAmount: BigNumber;
            requestedTime: BigNumber;
        }>;
    };
    filters: {
        'AddCollateral(uint256,uint256,uint256)'(strikeId?: null, positionId?: null, amount?: null): AddCollateralEventFilter;
        AddCollateral(strikeId?: null, positionId?: null, amount?: null): AddCollateralEventFilter;
        'AuthorityUpdated(address,address)'(user?: PromiseOrValue<string> | null, newAuthority?: PromiseOrValue<string> | null): AuthorityUpdatedEventFilter;
        AuthorityUpdated(user?: PromiseOrValue<string> | null, newAuthority?: PromiseOrValue<string> | null): AuthorityUpdatedEventFilter;
        'ClosePosition(uint256,uint256,uint256,uint256,uint256)'(strikeId?: null, positionId?: null, amount?: null, collateralWithdrawn?: null, premiumPaid?: null): ClosePositionEventFilter;
        ClosePosition(strikeId?: null, positionId?: null, amount?: null, collateralWithdrawn?: null, premiumPaid?: null): ClosePositionEventFilter;
        'InitiateDeposit(uint256,address,address,uint256)'(depositId?: null, depositor?: null, user?: null, amount?: null): InitiateDepositEventFilter;
        InitiateDeposit(depositId?: null, depositor?: null, user?: null, amount?: null): InitiateDepositEventFilter;
        'InitiateWithdrawal(uint256,address,address,uint256)'(withdrawalId?: null, withdrawer?: null, user?: null, tokens?: null): InitiateWithdrawalEventFilter;
        InitiateWithdrawal(withdrawalId?: null, withdrawer?: null, user?: null, tokens?: null): InitiateWithdrawalEventFilter;
        'OpenPosition(uint256,uint256,uint256,uint256,uint256,int256)'(strikeId?: null, positionId?: null, amount?: null, collateral?: null, premiumCollected?: null, putDelta?: null): OpenPositionEventFilter;
        OpenPosition(strikeId?: null, positionId?: null, amount?: null, collateral?: null, premiumCollected?: null, putDelta?: null): OpenPositionEventFilter;
        'OwnerUpdated(address,address)'(user?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnerUpdatedEventFilter;
        OwnerUpdated(user?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnerUpdatedEventFilter;
        'ProcessDeposit(uint256,address,uint256,uint256,uint256)'(depositId?: null, user?: null, amount?: null, tokens?: null, requestedTime?: null): ProcessDepositEventFilter;
        ProcessDeposit(depositId?: null, user?: null, amount?: null, tokens?: null, requestedTime?: null): ProcessDepositEventFilter;
        'ProcessWithdrawal(uint256,address,uint256,uint256,uint256)'(withdrawalId?: null, user?: null, tokens?: null, amount?: null, requestedTime?: null): ProcessWithdrawalEventFilter;
        ProcessWithdrawal(withdrawalId?: null, user?: null, tokens?: null, amount?: null, requestedTime?: null): ProcessWithdrawalEventFilter;
        'ProcessWithdrawalPartially(uint256,address,uint256,uint256,uint256)'(withdrawalId?: null, user?: null, tokens?: null, amount?: null, requestedTime?: null): ProcessWithdrawalPartiallyEventFilter;
        ProcessWithdrawalPartially(withdrawalId?: null, user?: null, tokens?: null, amount?: null, requestedTime?: null): ProcessWithdrawalPartiallyEventFilter;
        'SetDepositsPaused(address)'(account?: null): SetDepositsPausedEventFilter;
        SetDepositsPaused(account?: null): SetDepositsPausedEventFilter;
        'SetDepositsUnpaused(address)'(account?: null): SetDepositsUnpausedEventFilter;
        SetDepositsUnpaused(account?: null): SetDepositsUnpausedEventFilter;
        'SetPaused(address)'(account?: null): SetPausedEventFilter;
        SetPaused(account?: null): SetPausedEventFilter;
        'SetUnpaused(address)'(account?: null): SetUnpausedEventFilter;
        SetUnpaused(account?: null): SetUnpausedEventFilter;
        'SettleOption(uint256,uint256,uint256,uint256,int256,uint256)'(strikeId?: null, positionId?: null, amount?: null, totalCollateral?: null, totalPremium?: null, loss?: null): SettleOptionEventFilter;
        SettleOption(strikeId?: null, positionId?: null, amount?: null, totalCollateral?: null, totalPremium?: null, loss?: null): SettleOptionEventFilter;
        'UpdateCollateralization(uint256,uint256)'(oldCollateralization?: null, newCollateralization?: null): UpdateCollateralizationEventFilter;
        UpdateCollateralization(oldCollateralization?: null, newCollateralization?: null): UpdateCollateralizationEventFilter;
        'UpdateDelays(uint256,uint256,uint256,uint256)'(oldDepositDelay?: null, newDepositDelay?: null, oldWithdrawDelay?: null, newWithdrawDelay?: null): UpdateDelaysEventFilter;
        UpdateDelays(oldDepositDelay?: null, newDepositDelay?: null, oldWithdrawDelay?: null, newWithdrawDelay?: null): UpdateDelaysEventFilter;
        'UpdateFeeReceipient(address,address)'(oldFeeReceipient?: null, newFeeReceipient?: null): UpdateFeeReceipientEventFilter;
        UpdateFeeReceipient(oldFeeReceipient?: null, newFeeReceipient?: null): UpdateFeeReceipientEventFilter;
        'UpdateFees(uint256,uint256,uint256,uint256)'(oldPerf?: null, oldWithdraw?: null, newPerf?: null, newWithdraw?: null): UpdateFeesEventFilter;
        UpdateFees(oldPerf?: null, oldWithdraw?: null, newPerf?: null, newWithdraw?: null): UpdateFeesEventFilter;
        'UpdateMinDeposit(uint256,uint256)'(oldMinimum?: null, newMinimum?: null): UpdateMinDepositEventFilter;
        UpdateMinDeposit(oldMinimum?: null, newMinimum?: null): UpdateMinDepositEventFilter;
    };
    estimateGas: {
        GREEKS(overrides?: CallOverrides): Promise<BigNumber>;
        MARKET(overrides?: CallOverrides): Promise<BigNumber>;
        MARKET_WRAPPER(overrides?: CallOverrides): Promise<BigNumber>;
        OPTION_TOKEN(overrides?: CallOverrides): Promise<BigNumber>;
        OPTION_TYPE(overrides?: CallOverrides): Promise<BigNumber>;
        RATES(overrides?: CallOverrides): Promise<BigNumber>;
        SUSD(overrides?: CallOverrides): Promise<BigNumber>;
        UNDERLYING_SYNTH_KEY(overrides?: CallOverrides): Promise<BigNumber>;
        VAULT_TOKEN(overrides?: CallOverrides): Promise<BigNumber>;
        addCollateral(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        authority(overrides?: CallOverrides): Promise<BigNumber>;
        closePosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, premiumAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        collateralization(overrides?: CallOverrides): Promise<BigNumber>;
        depositQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        depositsPaused(overrides?: CallOverrides): Promise<BigNumber>;
        feeReceipient(overrides?: CallOverrides): Promise<BigNumber>;
        getLiveStrikes(overrides?: CallOverrides): Promise<BigNumber>;
        getTokenPrice(overrides?: CallOverrides): Promise<BigNumber>;
        getTotalSupply(overrides?: CallOverrides): Promise<BigNumber>;
        initiateDeposit(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        initiateWithdrawal(user: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        liveStrikes(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        minDepositAmount(overrides?: CallOverrides): Promise<BigNumber>;
        minDepositDelay(overrides?: CallOverrides): Promise<BigNumber>;
        minWithdrawDelay(overrides?: CallOverrides): Promise<BigNumber>;
        name(overrides?: CallOverrides): Promise<BigNumber>;
        nextQueuedDepositId(overrides?: CallOverrides): Promise<BigNumber>;
        nextQueuedWithdrawalId(overrides?: CallOverrides): Promise<BigNumber>;
        openPosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        pauseDeposits(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        paused(overrides?: CallOverrides): Promise<BigNumber>;
        performanceFee(overrides?: CallOverrides): Promise<BigNumber>;
        positionDatas(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        processDepositQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        processWithdrawalQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        queuedDepositHead(overrides?: CallOverrides): Promise<BigNumber>;
        queuedWithdrawalHead(overrides?: CallOverrides): Promise<BigNumber>;
        saveToken(token: PromiseOrValue<string>, receiver: PromiseOrValue<string>, amt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setAuthority(newAuthority: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setCollateralization(_ratio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setDelays(_depositDelay: PromiseOrValue<BigNumberish>, _withdrawDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setFeeReceipient(_feeReceipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setFees(_performanceFee: PromiseOrValue<BigNumberish>, _withdrawalFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setMinDepositAmount(_minAmt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        setOwner(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        settleOptions(strikeIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        totalFunds(overrides?: CallOverrides): Promise<BigNumber>;
        totalPremiumCollected(overrides?: CallOverrides): Promise<BigNumber>;
        totalQueuedDeposits(overrides?: CallOverrides): Promise<BigNumber>;
        totalQueuedWithdrawals(overrides?: CallOverrides): Promise<BigNumber>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        unpauseDeposits(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        usedFunds(overrides?: CallOverrides): Promise<BigNumber>;
        withdrawalFee(overrides?: CallOverrides): Promise<BigNumber>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        GREEKS(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MARKET(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        MARKET_WRAPPER(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        OPTION_TOKEN(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        OPTION_TYPE(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        RATES(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        SUSD(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        UNDERLYING_SYNTH_KEY(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        VAULT_TOKEN(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        addCollateral(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        authority(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        closePosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, premiumAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        collateralization(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        depositQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        depositsPaused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        feeReceipient(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getLiveStrikes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTokenPrice(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getTotalSupply(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        initiateDeposit(user: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        initiateWithdrawal(user: PromiseOrValue<string>, tokens: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        liveStrikes(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minDepositAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minDepositDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minWithdrawDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nextQueuedDepositId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nextQueuedWithdrawalId(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        openPosition(strikeId: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        pauseDeposits(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        paused(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        performanceFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        positionDatas(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        processDepositQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        processWithdrawalQueue(idCount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        queuedDepositHead(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        queuedWithdrawalHead(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        saveToken(token: PromiseOrValue<string>, receiver: PromiseOrValue<string>, amt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setAuthority(newAuthority: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setCollateralization(_ratio: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setDelays(_depositDelay: PromiseOrValue<BigNumberish>, _withdrawDelay: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setFeeReceipient(_feeReceipient: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setFees(_performanceFee: PromiseOrValue<BigNumberish>, _withdrawalFee: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setMinDepositAmount(_minAmt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        setOwner(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        settleOptions(strikeIds: PromiseOrValue<BigNumberish>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        totalFunds(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalPremiumCollected(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalQueuedDeposits(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        totalQueuedWithdrawals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        unpauseDeposits(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        usedFunds(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdrawalFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdrawalQueue(arg0: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}
