import * as _mysten_sui_js_client from '@mysten/sui.js/client';
import { CoinMetadata, SuiTransactionBlockResponse, DevInspectResults, CoinBalance, SuiClient, SuiObjectResponse } from '@mysten/sui.js/client';
import * as _mysten_sui_js_transactions from '@mysten/sui.js/transactions';
import { TransactionBlock, TransactionArgument } from '@mysten/sui.js/transactions';
import { DateTime, Duration } from 'luxon';
import { AxiosError, AxiosResponse } from 'axios';

type StreamEvent = {
    streamId: string;
    createdAt: Date;
    sender: string;
    txDigest: string;
    data: CreateStreamEventData | CancelStreamEventData | ClaimEventData | AutoClaimEventData | SetAutoClaimEventData;
};
interface CreateStreamEventData {
    type: 'create_stream';
    coinType: string;
    balance: bigint;
}
interface CancelStreamEventData {
    type: 'cancel_stream';
    coinType: string;
    withdrawAmount: bigint;
}
interface ClaimEventData {
    type: 'claim';
    coinType: string;
    claimAmount: bigint;
}
interface AutoClaimEventData {
    type: 'auto_claim';
    coinType: string;
    claimAmount: bigint;
}
interface SetAutoClaimEventData {
    type: 'set_auto_claim';
    enabled: boolean;
}

interface Paginated<T> {
    data: T[];
    pageNumber: number;
    pageSize: number;
    totalSize: number;
}
interface PaginationOptions {
    pageSize: number;
    pageNumber: number;
}

interface StreamRef {
    groupId: string;
    streamId: string;
    sender: string;
    recipient: string;
    coinType: string;
    createDate: string;
}
interface IBackend {
    getStreamGroupByGroupId(groupId: string): Promise<{
        groupId: string;
        streamIds: string[];
    }>;
    getIncomingStreams(recipient: string, options?: BackendIncomingStreamFilterOptions): Promise<StreamRef[]>;
    getOutgoingStreams(sender: string, options?: BackendOutgoingStreamFilterOptions): Promise<StreamRef[]>;
    getAllCoinTypes(address: string): Promise<string[]>;
    getAllRecipients(sender: string, options?: StreamFilterStatus): Promise<string[]>;
    getAllSenders(recipient: string, options?: StreamFilterStatus): Promise<string[]>;
    getStreamHistory(query: {
        streamId?: string;
        groupId?: string;
        pagination?: PaginationOptions;
    }): Promise<Paginated<StreamEvent>>;
}
type StreamFilterStatus = 'active' | 'inactive' | 'all';
interface BackendIncomingStreamFilterOptions {
    status?: StreamFilterStatus;
    coinType?: string | string[];
    sender?: string | string[];
}
interface BackendOutgoingStreamFilterOptions {
    status?: StreamFilterStatus;
    coinType?: string | string[];
    recipient?: string | string[];
}
type StreamEventDto = {
    streamId: string;
    createdAt: Date;
    sender: string;
    txDigest: string;
    data: StreamEventDataDto;
};
type StreamEventDataDto = CreateStreamEventDataDto | CancelStreamEventDataDto | ClaimEventDataDto | AutoClaimEventDataDto | SetAutoClaimEventDataDto;
interface CreateStreamEventDataDto {
    type: 'create_stream';
    coinType: string;
    balance: string;
}
interface CancelStreamEventDataDto {
    type: 'cancel_stream';
    coinType: string;
    withdrawAmount: string;
}
interface ClaimEventDataDto {
    type: 'claim';
    coinType: string;
    claimAmount: string;
}
interface AutoClaimEventDataDto {
    type: 'auto_claim';
    coinType: string;
    claimAmount: string;
}
interface SetAutoClaimEventDataDto {
    type: 'set_auto_claim';
    enabled: boolean;
}

interface SuiIterator<T> {
    next: () => Promise<T | undefined>;
    hasNext: () => Promise<boolean>;
}

