@soma-finance/core-contracts/SomaStarter/SomaStarter.d.ts

SOMA Finance core contracts

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 declare namespace AttoDecimal {
    type InstanceStruct = {
        mantissa: PromiseOrValue<BigNumberish>;
    };
    type InstanceStructOutput = [BigNumber] & {
        mantissa: BigNumber;
    };
}
export declare namespace SomaStarter {
    type PropsStruct = {
        issuanceLimit: PromiseOrValue<BigNumberish>;
        startsAt: PromiseOrValue<BigNumberish>;
        endsAt: PromiseOrValue<BigNumberish>;
        paymentToken: PromiseOrValue<string>;
        issuanceToken: PromiseOrValue<string>;
        fee: AttoDecimal.InstanceStruct;
        rate: AttoDecimal.InstanceStruct;
    };
    type PropsStructOutput = [
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string,
        AttoDecimal.InstanceStructOutput,
        AttoDecimal.InstanceStructOutput
    ] & {
        issuanceLimit: BigNumber;
        startsAt: BigNumber;
        endsAt: BigNumber;
        paymentToken: string;
        issuanceToken: string;
        fee: AttoDecimal.InstanceStructOutput;
        rate: AttoDecimal.InstanceStructOutput;
    };
    type IntervalStruct = {
        startsAt: PromiseOrValue<BigNumberish>;
        unlockingPart: AttoDecimal.InstanceStruct;
    };
    type IntervalStructOutput = [
        BigNumber,
        AttoDecimal.InstanceStructOutput
    ] & {
        startsAt: BigNumber;
        unlockingPart: AttoDecimal.InstanceStructOutput;
    };
    type AccountStateStruct = {
        limitIndex: PromiseOrValue<BigNumberish>;
        paymentSum: PromiseOrValue<BigNumberish>;
    };
    type AccountStateStructOutput = [BigNumber, BigNumber] & {
        limitIndex: BigNumber;
        paymentSum: BigNumber;
    };
    type ComplexAccountStateStruct = {
        issuanceAmount: PromiseOrValue<BigNumberish>;
        withdrawnIssuanceAmount: PromiseOrValue<BigNumberish>;
    };
    type ComplexAccountStateStructOutput = [BigNumber, BigNumber] & {
        issuanceAmount: BigNumber;
        withdrawnIssuanceAmount: BigNumber;
    };
    type LinearPropsStruct = {
        endsAt: PromiseOrValue<BigNumberish>;
        duration: PromiseOrValue<BigNumberish>;
    };
    type LinearPropsStructOutput = [BigNumber, BigNumber] & {
        endsAt: BigNumber;
        duration: BigNumber;
    };
    type StateStruct = {
        available: PromiseOrValue<BigNumberish>;
        issuance: PromiseOrValue<BigNumberish>;
        lockedPayments: PromiseOrValue<BigNumberish>;
        unlockedPayments: PromiseOrValue<BigNumberish>;
        nominatedOwner: PromiseOrValue<string>;
        owner: PromiseOrValue<string>;
        paymentLimits: PromiseOrValue<BigNumberish>[];
        requiredPrivileges: PromiseOrValue<BytesLike>;
    };
    type StateStructOutput = [
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string,
        string,
        BigNumber[],
        string
    ] & {
        available: BigNumber;
        issuance: BigNumber;
        lockedPayments: BigNumber;
        unlockedPayments: BigNumber;
        nominatedOwner: string;
        owner: string;
        paymentLimits: BigNumber[];
        requiredPrivileges: string;
    };
}
export interface SomaStarterInterface extends utils.Interface {
    functions: {
        "GLOBAL_ADMIN_ROLE()": FunctionFragment;
        "GLOBAL_WHITELIST_ROLE()": FunctionFragment;
        "LOCAL_ADMIN_ROLE()": FunctionFragment;
        "LOCAL_WHITELIST_ROLE()": FunctionFragment;
        "SOMA()": FunctionFragment;
        "TOKEN_RECOVERY_ROLE()": FunctionFragment;
        "acceptPoolOwnership(uint256)": FunctionFragment;
        "changeLimit(uint256,uint256,uint256)": FunctionFragment;
        "collectFee(uint256)": FunctionFragment;
        "collectedFees(address)": FunctionFragment;
        "createIntervalPool((uint256,uint256,uint256,address,address,(uint256),(uint256)),uint256,bytes32,address,(uint256),(uint256,(uint256))[])": FunctionFragment;
        "createLinearPool((uint256,uint256,uint256,address,address,(uint256),(uint256)),uint256,bytes32,address,(uint256),uint256)": FunctionFragment;
        "createPaymentLimit(uint256,uint256)": FunctionFragment;
        "createSimplePool((uint256,uint256,uint256,address,address,(uint256),(uint256)),uint256,bytes32,address)": FunctionFragment;
        "getRoleAdmin(bytes32)": FunctionFragment;
        "hasRole(bytes32,address)": FunctionFragment;
        "increaseIssuance(uint256,uint256)": FunctionFragment;
        "initialize()": FunctionFragment;
        "intervalPoolAccount(uint256,address)": FunctionFragment;
        "intervalPoolProps(uint256)": FunctionFragment;
        "linearPoolAccount(uint256,address)": FunctionFragment;
        "linearPoolProps(uint256)": FunctionFragment;
        "multicall(bytes[])": FunctionFragment;
        "nominateNewPoolOwner(uint256,address)": FunctionFragment;
        "pause()": FunctionFragment;
        "paused()": FunctionFragment;
        "poolAccount(uint256,address)": FunctionFragment;
        "poolProps(uint256)": FunctionFragment;
        "poolState(uint256)": FunctionFragment;
        "poolsCount()": FunctionFragment;
        "recoverTokens(address,address,uint256)": FunctionFragment;
        "setAccountsLimit(uint256,uint256,address[])": FunctionFragment;
        "supportsInterface(bytes4)": FunctionFragment;
        "swap(uint256,uint256)": FunctionFragment;
        "unlockInterval(uint256,uint256)": FunctionFragment;
        "unlockLinear(uint256)": FunctionFragment;
        "unpause()": FunctionFragment;
        "updateRequiredPrivileges(uint256,bytes32)": FunctionFragment;
        "withdrawFee(address,address)": FunctionFragment;
        "withdrawPayments(uint256)": FunctionFragment;
        "withdrawUnsold(uint256)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "GLOBAL_ADMIN_ROLE" | "GLOBAL_WHITELIST_ROLE" | "LOCAL_ADMIN_ROLE" | "LOCAL_WHITELIST_ROLE" | "SOMA" | "TOKEN_RECOVERY_ROLE" | "acceptPoolOwnership" | "changeLimit" | "collectFee" | "collectedFees" | "createIntervalPool" | "createLinearPool" | "createPaymentLimit" | "createSimplePool" | "getRoleAdmin" | "hasRole" | "increaseIssuance" | "initialize" | "intervalPoolAccount" | "intervalPoolProps" | "linearPoolAccount" | "linearPoolProps" | "multicall" | "nominateNewPoolOwner" | "pause" | "paused" | "poolAccount" | "poolProps" | "poolState" | "poolsCount" | "recoverTokens" | "setAccountsLimit" | "supportsInterface" | "swap" | "unlockInterval" | "unlockLinear" | "unpause" | "updateRequiredPrivileges" | "withdrawFee" | "withdrawPayments" | "withdrawUnsold"): FunctionFragment;
    encodeFunctionData(functionFragment: "GLOBAL_ADMIN_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "GLOBAL_WHITELIST_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "LOCAL_ADMIN_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "LOCAL_WHITELIST_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "SOMA", values?: undefined): string;
    encodeFunctionData(functionFragment: "TOKEN_RECOVERY_ROLE", values?: undefined): string;
    encodeFunctionData(functionFragment: "acceptPoolOwnership", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "changeLimit", values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "collectFee", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "collectedFees", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "createIntervalPool", values: [
        SomaStarter.PropsStruct,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<string>,
        AttoDecimal.InstanceStruct,
        SomaStarter.IntervalStruct[]
    ]): string;
    encodeFunctionData(functionFragment: "createLinearPool", values: [
        SomaStarter.PropsStruct,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<string>,
        AttoDecimal.InstanceStruct,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "createPaymentLimit", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "createSimplePool", values: [
        SomaStarter.PropsStruct,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BytesLike>,
        PromiseOrValue<string>
    ]): string;
    encodeFunctionData(functionFragment: "getRoleAdmin", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "hasRole", values: [PromiseOrValue<BytesLike>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "increaseIssuance", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "initialize", values?: undefined): string;
    encodeFunctionData(functionFragment: "intervalPoolAccount", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "intervalPoolProps", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "linearPoolAccount", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "linearPoolProps", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "multicall", values: [PromiseOrValue<BytesLike>[]]): string;
    encodeFunctionData(functionFragment: "nominateNewPoolOwner", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "pause", values?: undefined): string;
    encodeFunctionData(functionFragment: "paused", values?: undefined): string;
    encodeFunctionData(functionFragment: "poolAccount", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "poolProps", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "poolState", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "poolsCount", values?: undefined): string;
    encodeFunctionData(functionFragment: "recoverTokens", values: [
        PromiseOrValue<string>,
        PromiseOrValue<string>,
        PromiseOrValue<BigNumberish>
    ]): string;
    encodeFunctionData(functionFragment: "setAccountsLimit", values: [
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<BigNumberish>,
        PromiseOrValue<string>[]
    ]): string;
    encodeFunctionData(functionFragment: "supportsInterface", values: [PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "swap", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "unlockInterval", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "unlockLinear", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "unpause", values?: undefined): string;
    encodeFunctionData(functionFragment: "updateRequiredPrivileges", values: [PromiseOrValue<BigNumberish>, PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "withdrawFee", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "withdrawPayments", values: [PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "withdrawUnsold", values: [PromiseOrValue<BigNumberish>]): string;
    decodeFunctionResult(functionFragment: "GLOBAL_ADMIN_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "GLOBAL_WHITELIST_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "LOCAL_ADMIN_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "LOCAL_WHITELIST_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "SOMA", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "TOKEN_RECOVERY_ROLE", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "acceptPoolOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "changeLimit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "collectFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "collectedFees", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "createIntervalPool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "createLinearPool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "createPaymentLimit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "createSimplePool", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRoleAdmin", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "hasRole", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "increaseIssuance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "intervalPoolAccount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "intervalPoolProps", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "linearPoolAccount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "linearPoolProps", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "nominateNewPoolOwner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "paused", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolAccount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolProps", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolState", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "poolsCount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "recoverTokens", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setAccountsLimit", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unlockInterval", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unlockLinear", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unpause", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "updateRequiredPrivileges", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawPayments", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawUnsold", data: BytesLike): Result;
    events: {
        "AccountLimitChanged(uint256,address,uint256)": EventFragment;
        "FeeWithdrawn(address,uint256)": EventFragment;
        "ImmediatelyUnlockingPartUpdated(uint256,uint256)": EventFragment;
        "Initialized(uint8)": EventFragment;
        "IntervalCreated(uint256,uint256,uint256)": EventFragment;
        "IntervalPoolUnlocking(uint256,address,uint256)": EventFragment;
        "IssuanceIncreased(uint256,uint256)": EventFragment;
        "LinearPoolUnlocking(uint256,address,uint256)": EventFragment;
        "LinearUnlockingEndingTimestampUpdated(uint256,uint256)": EventFragment;
        "Paused(address)": EventFragment;
        "PaymentLimitChanged(uint256,uint256,uint256)": EventFragment;
        "PaymentLimitCreated(uint256,uint256,uint256)": EventFragment;
        "PaymentUnlocked(uint256,uint256,uint256)": EventFragment;
        "PaymentsWithdrawn(uint256,uint256)": EventFragment;
        "PoolCreated(uint8,address,address,uint256,uint256,uint256,uint256,uint256,uint256,uint256)": EventFragment;
        "PoolOwnerChanged(uint256,address)": EventFragment;
        "PoolOwnerNominated(uint256,address)": EventFragment;
        "PoolPrivilegesChanged(uint256,bytes32)": EventFragment;
        "Swap(uint256,address,uint256,uint256,uint256)": EventFragment;
        "TokensRecovered(address,address,uint256,address)": EventFragment;
        "Unpaused(address)": EventFragment;
        "UnsoldWithdrawn(uint256,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "AccountLimitChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "FeeWithdrawn"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ImmediatelyUnlockingPartUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "IntervalCreated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "IntervalPoolUnlocking"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "IssuanceIncreased"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LinearPoolUnlocking"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "LinearUnlockingEndingTimestampUpdated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Paused"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PaymentLimitChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PaymentLimitCreated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PaymentUnlocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PaymentsWithdrawn"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolCreated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolOwnerChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolOwnerNominated"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "PoolPrivilegesChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Swap"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TokensRecovered"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Unpaused"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UnsoldWithdrawn"): EventFragment;
}
export interface AccountLimitChangedEventObject {
    poolIndex: BigNumber;
    address_: string;
    limitIndex: BigNumber;
}
export declare type AccountLimitChangedEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber
], AccountLimitChangedEventObject>;
export declare type AccountLimitChangedEventFilter = TypedEventFilter<AccountLimitChangedEvent>;
export interface FeeWithdrawnEventObject {
    token: string;
    amount: BigNumber;
}
export declare type FeeWithdrawnEvent = TypedEvent<[
    string,
    BigNumber
], FeeWithdrawnEventObject>;
export declare type FeeWithdrawnEventFilter = TypedEventFilter<FeeWithdrawnEvent>;
export interface ImmediatelyUnlockingPartUpdatedEventObject {
    poolIndex: BigNumber;
    mantissa: BigNumber;
}
export declare type ImmediatelyUnlockingPartUpdatedEvent = TypedEvent<[
    BigNumber,
    BigNumber
], ImmediatelyUnlockingPartUpdatedEventObject>;
export declare type ImmediatelyUnlockingPartUpdatedEventFilter = TypedEventFilter<ImmediatelyUnlockingPartUpdatedEvent>;
export interface InitializedEventObject {
    version: number;
}
export declare type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
export declare type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
export interface IntervalCreatedEventObject {
    poolIndex: BigNumber;
    startsAt: BigNumber;
    unlockingPart: BigNumber;
}
export declare type IntervalCreatedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], IntervalCreatedEventObject>;
export declare type IntervalCreatedEventFilter = TypedEventFilter<IntervalCreatedEvent>;
export interface IntervalPoolUnlockingEventObject {
    poolIndex: BigNumber;
    account: string;
    amount: BigNumber;
}
export declare type IntervalPoolUnlockingEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber
], IntervalPoolUnlockingEventObject>;
export declare type IntervalPoolUnlockingEventFilter = TypedEventFilter<IntervalPoolUnlockingEvent>;
export interface IssuanceIncreasedEventObject {
    poolIndex: BigNumber;
    amount: BigNumber;
}
export declare type IssuanceIncreasedEvent = TypedEvent<[
    BigNumber,
    BigNumber
], IssuanceIncreasedEventObject>;
export declare type IssuanceIncreasedEventFilter = TypedEventFilter<IssuanceIncreasedEvent>;
export interface LinearPoolUnlockingEventObject {
    poolIndex: BigNumber;
    account: string;
    amount: BigNumber;
}
export declare type LinearPoolUnlockingEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber
], LinearPoolUnlockingEventObject>;
export declare type LinearPoolUnlockingEventFilter = TypedEventFilter<LinearPoolUnlockingEvent>;
export interface LinearUnlockingEndingTimestampUpdatedEventObject {
    poolIndex: BigNumber;
    timestamp: BigNumber;
}
export declare type LinearUnlockingEndingTimestampUpdatedEvent = TypedEvent<[
    BigNumber,
    BigNumber
], LinearUnlockingEndingTimestampUpdatedEventObject>;
export declare type LinearUnlockingEndingTimestampUpdatedEventFilter = TypedEventFilter<LinearUnlockingEndingTimestampUpdatedEvent>;
export interface PausedEventObject {
    account: string;
}
export declare type PausedEvent = TypedEvent<[string], PausedEventObject>;
export declare type PausedEventFilter = TypedEventFilter<PausedEvent>;
export interface PaymentLimitChangedEventObject {
    poolIndex: BigNumber;
    limitIndex: BigNumber;
    newLimit: BigNumber;
}
export declare type PaymentLimitChangedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], PaymentLimitChangedEventObject>;
export declare type PaymentLimitChangedEventFilter = TypedEventFilter<PaymentLimitChangedEvent>;
export interface PaymentLimitCreatedEventObject {
    poolIndex: BigNumber;
    limitIndex: BigNumber;
    limit: BigNumber;
}
export declare type PaymentLimitCreatedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], PaymentLimitCreatedEventObject>;
export declare type PaymentLimitCreatedEventFilter = TypedEventFilter<PaymentLimitCreatedEvent>;
export interface PaymentUnlockedEventObject {
    poolIndex: BigNumber;
    unlockedAmount: BigNumber;
    collectedFee: BigNumber;
}
export declare type PaymentUnlockedEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    BigNumber
], PaymentUnlockedEventObject>;
export declare type PaymentUnlockedEventFilter = TypedEventFilter<PaymentUnlockedEvent>;
export interface PaymentsWithdrawnEventObject {
    poolIndex: BigNumber;
    amount: BigNumber;
}
export declare type PaymentsWithdrawnEvent = TypedEvent<[
    BigNumber,
    BigNumber
], PaymentsWithdrawnEventObject>;
export declare type PaymentsWithdrawnEventFilter = TypedEventFilter<PaymentsWithdrawnEvent>;
export interface PoolCreatedEventObject {
    type_: number;
    paymentToken: string;
    issuanceToken: string;
    poolIndex: BigNumber;
    issuanceLimit: BigNumber;
    startsAt: BigNumber;
    endsAt: BigNumber;
    fee: BigNumber;
    rate: BigNumber;
    paymentLimit: BigNumber;
}
export declare type PoolCreatedEvent = TypedEvent<[
    number,
    string,
    string,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber,
    BigNumber
], PoolCreatedEventObject>;
export declare type PoolCreatedEventFilter = TypedEventFilter<PoolCreatedEvent>;
export interface PoolOwnerChangedEventObject {
    poolIndex: BigNumber;
    newOwner: string;
}
export declare type PoolOwnerChangedEvent = TypedEvent<[
    BigNumber,
    string
], PoolOwnerChangedEventObject>;
export declare type PoolOwnerChangedEventFilter = TypedEventFilter<PoolOwnerChangedEvent>;
export interface PoolOwnerNominatedEventObject {
    poolIndex: BigNumber;
    nominatedOwner: string;
}
export declare type PoolOwnerNominatedEvent = TypedEvent<[
    BigNumber,
    string
], PoolOwnerNominatedEventObject>;
export declare type PoolOwnerNominatedEventFilter = TypedEventFilter<PoolOwnerNominatedEvent>;
export interface PoolPrivilegesChangedEventObject {
    poolIndex: BigNumber;
    newRequiredPrivileges: string;
}
export declare type PoolPrivilegesChangedEvent = TypedEvent<[
    BigNumber,
    string
], PoolPrivilegesChangedEventObject>;
export declare type PoolPrivilegesChangedEventFilter = TypedEventFilter<PoolPrivilegesChangedEvent>;
export interface SwapEventObject {
    poolIndex: BigNumber;
    caller: string;
    requestedPaymentAmount: BigNumber;
    paymentAmount: BigNumber;
    issuanceAmount: BigNumber;
}
export declare type SwapEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber,
    BigNumber,
    BigNumber
], SwapEventObject>;
export declare type SwapEventFilter = TypedEventFilter<SwapEvent>;
export interface TokensRecoveredEventObject {
    token: string;
    to: string;
    amount: BigNumber;
    sender: string;
}
export declare type TokensRecoveredEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    string
], TokensRecoveredEventObject>;
export declare type TokensRecoveredEventFilter = TypedEventFilter<TokensRecoveredEvent>;
export interface UnpausedEventObject {
    account: string;
}
export declare type UnpausedEvent = TypedEvent<[string], UnpausedEventObject>;
export declare type UnpausedEventFilter = TypedEventFilter<UnpausedEvent>;
export interface UnsoldWithdrawnEventObject {
    poolIndex: BigNumber;
    amount: BigNumber;
}
export declare type UnsoldWithdrawnEvent = TypedEvent<[
    BigNumber,
    BigNumber
], UnsoldWithdrawnEventObject>;
export declare type UnsoldWithdrawnEventFilter = TypedEventFilter<UnsoldWithdrawnEvent>;
export interface SomaStarter extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: SomaStarterInterface;
    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: {
        GLOBAL_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;
        GLOBAL_WHITELIST_ROLE(overrides?: CallOverrides): Promise<[string]>;
        LOCAL_ADMIN_ROLE(overrides?: CallOverrides): Promise<[string]>;
        LOCAL_WHITELIST_ROLE(overrides?: CallOverrides): Promise<[string]>;
        SOMA(overrides?: CallOverrides): Promise<[string]>;
        TOKEN_RECOVERY_ROLE(overrides?: CallOverrides): Promise<[string]>;
        acceptPoolOwnership(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        changeLimit(poolIndex: PromiseOrValue<BigNumberish>, limitIndex: PromiseOrValue<BigNumberish>, newLimit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        collectFee(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        collectedFees(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        createIntervalPool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, immediatelyUnlockingPart: AttoDecimal.InstanceStruct, intervals: SomaStarter.IntervalStruct[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        createLinearPool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, immediatelyUnlockingPart: AttoDecimal.InstanceStruct, linearUnlockingEndsAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        createPaymentLimit(poolIndex: PromiseOrValue<BigNumberish>, limit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        createSimplePool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[string]>;
        hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        increaseIssuance(poolIndex: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        initialize(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        intervalPoolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            SomaStarter.AccountStateStructOutput,
            SomaStarter.ComplexAccountStateStructOutput,
            BigNumber
        ] & {
            state: SomaStarter.AccountStateStructOutput;
            complex: SomaStarter.ComplexAccountStateStructOutput;
            unlockedIntervalsCount: BigNumber;
        }>;
        intervalPoolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            SomaStarter.PropsStructOutput,
            AttoDecimal.InstanceStructOutput,
            SomaStarter.IntervalStructOutput[]
        ] & {
            props: SomaStarter.PropsStructOutput;
            immediatelyUnlockingPart: AttoDecimal.InstanceStructOutput;
            intervals: SomaStarter.IntervalStructOutput[];
        }>;
        linearPoolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            SomaStarter.AccountStateStructOutput,
            SomaStarter.ComplexAccountStateStructOutput,
            BigNumber
        ] & {
            state: SomaStarter.AccountStateStructOutput;
            complex: SomaStarter.ComplexAccountStateStructOutput;
            immediatelyUnlockedAmount: BigNumber;
        }>;
        linearPoolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            SomaStarter.PropsStructOutput,
            AttoDecimal.InstanceStructOutput,
            SomaStarter.LinearPropsStructOutput
        ] & {
            props: SomaStarter.PropsStructOutput;
            immediatelyUnlockingPart: AttoDecimal.InstanceStructOutput;
            linear: SomaStarter.LinearPropsStructOutput;
        }>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        nominateNewPoolOwner(poolIndex: PromiseOrValue<BigNumberish>, nominatedOwner_: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        pause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        paused(overrides?: CallOverrides): Promise<[boolean]>;
        poolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            number,
            SomaStarter.AccountStateStructOutput
        ] & {
            type_: number;
            state: SomaStarter.AccountStateStructOutput;
        }>;
        poolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            number,
            SomaStarter.PropsStructOutput
        ] & {
            type_: number;
            props: SomaStarter.PropsStructOutput;
        }>;
        poolState(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            SomaStarter.StateStructOutput
        ] & {
            state: SomaStarter.StateStructOutput;
        }>;
        poolsCount(overrides?: CallOverrides): Promise<[BigNumber]>;
        recoverTokens(token: PromiseOrValue<string>, to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        setAccountsLimit(poolIndex: PromiseOrValue<BigNumberish>, limitIndex: PromiseOrValue<BigNumberish>, accounts: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<[boolean]>;
        swap(poolIndex: PromiseOrValue<BigNumberish>, requestedPaymentAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unlockInterval(poolIndex: PromiseOrValue<BigNumberish>, intervalIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unlockLinear(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        unpause(overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        updateRequiredPrivileges(poolIndex: PromiseOrValue<BigNumberish>, newRequiredPrivileges: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawFee(token: PromiseOrValue<string>, to: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawPayments(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        withdrawUnsold(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
    };
    GLOBAL_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
    GLOBAL_WHITELIST_ROLE(overrides?: CallOverrides): Promise<string>;
    LOCAL_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
    LOCAL_WHITELIST_ROLE(overrides?: CallOverrides): Promise<string>;
    SOMA(overrides?: CallOverrides): Promise<string>;
    TOKEN_RECOVERY_ROLE(overrides?: CallOverrides): Promise<string>;
    acceptPoolOwnership(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    changeLimit(poolIndex: PromiseOrValue<BigNumberish>, limitIndex: PromiseOrValue<BigNumberish>, newLimit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    collectFee(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    collectedFees(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    createIntervalPool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, immediatelyUnlockingPart: AttoDecimal.InstanceStruct, intervals: SomaStarter.IntervalStruct[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    createLinearPool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, immediatelyUnlockingPart: AttoDecimal.InstanceStruct, linearUnlockingEndsAt: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    createPaymentLimit(poolIndex: PromiseOrValue<BigNumberish>, limit: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    createSimplePool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
    hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    increaseIssuance(poolIndex: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    initialize(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    intervalPoolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        SomaStarter.AccountStateStructOutput,
        SomaStarter.ComplexAccountStateStructOutput,
        BigNumber
    ] & {
        state: SomaStarter.AccountStateStructOutput;
        complex: SomaStarter.ComplexAccountStateStructOutput;
        unlockedIntervalsCount: BigNumber;
    }>;
    intervalPoolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        SomaStarter.PropsStructOutput,
        AttoDecimal.InstanceStructOutput,
        SomaStarter.IntervalStructOutput[]
    ] & {
        props: SomaStarter.PropsStructOutput;
        immediatelyUnlockingPart: AttoDecimal.InstanceStructOutput;
        intervals: SomaStarter.IntervalStructOutput[];
    }>;
    linearPoolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        SomaStarter.AccountStateStructOutput,
        SomaStarter.ComplexAccountStateStructOutput,
        BigNumber
    ] & {
        state: SomaStarter.AccountStateStructOutput;
        complex: SomaStarter.ComplexAccountStateStructOutput;
        immediatelyUnlockedAmount: BigNumber;
    }>;
    linearPoolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        SomaStarter.PropsStructOutput,
        AttoDecimal.InstanceStructOutput,
        SomaStarter.LinearPropsStructOutput
    ] & {
        props: SomaStarter.PropsStructOutput;
        immediatelyUnlockingPart: AttoDecimal.InstanceStructOutput;
        linear: SomaStarter.LinearPropsStructOutput;
    }>;
    multicall(data: PromiseOrValue<BytesLike>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    nominateNewPoolOwner(poolIndex: PromiseOrValue<BigNumberish>, nominatedOwner_: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    pause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    paused(overrides?: CallOverrides): Promise<boolean>;
    poolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        number,
        SomaStarter.AccountStateStructOutput
    ] & {
        type_: number;
        state: SomaStarter.AccountStateStructOutput;
    }>;
    poolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
        number,
        SomaStarter.PropsStructOutput
    ] & {
        type_: number;
        props: SomaStarter.PropsStructOutput;
    }>;
    poolState(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<SomaStarter.StateStructOutput>;
    poolsCount(overrides?: CallOverrides): Promise<BigNumber>;
    recoverTokens(token: PromiseOrValue<string>, to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    setAccountsLimit(poolIndex: PromiseOrValue<BigNumberish>, limitIndex: PromiseOrValue<BigNumberish>, accounts: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
    swap(poolIndex: PromiseOrValue<BigNumberish>, requestedPaymentAmount: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unlockInterval(poolIndex: PromiseOrValue<BigNumberish>, intervalIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unlockLinear(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    unpause(overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    updateRequiredPrivileges(poolIndex: PromiseOrValue<BigNumberish>, newRequiredPrivileges: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawFee(token: PromiseOrValue<string>, to: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawPayments(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    withdrawUnsold(poolIndex: PromiseOrValue<BigNumberish>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    callStatic: {
        GLOBAL_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
        GLOBAL_WHITELIST_ROLE(overrides?: CallOverrides): Promise<string>;
        LOCAL_ADMIN_ROLE(overrides?: CallOverrides): Promise<string>;
        LOCAL_WHITELIST_ROLE(overrides?: CallOverrides): Promise<string>;
        SOMA(overrides?: CallOverrides): Promise<string>;
        TOKEN_RECOVERY_ROLE(overrides?: CallOverrides): Promise<string>;
        acceptPoolOwnership(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        changeLimit(poolIndex: PromiseOrValue<BigNumberish>, limitIndex: PromiseOrValue<BigNumberish>, newLimit: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        collectFee(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        collectedFees(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        createIntervalPool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, immediatelyUnlockingPart: AttoDecimal.InstanceStruct, intervals: SomaStarter.IntervalStruct[], overrides?: CallOverrides): Promise<[
            boolean,
            BigNumber
        ] & {
            success: boolean;
            poolIndex: BigNumber;
        }>;
        createLinearPool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, immediatelyUnlockingPart: AttoDecimal.InstanceStruct, linearUnlockingEndsAt: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            boolean,
            BigNumber
        ] & {
            success: boolean;
            poolIndex: BigNumber;
        }>;
        createPaymentLimit(poolIndex: PromiseOrValue<BigNumberish>, limit: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        createSimplePool(props: SomaStarter.PropsStruct, paymentLimit: PromiseOrValue<BigNumberish>, requiredPrivileges: PromiseOrValue<BytesLike>, owner_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            boolean,
            BigNumber
        ] & {
            success: boolean;
            poolIndex: BigNumber;
        }>;
        getRoleAdmin(role: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<string>;
        hasRole(role: PromiseOrValue<BytesLike>, account: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        increaseIssuance(poolIndex: PromiseOrValue<BigNumberish>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<boolean>;
        initialize(overrides?: CallOverrides): Promise<void>;
        intervalPoolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            SomaStarter.AccountStateStructOutput,
            SomaStarter.ComplexAccountStateStructOutput,
            BigNumber
        ] & {
            state: SomaStarter.AccountStateStructOutput;
            complex: SomaStarter.ComplexAccountStateStructOutput;
            unlockedIntervalsCount: BigNumber;
        }>;
        intervalPoolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            SomaStarter.PropsStructOutput,
            AttoDecimal.InstanceStructOutput,
            SomaStarter.IntervalStructOutput[]
        ] & {
            props: SomaStarter.PropsStructOutput;
            immediatelyUnlockingPart: AttoDecimal.InstanceStructOutput;
            intervals: SomaStarter.IntervalStructOutput[];
        }>;
        linearPoolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            SomaStarter.AccountStateStructOutput,
            SomaStarter.ComplexAccountStateStructOutput,
            BigNumber
        ] & {
            state: SomaStarter.AccountStateStructOutput;
            complex: SomaStarter.ComplexAccountStateStructOutput;
            immediatelyUnlockedAmount: BigNumber;
        }>;
        linearPoolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            SomaStarter.PropsStructOutput,
            AttoDecimal.InstanceStructOutput,
            SomaStarter.LinearPropsStructOutput
        ] & {
            props: SomaStarter.PropsStructOutput;
            immediatelyUnlockingPart: AttoDecimal.InstanceStructOutput;
            linear: SomaStarter.LinearPropsStructOutput;
        }>;
        multicall(data: PromiseOrValue<BytesLike>[], overrides?: CallOverrides): Promise<string[]>;
        nominateNewPoolOwner(poolIndex: PromiseOrValue<BigNumberish>, nominatedOwner_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        pause(overrides?: CallOverrides): Promise<void>;
        paused(overrides?: CallOverrides): Promise<boolean>;
        poolAccount(poolIndex: PromiseOrValue<BigNumberish>, address_: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            number,
            SomaStarter.AccountStateStructOutput
        ] & {
            type_: number;
            state: SomaStarter.AccountStateStructOutput;
        }>;
        poolProps(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            number,
            SomaStarter.PropsStructOutput
        ] & {
            type_: number;
            props: SomaStarter.PropsStructOutput;
        }>;
        poolState(poolIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<SomaStarter.StateStructOutput>;
        poolsCount(overrides?: CallOverrides): Promise<BigNumber>;
        recoverTokens(token: PromiseOrValue<string>, to: PromiseOrValue<string>, amount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        setAccountsLimit(poolIndex: PromiseOrValue<BigNumberish>, limitIndex: PromiseOrValue<BigNumberish>, accounts: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<boolean>;
        supportsInterface(interfaceId: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
        swap(poolIndex: PromiseOrValue<BigNumberish>, requestedPaymentAmount: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber
        ] & {
            paymentAmount: BigNumber;
            issuanceAmount: BigNumber;
        }>;
        unlockInterval(poolIndex: PromiseOrValue<BigNumberish>, intervalIndex: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<BigNumber>;
        unlockLi