declare enum StreamStatus {
    STREAMING = "STREAMING",
    COMPLETED = "COMPLETED",
    CANCELED = "CANCELED",
    SETTLED = "SETTLED"
}
interface IStream {
    streamId: string;
    type: 'Stream';
    groupId: string;
    creator: string;
    recipient: string;
    progress: StreamProgress;
    info: StreamInfo;
    refresh(): Promise<void>;
    historyEvents(options?: PaginationOptions): Promise<Paginated<StreamEvent>>;
    cancel(): Promise<TransactionBlock>;
    claim(): Promise<TransactionBlock>;
    setAutoClaim(enabled: boolean): Promise<TransactionBlock>;
    claimByProxy(): Promise<TransactionBlock>;
}
interface IStreamGroup {
    groupId: string;
    type: 'StreamGroup';
    streams: IStream[];
    creator: string;
    info: StreamGroupInfo;
    progress: StreamGroupProgress;
    refresh(): Promise<void>;
    historyEvents(options?: PaginationOptions): Promise<Paginated<StreamEvent>>;
}
type StreamInfo = StreamInfoCommon & {
    groupId: string;
    streamId: string;
    recipient: string;
    progress: StreamProgress;
    autoClaim: boolean;
};
type StreamGroupInfo = StreamInfoCommon & {
    groupId: string;
    streamIds: string[];
    progress: StreamGroupProgress;
};
interface StreamInfoCommon {
    name: string;
    creator: string;
    coinType: string;
    totalAmount: bigint;
    start: DateTime;
    end: DateTime;
    cancelable: boolean;
    cliffAmount: bigint;
    duration: Duration;
    interval: Duration;
    steps: bigint;
    nextReleaseDate: DateTime | null;
    nextReleaseAmount: bigint | null;
}
interface StreamGroupCommonInfo {
    name: string;
    groupId: string;
    creator: string;
    start: DateTime;
    interval: Duration;
    steps: bigint;
    cancelable: boolean;
}
interface StreamProgress {
    status: StreamStatus;
    total: bigint;
    streamed: bigint;
    claimed: bigint;
    claimable: bigint;
    canceled: bigint;
}
interface StreamGroupProgress {
    total: bigint;
    streamed: bigint;
    claimed: bigint;
    claimable: bigint;
    canceled: bigint;
}
interface StreamMetadata {
    groupId: string;
    name: string;
}

declare enum WalletType {
    single = "single",
    msafe = "msafe"
}
declare const GAS_OBJECT_SPEC = "txn.gas";
/**
 * IWallet is the adapted interface of wallet. Supports both single wallet and msafe.
 */
interface IWallet {
    type: WalletType;
    address(): Promise<string>;
    requestCoins(reqs: CoinRequest[]): Promise<CoinRequestResponse[]>;
}
/**
 * ISingleWallet is the raw interface of msafe account.
 * Need to adapt to IWallet interface
 */
interface IMSafeAccount {
    address(): Promise<string>;
    requestCoins(reqs: CoinRequest[]): Promise<CoinRequestResponse[]>;
}
/**
 * ISingleWallet is the raw interface of single signer wallet.
 * Need to adapt to IWallet interface
 */
interface ISingleWallet {
    address(): Promise<string>;
}
interface CoinRequest {
    coinType: string;
    amount: bigint;
}
interface CoinRequestResponse {
    primaryCoin: string;
    mergedCoins?: string[];
}

interface IMPayClient {
    helper: IMPayHelper;
    connectSingleWallet(wallet: ISingleWallet): void;
    connectMSafeAccount(msafe: IMSafeAccount): void;
    getStream(streamId: string): Promise<IStream>;
    getStreamGroup(streamGroupId: string): Promise<{
        groupId: string;
        streamGroup: IStreamGroup;
    }>;
    getIncomingStreams(query?: IncomingStreamQuery, pageSize?: number): Promise<IPagedStreamListIterator>;
    getOutgoingStreams(query?: OutgoingStreamQuery, pageSize?: number): Promise<IPagedStreamListIterator>;
    getCoinTypesForStreamFilter(): Promise<string[]>;
    getRecipientsForStreamFilter(options?: StreamFilterStatus): Promise<string[]>;
    getCreatorsForStreamFilter(options?: StreamFilterStatus): Promise<string[]>;
    createStream(info: CreateStreamInfo): Promise<TransactionBlock>;
}
interface PaymentWithFee {
    totalAmount: bigint;
    streamFeeAmount: bigint;
    flatFeeAmount: bigint;
}
interface MPayFees {
    createFeePercent: Fraction;
    claimFeePercent: Fraction;
    flatFeePerStream: bigint;
}
interface IMPayHelper {
    getBalance(address: string, coinType?: string | null): Promise<CoinBalanceWithMeta>;
    getAllBalance(address: string): Promise<CoinBalanceWithMeta[]>;
    getCoinMeta(coinType: string): Promise<CoinMetadata | undefined>;
    getStreamIdsFromCreateStreamResponse(res: SuiTransactionBlockResponse): string[];
    calculateCreateStreamFees(info: CreateStreamInfo): PaymentWithFee;
    feeParams(): MPayFees;
    calculateStreamAmount(input: {
        totalAmount: bigint;
        steps: bigint;
        cliff?: Fraction;
    }): CalculatedStreamAmount;
    calculateTimelineByInterval(input: {
        timeStart: DateTime;
        interval: Duration;
        steps: bigint;
    }): CalculatedTimeline;
    calculateTimelineByTotalDuration(input: {
        timeStart: DateTime;
        total: Duration;
        steps: bigint;
    }): CalculatedTimeline;
    simulateTransactionBlock(txb: TransactionBlock): Promise<DevInspectResults>;
}
type IPagedStreamListIterator = SuiIterator<(IStream | IStreamGroup)[]>;
interface IncomingStreamQuery {
    status?: StreamStatus | StreamStatus[];
    sender?: string | string[];
    coinType?: string | string[];
    claimable?: boolean;
}
interface OutgoingStreamQuery {
    status?: StreamStatus | StreamStatus[];
    recipient?: string | string[];
    coinType?: string | string[];
}
interface CreateStreamInfo {
    name: string;
    coinType: string;
    recipients: RecipientWithAmount[];
    interval: bigint;
    steps: bigint;
    startTimeMs: bigint;
    cancelable: boolean;
}
interface RecipientWithAmount {
    address: string;
    amountPerStep: bigint;
    cliffAmount: bigint;
}
interface CreateStreamInfoInternal {
    metadata: string;
    coinType: string;
    recipients: RecipientInfoInternal[];
    epochInterval: bigint;
    numberEpoch: bigint;
    startTime: bigint;
    cancelable: boolean;
}
interface RecipientInfoInternal {
    address: string;
    cliffAmount: bigint;
    amountPerEpoch: bigint;
}
interface CalculatedStreamAmount {
    realTotalAmount: bigint;
    cliffAmount: bigint;
    amountPerStep: bigint;
}
interface CalculatedTimeline {
    timeStart: DateTime;
    timeEnd: DateTime;
    interval: Duration;
    steps: bigint;
}
interface Fraction {
    numerator: bigint;
    denominator: bigint;
}
type CoinBalanceWithMeta = CoinBalance & {
    coinMeta: CoinMetadata | undefined;
};

declare enum RawStreamStatusEnum {
    OPEN = 0,
    COMPLETED = 1,
    CANCELED = 16,
    CANCELED_COMPLETED = 17
}
type RawStreamData = {
    coinType: string;
    balance: bigint;
    autoClaim: boolean;
    config: RawStreamConfig;
    status: RawStreamStatus;
};
interface RawStreamConfig {
    amountPerEpoch: bigint;
    cancelable: boolean;
    cliff: bigint;
    creator: string;
    epochInterval: bigint;
    metadata: string;
    recipient: string;
    timeStart: bigint;
    totalEpoch: bigint;
}
interface RawStreamStatus {
    status: RawStreamStatusEnum;
    epochClaimed: bigint;
    epochCanceled: bigint;
}

type StreamDecodedTransaction = DecodedCreateStream | DecodedSetAutoClaim | DecodedClaimStream | DecodedCancelStream | DecodedClaimByProxy | undefined;
declare enum StreamTransactionType {
    CREATE_STREAM = "CreateStream",
    SET_AUTO_CLAIM = "SetAutoClaim",
    CLAIM = "Claim",
    CLAIM_BY_PROXY = "ClaimByProxy",
    CANCEL = "Cancel"
}
interface DecodedCreateStream {
    type: StreamTransactionType.CREATE_STREAM;
    info: CreateStreamInfo;
    fees: PaymentWithFee;
    coinMerges: CoinMerge[];
}
interface CoinMerge {
    coinType: string;
    primary: string | 'GAS';
    merged?: string[];
}
interface DecodedSetAutoClaim {
    type: StreamTransactionType.SET_AUTO_CLAIM;
    streamId: string;
    enabled: boolean;
}
interface DecodedClaimStream {
    type: StreamTransactionType.CLAIM;
    streamId: string;
}
interface DecodedClaimByProxy {
    type: StreamTransactionType.CLAIM_BY_PROXY;
    streamId: string;
}
interface DecodedCancelStream {
    type: StreamTransactionType.CANCEL;
    streamId: string;
}

declare enum Env {
    local = "local",
    dev = "dev",
    stg = "stg",
    prev = "prev",
    prod = "prod"
}
interface EnvConfig {
    env: Env;
    rpc: SuiConfig;
    backend: BackendConfig;
    contract: ContractConfig;
}
interface EnvConfigOptions {
    rpc?: SuiConfig;
    backend?: BackendConfig;
    contract?: ContractConfig;
}
interface BackendConfig {
    url: string;
}
interface SuiConfig {
    url: string;
}
interface ContractConfig {
    contractId: string;
    roleObjId: string;
    vaultObjId: string;
    feeObjId: string;
}
declare const DEV_RPC_ENDPOINT = "https://fullnode.testnet.sui.io/";
declare const STG_RPC_ENDPOINT = "https://fullnode.testnet.sui.io/";
declare const PREV_RPC_ENDPOINT = "https://fullnode.mainnet.sui.io/";
declare const PROD_RPC_ENDPOINT = "https://fullnode.mainnet.sui.io/";
declare const DEV_BE_API = "https://sui-dev.m-safe.link";
declare const STG_BE_API = "https://sui-stage.m-safe.link";
declare const PREV_BE_API = "https://sui-preview.m-safe.link";
declare const PROD_BE_API = "https://sui.m-safe.link";
declare const CONTRACT_DEV: ContractConfig;
declare const CONTRACT_PROD: ContractConfig;
declare function getConfig(env: Env, options?: EnvConfigOptions): EnvConfig;

declare class Globals {
    signer: IWallet | undefined;
    readonly suiClient: SuiClient;
    readonly envConfig: EnvConfig;
    _backend?: IBackend;
    constructor(envConfig: EnvConfig);
    static new(env: Env, options?: EnvConfigOptions): Globals;
    get walletType(): WalletType | 'disconnected';
    get backend(): IBackend;
    set backend(b: IBackend);
    connectWallet(wallet: IWallet): void;
    disconnect(): void;
    get wallet(): IWallet;
    walletAddress(): Promise<string>;
}

declare class MPayHelper implements IMPayHelper {
    readonly globals: Globals;
    private readonly coinMetaHelper;
    private readonly createStreamHelper;
    constructor(globals: Globals);
    getStreamIdsFromCreateStreamResponse(res: SuiTransactionBlockResponse): string[];
    calculateCreateStreamFees(info: CreateStreamInfo): PaymentWithFee;
    feeParams(): MPayFees;
    calculateStreamAmount(input: {
        totalAmount: bigint;
        steps: bigint;
        cliff?: Fraction;
    }): CalculatedStreamAmount;
    calculateTimelineByInterval(input: {
        timeStart: DateTime;
        interval: Duration;
        steps: bigint;
    }): CalculatedTimeline;
    calculateTimelineByTotalDuration(input: {
        timeStart: DateTime;
        total: Duration;
        steps: bigint;
    }): CalculatedTimeline;
    getBalance(address: string, coinType?: string | null): Promise<{
        coinType: string;
        coinMeta: CoinMetadata | undefined;
        coinObjectCount: number;
        totalBalance: string;
        lockedBalance: Record<string, string>;
    }>;
    getAllBalance(address: string): Promise<{
        coinType: string;
        coinMeta: CoinMetadata | undefined;
        coinObjectCount: number;
        totalBalance: string;
        lockedBalance: Record<string, string>;
    }[]>;
    getCoinMeta(coinType: string | null | undefined): Promise<CoinMetadata | undefined>;
    simulateTransactionBlock(txb: TransactionBlock): Promise<DevInspectResults>;
    private validateStreamAmount;
    private validateTimeline;
}

declare class Stream implements IStream {
    readonly globals: Globals;
    readonly streamId: string;
    rawData: RawStreamData;
    private readonly streamContract;
    readonly type = "Stream";
    constructor(globals: Globals, streamId: string, rawData: RawStreamData);
    static new(globals: Globals, streamId: string): Promise<Stream>;
    static fromObjectData(globals: Globals, streamId: string, data: SuiObjectResponse): Stream;
    get info(): StreamInfo;
    get groupCommonInfo(): StreamGroupCommonInfo;
    refresh(): Promise<void>;
    refreshWithData(data: SuiObjectResponse): void;
    historyEvents(pagination?: PaginationOptions): Promise<Paginated<StreamEvent>>;
    cancel(): Promise<TransactionBlock>;
    claim(): Promise<TransactionBlock>;
    setAutoClaim(enabled: boolean): Promise<TransactionBlock>;
    claimByProxy(): Promise<TransactionBlock>;
    get wallet(): IWallet;
    get client(): _mysten_sui_js_client.SuiClient;
    get coinType(): string;
    get progress(): StreamProgress;
    get balance(): bigint;
    get autoClaim(): boolean;
    get amountPerEpoch(): bigint;
    get cancelable(): boolean;
    get cliff(): bigint;
    get creator(): string;
    get interval(): Duration;
    get groupId(): string;
    get name(): string;
    get recipient(): string;
    get timeStart(): DateTime;
    get duration(): Duration;
    get timeEnd(): DateTime;
    get totalSteps(): bigint;
    get claimable(): bigint;
    get nextReleaseDate(): DateTime | null;
    get nextReleaseAmount(): bigint | null;
    get streamStatus(): StreamStatus;
    get streamedAmount(): bigint;
    get claimedAmount(): bigint;
    get currentEpoch(): bigint;
    get totalAmount(): bigint;
    get isCanceled(): boolean;
    get canceledAmount(): bigint;
    private static fetchStreamData;
    static parseRawStreamData(streamId: string, res: SuiObjectResponse): RawStreamData;
}

declare class StreamGroup implements IStreamGroup {
    readonly globals: Globals;
    readonly streams: Stream[];
    readonly type = "StreamGroup";
    constructor(globals: Globals, streams: Stream[]);
    static new(globals: Globals, ids: string[]): Promise<StreamGroup>;
    static newFromObjectResponse(globals: Globals, ids: string[], responses: SuiObjectResponse[]): Promise<StreamGroup>;
    static checkStreamGroup(streams: Stream[]): boolean;
    refresh(): Promise<void>;
    get groupId(): string;
    get creator(): string;
    get info(): StreamGroupInfo;
    get progress(): StreamGroupProgress;
    historyEvents(pagination?: PaginationOptions): Promise<Paginated<StreamEvent>>;
    private static parseGroupStreams;
}

declare class MPayClient implements IMPayClient {
    readonly globals: Globals;
    readonly helper: MPayHelper;
    constructor(env: Env, options?: EnvConfigOptions);
    connectSingleWallet(wallet: ISingleWallet): void;
    connectMSafeAccount(msafe: IMSafeAccount): void;
    createStream(info: CreateStreamInfo): Promise<TransactionBlock>;
    getStream(streamId: string): Promise<Stream>;
    getStreamGroup(streamGroupId: string): Promise<{
        groupId: string;
        streamGroup: StreamGroup;
    }>;
    getIncomingStreams(query?: IncomingStreamQuery, pageSize?: number): Promise<IPagedStreamListIterator>;
    getOutgoingStreams(query?: OutgoingStreamQuery, pageSize?: number): Promise<IPagedStreamListIterator>;
    getCoinTypesForStreamFilter(): Promise<string[]>;
    getRecipientsForStreamFilter(options?: StreamFilterStatus): Promise<string[]>;
    getCreatorsForStreamFilter(options?: StreamFilterStatus): Promise<string[]>;
    get wallet(): IWallet;
    private builder;
}

declare const MAX_U64: bigint;
declare const TIME_ROUND_UNIT = 1000;
declare function roundDateTime(date: DateTime | number | bigint): DateTime;
declare function roundDuration(duration: Duration | number | bigint): Duration;
declare function addPrefix(s: string, prefix: string): string;

declare function parseResponseData(response: AxiosError | AxiosResponse): any;

declare class MSafeAccountAdapter implements IWallet {
    private readonly msafe;
    constructor(msafe: IMSafeAccount);
    get type(): WalletType;
    address(): Promise<string>;
    requestCoins(reqs: CoinRequest[]): Promise<CoinRequestResponse[]>;
}

/**
 * SingleWalletAdapter adapts ISingleWallet to IWallet
 */
declare class SingleWalletAdapter implements IWallet {
    private readonly singleWallet;
    private readonly suiClient;
    constructor(singleWallet: ISingleWallet, suiClient: SuiClient);
    get type(): WalletType;
    address(): Promise<string>;
    requestCoins(reqs: CoinRequest[]): Promise<CoinRequestResponse[]>;
    requestCoin(req: CoinRequest): Promise<CoinRequestResponse>;
}

declare class StreamTransactionDecoder {
    static decodeTransaction(globals: Globals, txb: TransactionBlock): StreamDecodedTransaction;
}

type MoveNumber = bigint | string | number;
type Ref<T> = T | ResultRef;
type ObjectId = string;
declare class MoveObject {
    readonly object: string;
    constructor(object: string);
    moveArg(txb: TransactionBlock): _mysten_sui_js_transactions.TransactionObjectArgument;
}
declare class ObjectVector {
    readonly objects: string[];
    constructor(objects: string[]);
    moveArgs(txb: TransactionBlock): _mysten_sui_js_transactions.TransactionResult;
}
declare class ResultRef {
    readonly result: TransactionArgument & TransactionArgument[];
    constructor(result: TransactionArgument & TransactionArgument[]);
    moveArg(): ({
        index: number;
        kind: "Input";
        type?: "object" | undefined;
        value?: any;
    } | {
        type: "pure";
        index: number;
        kind: "Input";
        value?: any;
    } | {
        kind: "GasCoin";
    } | {
        index: number;
        kind: "Result";
    } | {
        index: number;
        resultIndex: number;
        kind: "NestedResult";
    }) & ({
        index: number;
        kind: "Input";
        type?: "object" | undefined;
        value?: any;
    } | {
        type: "pure";
        index: number;
        kind: "Input";
        value?: any;
    } | {
        kind: "GasCoin";
    } | {
        index: number;
        kind: "Result";
    } | {
        index: number;
        resultIndex: number;
        kind: "NestedResult";
    })[];
}

declare class BaseContract {
    readonly moduleName: string;
    readonly config: ContractConfig;
    readonly globals: Globals;
    constructor(moduleName: string, config: ContractConfig, globals: Globals);
    addContractCall(txb: TransactionBlock, input: {
        method: string;
        arguments: any[];
        typeArgs?: string[];
    }): TransactionBlock;
    private addTransactionBlock;
    makeObject(object: Ref<ObjectId>): ResultRef | MoveObject;
    vaultObject(): MoveObject;
    roleObject(): MoveObject;
    feeObject(): MoveObject;
    clockObject(): MoveObject;
}

declare class FeeContract extends BaseContract {
    readonly config: ContractConfig;
    readonly globals: Globals;
    static ModuleName: string;
    static MethodName: {
        readonly set_streaming_fee: "set_streaming_fee";
        readonly set_claim_fee: "set_claim_fee";
        readonly set_streaming_flat_fee: "set_streaming_flat_fee";
        readonly streaming_flat_fee: "streaming_flat_fee";
        readonly streaming_fee: "streaming_fee";
        readonly claim_fee: "claim_fee";
        readonly fee_denominator: "fee_denominator";
    };
    constructor(config: ContractConfig, globals: Globals);
    setStreamingFee(txb: TransactionBlock, createFeeNumerator: MoveNumber): TransactionBlock;
    setStreamingFlatFee(txb: TransactionBlock, flatFee: MoveNumber): TransactionBlock;
    setClaimFee(txb: TransactionBlock, claimFee: MoveNumber): TransactionBlock;
    streamingFee(txb: TransactionBlock, amount: MoveNumber): TransactionBlock;
    claimFee(txb: TransactionBlock, amount: MoveNumber): TransactionBlock;
    feeDenominator(txb: TransactionBlock): TransactionBlock;
}

declare class RoleContract extends BaseContract {
    readonly config: ContractConfig;
    readonly globals: Globals;
    static ModuleName: string;
    static MethodName: {
        readonly set_collector: "set_collector";
        readonly transfer_admin: "transfer_admin";
        readonly accept_admin: "accept_admin";
        readonly get_collector: "get_collector";
        readonly get_pending_admin: "get_pending_admin";
        readonly get_admin: "get_admin";
    };
    constructor(config: ContractConfig, globals: Globals);
    setCollector(txb: TransactionBlock, newCollector: string): TransactionBlock;
    transferAdmin(txb: TransactionBlock, newAdmin: string): TransactionBlock;
    acceptAdmin(txb: TransactionBlock): TransactionBlock;
    getCollector(txb: TransactionBlock): TransactionBlock;
    getPendingAdmin(txb: TransactionBlock): TransactionBlock;
    getAdmin(txb: TransactionBlock): TransactionBlock;
}

declare class StreamContract extends BaseContract {
    readonly config: ContractConfig;
    readonly globals: Globals;
    static ModuleName: string;
    static MethodName: {
        readonly create_stream: "create_stream";
        readonly set_auto_claim: "set_auto_claim";
        readonly cancel_stream: "cancel_stream";
        readonly claim_stream: "claim_stream";
        readonly claim_stream_by_proxy: "claim_stream_by_proxy";
        readonly stream_current_epoch: "stream_current_epoch";
        readonly now_milli_seconds: "now_milli_seconds";
    };
    constructor(config: ContractConfig, globals: Globals);
    createStream(txb: TransactionBlock, input: {
        paymentCoin: Ref<ObjectId>;
        flatFeeCoin: Ref<ObjectId>;
        metadata: string;
        recipient: string;
        timeStart: Ref<MoveNumber>;
        cliff: Ref<MoveNumber>;
        epochInterval: Ref<MoveNumber>;
        numEpoch: Ref<MoveNumber>;
        amountPerEpoch: Ref<MoveNumber>;
        cancelable: boolean;
        coinType: string;
    }): TransactionBlock;
    setAutoClaim(txb: TransactionBlock, input: {
        streamId: Ref<ObjectId>;
        enabled: boolean;
        coinType: string;
    }): TransactionBlock;
    cancelStream(txb: TransactionBlock, input: {
        streamId: Ref<ObjectId>;
        coinType: string;
    }): TransactionBlock;
    claimStream(txb: TransactionBlock, input: {
        streamId: Ref<ObjectId>;
        coinType: string;
    }): TransactionBlock;
    claimStreamByProxy(txb: TransactionBlock, input: {
        streamId: Ref<ObjectId>;
        coinType: string;
    }): TransactionBlock;
    get createStreamTarget(): string;
    get setAutoClaimTarget(): string;
    get cancelStreamTarget(): string;
    get claimStreamTarget(): string;
    get claimStreamByProxyTarget(): string;
}

declare class VaultContract extends BaseContract {
    readonly config: ContractConfig;
    readonly globals: Globals;
    static ModuleName: string;
    static MethodName: {
        readonly withdraw_fee: "withdraw_fee";
        readonly balance: "balance";
    };
    constructor(config: ContractConfig, globals: Globals);
    withdrawFee(txb: TransactionBlock, coinType: string): TransactionBlock;
    balance(txb: TransactionBlock, coinType: string): TransactionBlock;
}

type index_FeeContract = FeeContract;
declare const index_FeeContract: typeof FeeContract;
type index_MoveNumber = MoveNumber;
type index_MoveObject = MoveObject;
declare const index_MoveObject: typeof MoveObject;
type index_ObjectId = ObjectId;
type index_ObjectVector = ObjectVector;
declare const index_ObjectVector: typeof ObjectVector;
type index_Ref<T> = Ref<T>;
type index_ResultRef = ResultRef;
declare const index_ResultRef: typeof ResultRef;
type index_RoleContract = RoleContract;
declare const index_RoleContract: typeof RoleContract;
type index_StreamContract = StreamContract;
declare const index_StreamContract: typeof StreamContract;
type index_VaultContract = VaultContract;
declare const index_VaultContract: typeof VaultContract;
declare namespace index {
  export {
    index_FeeContract as FeeContract,
    index_MoveNumber as MoveNumber,
    index_MoveObject as MoveObject,
    index_ObjectId as ObjectId,
    index_ObjectVector as ObjectVector,
    index_Ref as Ref,
    index_ResultRef as ResultRef,
    index_RoleContract as RoleContract,
    index_StreamContract as StreamContract,
    index_VaultContract as VaultContract,
  };
}

export { AutoClaimEventData, AutoClaimEventDataDto, BackendConfig, BackendIncomingStreamFilterOptions, BackendOutgoingStreamFilterOptions, CONTRACT_DEV, CONTRACT_PROD, CalculatedStreamAmount, CalculatedTimeline, CancelStreamEventData, CancelStreamEventDataDto, ClaimEventData, ClaimEventDataDto, CoinBalanceWithMeta, CoinMerge, CoinRequest, CoinRequestResponse, index as Contract, ContractConfig, CreateStreamEventData, CreateStreamEventDataDto, CreateStreamInfo, CreateStreamInfoInternal, DEV_BE_API, DEV_RPC_ENDPOINT, DecodedCancelStream, DecodedClaimByProxy, DecodedClaimStream, DecodedCreateStream, DecodedSetAutoClaim, Env, EnvConfig, EnvConfigOptions, Fraction, GAS_OBJECT_SPEC, Globals, IBackend, IMPayClient, IMPayHelper, IMSafeAccount, IPagedStreamListIterator, ISingleWallet, IStream, IStreamGroup, IWallet, IncomingStreamQuery, MAX_U64, MPayClient, MPayFees, MSafeAccountAdapter, OutgoingStreamQuery, PREV_BE_API, PREV_RPC_ENDPOINT, PROD_BE_API, PROD_RPC_ENDPOINT, Paginated, PaginationOptions, PaymentWithFee, RawStreamConfig, RawStreamData, RawStreamStatus, RawStreamStatusEnum, RecipientInfoInternal, RecipientWithAmount, STG_BE_API, STG_RPC_ENDPOINT, SetAutoClaimEventData, SetAutoClaimEventDataDto, SingleWalletAdapter, Stream, StreamDecodedTransaction, StreamEvent, StreamEventDataDto, StreamEventDto, StreamFilterStatus, StreamGroup, StreamGroupCommonInfo, StreamGroupInfo, StreamGroupProgress, StreamInfo, StreamInfoCommon, StreamMetadata, StreamProgress, StreamRef, StreamStatus, StreamTransactionDecoder, StreamTransactionType, SuiConfig, TIME_ROUND_UNIT, WalletType, addPrefix, getConfig, parseResponseData, roundDateTime, roundDuration };