import * as _mysten_sui_js_cryptography from '@mysten/sui.js/cryptography';
import { PublicKey, SignatureScheme, SerializedSignature } from '@mysten/sui.js/cryptography';
import { MultiSigPublicKey } from '@mysten/sui.js/multisig';
import { SuiClient, CoinStruct, TransactionBlockData, GasCostSummary, DryRunTransactionBlockResponse, CoinMetadata, SuiObjectData, SuiTransactionBlockResponse } from '@mysten/sui.js/client';
import { TransactionBlock } from '@mysten/sui.js/transactions';
import { Buffer } from 'buffer';
import { PendingTransaction, HistoryTransaction, TransactionIntention } from '@msafe/sui3-model/core';

declare enum StreamStatus {
    Streaming = "streaming",
    Completed = "completed",
    Canceled = "canceled",
    Settled = "settled"
}
declare enum StreamEventType {
    Create = "create_stream",
    Cancel = "cancel_stream",
    Claim = "claim",
    AutoClaim = "auto_claim",
    SetAutoClaim = "set_auto_claim"
}
declare enum StreamTransactionType {
    CREATE_STREAM = "CreateStream",
    SET_AUTO_CLAIM = "SetAutoClaim",
    CLAIM = "Claim",
    CLAIM_BY_PROXY = "ClaimByProxy",
    CANCEL = "Cancel"
}
interface CancelStreamIntentionData {
    streamId: string;
}
interface ClaimByProxyStreamIntentionData {
    streamId: string;
}
interface ClaimStreamIntentionData {
    streamId: string;
}
interface CreateStreamIntentionData {
    name: string;
    coinType: string;
    recipients: RecipientWithAmount[];
    interval: bigint;
    steps: bigint;
    startTimeMs: bigint;
    cancelable: boolean;
}
interface RecipientWithAmount {
    address: string;
    amountPerStep: bigint;
    cliffAmount: bigint;
}
interface SetAutoClaimIntentionData {
    streamId: string;
    enabled: boolean;
}

declare enum RawStreamStatusEnum {
    OPEN = 0,
    COMPLETED = 1,
    CANCELED = 16,
    CANCELED_COMPLETED = 17
}
interface EventStreamConfig {
    amount_per_epoch: string;
    cancelable: boolean;
    cliff: string;
    creator: string;
    epoch_interval: string;
    metadata: string;
    recipient: string;
    time_start: string;
    total_epoch: string;
}
interface EventStreamStatus {
    epoch_canceled: string;
    epoch_claimed: string;
    status: RawStreamStatusEnum;
}
interface EventCreateStream {
    id: string;
    balance: string;
    coin: string;
    config: EventStreamConfig;
    status: EventStreamStatus;
}

interface StreamMetadata {
    groupId: string;
    name: string;
}

declare class StreamHelper {
    static decodeMetadata(metaStr: string): StreamMetadata;
    static parseStreamStatus(rawStatus: number): StreamStatus;
    static fullStreamEventType(packageId: string, eventType: StreamEventType): string;
}

type SuiAddress = string;
type MessageType = 'TransactionBlock' | 'Personal';
declare enum UserMSafeStatus {
    active = "ACTIVE",
    pending = "PENDING",
    ignored = "IGNORED"
}
interface IOwnerWithWeight {
    address: string;
    weight: number;
}
type IOwnerWithWeightPK = IOwnerWithWeight & {
    publicKey: PublicKey;
};
interface PublicKeyWithWeight {
    publicKey: PublicKey;
    weight: number;
}
interface PublicKeyWithSchema {
    publicKeyEncoded: string;
    schema: SignatureScheme;
}
interface MSafeConfig extends MultiSigConfig {
    name: string;
    description?: string;
}
interface MultiSigConfig {
    threshold: number;
    ownersWithWeight: PublicKeyWithWeight[];
    creationNonce: number | undefined;
}
interface CoinTransferIntention {
    recipient: SuiAddress;
    coinType: string;
    amount: string;
}
interface ObjectTransferIntention {
    receiver: SuiAddress;
    objectType: string;
    objectId: string;
}
interface PlainPayloadIntention {
    payload: string;
}
interface RejectIntention {
    txType: 'Reject';
}
interface CoinTransferPayload {
    coinType: string;
    to: string;
    amount: bigint;
}
interface ObjectTransferPayload {
    objectId: string;
    objectVersion: string;
    objectType: string;
    to: string;
}
declare const TransactionDefaultApplication = "msafe-core";
declare enum TransactionType {
    Assets = "Assets",
    NFT = "NFT",
    Account = "Account",
    Swap = "Swap",
    Staking = "Staking",
    Bridge = "Bridge",
    Ending = "Ending",
    Stream = "Stream",
    Other = "Other"
}
declare const TransactionSubTypes: {
    assets: {
        coin: {
            send: string;
            receive: string;
        };
        object: {
            send: string;
            receive: string;
        };
    };
    account: {
        creation: string;
    };
    others: {
        plain: string;
    };
    stream: {
        create: StreamTransactionType;
        claim: StreamTransactionType;
        claimByProxy: StreamTransactionType;
        setAutoClaim: StreamTransactionType;
        cancel: StreamTransactionType;
    };
};
declare enum OpAddressBookType {
    Delete = "delete",
    Upsert = "upsert"
}
type UpdateAddressBookEntry = DeleteAddressBookEntry | UpsertAddressBookEntry;
interface DeleteAddressBookEntry {
    opType: OpAddressBookType.Delete;
    address: string;
}
interface UpsertAddressBookEntry {
    opType: OpAddressBookType.Upsert;
    address: string;
    addressName: string;
    remark?: string;
}
type JWTToken = string;
declare enum IntentionBuildStatus {
    Success = "SUCCESS",
    Failed = "FAILED",
    New = "NEW"
}
interface IMSafeConfig {
    address: string;
    name: string;
    description?: string;
    owners: IOwnerWithWeightPK[];
    threshold: number;
    creationNonce: number;
}
type TxIntention = CoinTransferIntention | ObjectTransferIntention | PlainPayloadIntention | any;
interface AggregatedAssets {
    coinType: string;
    sum: bigint;
    isReceive: boolean;
}

/**
 * Represents a raw multi-signature account.
 */
declare class MultiSigAccount {
    private readonly config;
    publicKey: MultiSigPublicKey;
    constructor(config: MultiSigConfig);
    get address(): string;
    get publicKeys(): {
        weight: number;
        publicKey: _mysten_sui_js_cryptography.PublicKey;
    }[];
    combinePartialSignatures(signatures: SerializedSignature[]): SerializedSignature;
    private toMultisigPublicKey;
    private makeNoncePublicKey;
    private static validate;
}

declare const AccountConfig: {
    minWeight: number;
    maxWeight: number;
    maxOwnerWithNonce: number;
    maxOwnerWithoutNonce: number;
    nonce: {
        prefix: string;
        weight: number;
        maxSize: number;
    };
};
declare const SUI_COIN = "0x2::sui::SUI";
declare const UNKNOWN_COIN = "UNKNOWN COIN";

/**
 * Get public key from signature
 * @param message message
 * @param type message type
 * @param signature signature
 * @returns public key
 */
declare function getPublicKeyFromSignature(message: Uint8Array, type: MessageType, signature: SerializedSignature): Promise<PublicKey>;
/**
 * Get public key from personal signature
 * @param message message
 * @param signature  signature
 * @returns public key
 */
declare function getPublicKeyFromPersonalSignature(message: string, signature: SerializedSignature): Promise<PublicKey>;
/**
 * Verify signature
 * @param message message
 * @param type message type
 * @param signature signature
 * @param address target address
 */
declare function verifySignature(message: Uint8Array, type: MessageType, signature: SerializedSignature, address: SuiAddress): Promise<boolean>;
/**
 * Verify personal signature
 * @param message message
 * @param signature signatured
 * @param address target address
 * @returns
 */
declare function verifyPersonalSignature(message: string, signature: SerializedSignature, address: SuiAddress): Promise<boolean>;
/**
 * Verify transaction signature
 * @param payload transaction payload
 * @param signature signature
 * @param address target address
 */
declare function verifyTransactionSignature(payload: Uint8Array, signature: SerializedSignature, address: SuiAddress): Promise<boolean>;
/**
 * Serialize public key
 * @Deprecated: Use PublicKeySerde.ser
 * @param publicKey public key object
 * @returns public key with scheme
 */
declare function serializePublicKey(publicKey: PublicKey): PublicKeyWithSchema;
/**
 * Deserialize public key
 * @Deprecated: Use PublicKeySerde.de
 * @param publicKey public key string
 * @param scheme public key scheme
 * @returns public key object
 */
declare function deserializePublicKey(publicKey: string | Uint8Array, scheme: SignatureScheme): PublicKey;
declare class PublicKeyManager {
    private readonly client;
    private cachedKeys;
    constructor(client: SuiClient);
    /**
     * Get address public key from cache or from chain
     * @param address target address
     */
    getPublicKey(address: SuiAddress): Promise<PublicKey>;
    /**
     * Batch get public keys from addresses
     * @param addresses addresses
     */
    getPublicKeys(addresses: SuiAddress[]): Promise<PublicKey[]>;
    private fetchPublicKey;
    private fetchPublicKeyFromChain;
    private getAddressFromSignature;
}

/**
 * Create a msafe login message to sign
 *
 * @Deprecated: Use SigningMessageHelper instead
 * @returns login message
 */
declare function createLoginMessage(): string;
declare function createLoginMessageWithTimestamp(timestamp: string): string;
/**
 * decode login message timestamp
 *
 * @Deprecated: Use SigningMessageHelper instead
 *
 * @param message login message
 * @returns match timestamp
 */
declare function decodeLoginMessageTimestamp(message: string): string;
/**
 * @Deprecated: Use SigningMessageHelper instead
 * Create a msafe creation message to sign
 * @param address msafe address
 * @returns msafe account create message
 */
declare function createAccountCreationMessage(address: string): string;
/**
 * @Deprecated: Use SigningMessageHelper instead
 * Create propose intention sign message
 * @param intention intention
 * @param sn sequence number
 * @returns intention sign message
 */
declare function createProposeIntentionMessage(intention: any, sn: number): string;

declare function serializeIntention(intention: any): string;
/**
 * Get all owner coins
 * @param client sui client
 * @param owner owner address
 * @param coinType coin type
 * @returns coins
 */
declare function getAllCoins(client: SuiClient, owner: SuiAddress, coinType: string | undefined): Promise<CoinStruct[]>;
declare function deserializeIntention(value: string): TxIntention;
declare function buildRejectTxb(sender: SuiAddress): TransactionBlock;
declare function buildCoinTransferTxb(client: SuiClient, intention: CoinTransferIntention, sender: SuiAddress): Promise<TransactionBlock>;
declare function buildSuiCoinTransferTxb(intention: CoinTransferIntention, sender: SuiAddress): TransactionBlock;
declare function buildOtherCoinTransferTxb(client: SuiClient, intention: CoinTransferIntention, sender: SuiAddress): Promise<TransactionBlock>;
declare function buildObjectTransferTxb(client: SuiClient, intention: ObjectTransferIntention, sender: SuiAddress): Promise<TransactionBlock>;

/**
 * Check if the given addresses are same address
 * @param address1 address 1
 * @param address2 address 2
 * @returns if two addresses are equal
 */
declare function isSameAddress(address1: string, address2: string): boolean;
/**
 * Check if the given structs are same
 * @param struct1 struct 1
 * @param struct2 struct 2
 * @returns if two struct are equal
 */
declare function isSuiStructEqual(struct1: string, struct2: string): boolean;
/**
 * Check if is coin object type
 * @param struct struct
 * @returns if is coin object type
 */
declare function isCoinObjectType(struct: string): boolean;
/**
 * Convert a string to Buffer object
 * @param s string
 * @returns
 */
declare function stringToBuffer(s: string): Buffer;
/**
 * Convert buffer to hex string
 * @param buffer buffer
 * @returns hex string
 */
declare function Uint8ArrayToHex(buffer: Uint8Array): string;
/**
 * Convert hex string to buffer
 * @param hex hex string
 * @returns buffer
 */
declare function HexToUint8Array(hex: string): Uint8Array;

/**
 * @deprecated Use TxParser instead.
 */
declare class TransactionResponseDataDecoder {
    private transactionData;
    constructor(transactionData: TransactionBlockData);
    isCoinTransfer(): boolean;
    isObjectTransfer(): boolean;
    coinTransferInfo(suiClient: SuiClient): Promise<CoinTransferPayload>;
    objectTransferInfo(suiClient: SuiClient): Promise<ObjectTransferPayload>;
    static decodeObjectInput(inputs: any, param: {
        index: number;
    }): {
        objectId: string;
        version: number;
    };
    static decodePureInput(inputs: any, param: {
        index: number;
    }): any;
}

declare enum AddressBookMode {
    Unknown = "unknown",
    Local = "local",
    Remote = "remote"
}
declare const ADDRESS_BOOK_SETTING_KEY = "address-book-mode";

interface IPageOptions {
    page: number;
    limit: number;
}
interface IPagedMeta {
    page: number;
    limit: number;
    total: number;
}
interface IPagedResult<T> {
    data: T[];
    meta: IPagedMeta;
}

interface IUpdateAddressBookReq {
    updates: IUpdateAddressBookEntry[];
    signature: SerializedSignature;
}
interface IUpdateAddressBookEntry {
    opType: OpAddressBookType;
    address: string;
    addressName?: string;
    remark?: string;
}
type IGetAddressBookResult = IPagedResult<IGetAddressBookResultEntry>;
interface IGetAddressBookResultEntry {
    address: string;
    addressName: string;
    remark?: string;
    updatedAt: Date;
}
interface IGetAddressBookModeResult {
    mode: AddressBookMode;
}
interface ISetAddressBookModeReq {
    mode: AddressBookMode;
}

interface IAuthLoginReq {
    readonly message: string;
    readonly signature: SerializedSignature;
    readonly address: string;
    readonly walletType: string;
    readonly mockAddress?: string;
}
interface IAuthLoginResp {
    accessToken: string;
    refreshToken: string;
}

type ICreateMSafeReq = IMSafeConfigDtoInternal & {
    signature: SerializedSignature;
};
type IMSafeInfoResp = IMSafeConfigDtoInternal & {
    address: string;
};
interface IMSafeConfigDtoInternal {
    name: string;
    description?: string;
    owners: IOwnerWithWeightPKEncodedWithStatus[];
    threshold: number;
    creationNonce: number;
}
interface IUpdateMSafeStatusReq {
    msafeAddress: string;
    status: UserMSafeStatus;
}
interface IUserInfoResp {
    address: string;
    publicKey: string;
    schema: string;
    creationNonce: number;
}
type IOwnerWithWeightPKEncoded = IOwnerWithWeight & IPublicKeyEncoded;
type IOwnerWithWeightPKEncodedWithStatus = IOwnerWithWeightPKEncoded & {
    status: string;
};
interface IPublicKeyEncoded {
    publicKeyEncoded: string;
    schema: string;
}
interface IGetMSafeQuery {
    msafeAddress: string;
    page?: string;
    limit?: string;
}
interface IGetMSafesQuery {
    status?: UserMSafeStatus;
    page?: string;
    limit?: string;
}
interface IGetPublicKeyBatchQuery {
    userAddressList: string[];
}
type IGetPublicKeyBatchResp = (IPublicKeyEncoded | undefined | null)[];

declare enum TransactionStatus {
    SUCCESS = "SUCCESS",
    FAILED = "FAILED",
    REJECTED = "REJECTED"
}
declare enum TransactionIntentionStatus {
    NEW = "NEW",
    SUCCESS = "SUCCESS",
    FAILED = "FAILED"
}
interface IMSafeAddressRequest {
    msafeAddress: string;
}
interface IGetSequenceNumberRequest extends IMSafeAddressRequest {
}
interface IGetPendingTransactionRequest extends IMSafeAddressRequest {
}
interface IGetHistoryTransactionsRequest extends IMSafeAddressRequest {
    page?: string;
    limit?: string;
}
interface IGetIntentionsRequest extends IGetHistoryTransactionsRequest {
}
interface GetPendingTransactionResponse {
    pending?: PendingTransactionItem;
    reject?: PendingTransactionItem;
}
interface GetHistoryTransactionsResponse extends IPagedResult<HistoryTransactionItem> {
}
interface GetTransactionIntentionsResponse extends IPagedResult<TransactionIntentionItem> {
}
interface IProposeIntentionRequest {
    application: string;
    txType: TransactionType;
    txSubType: string;
    intention: TxIntention;
    sequenceNumber: number;
    msafeAddress: string;
    signature: SerializedSignature;
}
interface IProposeIntentionAndBuildAndVoteRequest extends IGasOption {
    application: string;
    txType: TransactionType;
    txSubType: string;
    intention: TxIntention;
    sequenceNumber: number;
    msafeAddress: string;
    signature: SerializedSignature;
    forceBuild: boolean;
    payload: string;
    digest: string;
}
interface ISimulateIntentionRequest {
    application: string;
    txType: TransactionType;
    txSubType: string;
    intention: TxIntention;
}
interface SimulateIntentionResponse {
    success: boolean;
    message: string;
    gasPrice: bigint;
    gasUsed: GasCostSummary;
    result: DryRunTransactionBlockResponse;
}
interface ISkipIntentionRequest extends IMSafeAddressRequest {
}
type IBuildTransactionRequest = IMSafeAddressRequest & IGasOption & {
    forceBuild: boolean;
};
interface IVoteTransactionRequest {
    msafeAddress: string;
    digest: string;
    signature: string;
}
type IRejectTransactionRequest = IVoteTransactionRequest & IGasOption & {
    forceBuild: boolean;
};
type PendingTransactionItem = Omit<PendingTransaction, 'id' | 'updateAt' | 'isRejectTx'> & {
    application: string;
    txType: TransactionType;
    txSubType: string;
    intention?: TxIntention;
    votes: PendingVote[];
};
type HistoryTransactionItem = HistoryTransactionSendItem | HistoryTransactionReceiveItem;
type HistoryTransactionSendItem = Omit<HistoryTransaction, 'id' | 'updateAt'> & {
    application: string;
    txType: TransactionType;
    txSubType: string;
    isSendTx: true;
    approveVotes: HistoryVote[];
    rejectVotes: HistoryVote[];
    intention: CoinTransferIntentionItem | ObjectTransferIntentionItem | PlainPayloadIntentionItem | OtherIntentionItem;
};
type HistoryTransactionReceiveItem = {
    application: string;
    txType: TransactionType;
    txSubType: string;
    isSendTx: false;
    type: 'ReceiveCoin' | 'ReceiveObject' | 'CreateAccount';
    digest: string;
    sender: string;
    executedAt: Date;
    data: CoinReceiveType | ObjectReceiveType | CreateAccountType;
};
type CoinTransferIntentionItem = {
    txType: TransactionType.Assets;
    txSubType: 'SendCoin';
} & CoinTransferIntention;
type ObjectTransferIntentionItem = {
    txType: TransactionType.Assets;
    txSubType: 'SendObject';
} & ObjectTransferIntention;
type PlainPayloadIntentionItem = {
    txType: TransactionType.Other;
    txSubType: 'PlainPayload';
} & PlainPayloadIntention;
type OtherIntentionItem = {
    txType: TransactionType;
    txSubType: string;
} & TxIntention;
type CoinReceiveType = {
    sender: string;
    receiver: string;
    coinType: string;
    amount: string;
};
type ObjectReceiveType = {
    sender: string;
    receiver: string;
    objectType: string;
    objectId: string;
};
type CreateAccountType = IMSafeInfoResp;
type TransactionIntentionItem = Omit<TransactionIntention, 'id' | 'updateAt'> & {
    intentionId: string;
    intention: TxIntention;
};
type PendingVote = HistoryVote & {
    signature: string;
};
interface HistoryVote {
    userAddress: SuiAddress;
    timestamp: Date;
}
interface IGasOption {
    gasPrice: bigint;
    gasBudget: bigint;
}

declare const API_SIGNATURE_KEY_HEADER = "Authorization-Signature";
interface ISetCheckpointReq {
    checkpoint: string;
}
interface IGetCheckpointResp {
    checkpoint: string;
}
interface IExistMSafeResp {
    exist: boolean;
}
interface IProcessTransactionRequest {
    digest: string;
    status: TransactionStatus;
    executedAt: Date;
}
interface IProcessCoinTransferRequest {
    digest: string;
    msafeAddress: string;
    coinType: string;
    amount: string;
    sender: string;
    receiver: string;
    executedAt: Date;
}
interface IProcessObjectTransferRequest {
    digest: string;
    msafeAddress: string;
    objectId: string;
    objectVersion: string;
    objectType: string;
    sender: string;
    receiver: string;
    executedAt: Date;
}

interface ICreateReportReq {
    reportType: string;
    summary: string;
    description?: string;
    userAddress?: string;
    msafeAddress?: string;
    stack?: string;
    contactType: string;
    contact: string;
}

interface IValueItem {
    timestamp: number;
    value: number;
}
interface IDashboardNetWorth {
    oneWeek: IValueItem[];
    oneMonth: IValueItem[];
    total: IValueItem[];
}
interface ICoinPrice {
    symbol: string;
    price: string;
}
interface IGetDashboardResp {
    coinPriceList: ICoinPrice[];
    netWorth: IDashboardNetWorth;
}
interface IGetDashboardReq {
    msafeAddress: string;
}

/**
 * MessageHelper defines messages to be signed by single signer wallet
 */
declare class SigningMessageHelper {
    static createMSafeMessage(msafeAddress: string): string;
    static loginMessageWithTimestamp(timestamp: string): string;
    static loginMessage(): string;
    static decodeLoginMessageTimestamp(message: string): string;
    static proposeIntentionMessage(input: {
        intention: any;
        sn: number;
        msafeAddress: string;
    }): string;
    static updateAddressBookMessage(updates: UpdateAddressBookEntry[]): string;
    private static sortObjectKeys;
}

/**
 * Class representing a Public Key Serializer/Deserializer.
 */
declare class PublicKeySerde {
    /**
     * Serializes a public key.
     *
     * @param {PublicKey} publicKey - The public key to serialize.
     * @return {Object} An object containing the serialized public key and the signature scheme.
     *   - publicKeyEncoded: The serialized public key encoded in base64.
     *   - scheme: The signature scheme corresponding to the public key flag.
     */
    static ser(publicKey: PublicKey): {
        publicKeyEncoded: string;
        schema: SignatureScheme;
    };
    /**
     * Generates a public key object based on the provided input.
     *
     * @param {object} input - The input object containing the public key and the signature scheme.
     * @param {string | Uint8Array} input.publicKey - The public key.
     * @param {SignatureScheme} input.schema - The signature scheme.
     *
     * @return {PublicKey} - The generated public key object.
     *
     * @throws {Error} - If the signature scheme is unsupported.
     */
    static de(input: {
        publicKeyEncoded: string | Uint8Array;
        schema: string;
    }): PublicKey;
}

declare enum SyncField {
    checkpoint = "syncCheckpoint"
}
declare class SyncApiService {
    signPayload<T>(input: {
        payload: T;
        secretKey: string;
    }): {
        payload: T;
        signature: string;
    };
    verify<T>(input: {
        payload: T;
        secretKey: string;
        signature: string;
    }): boolean;
}

declare enum IssueType {
    Bug = "Bug",
    Feature = "Feature",
    Support = "Support",
    Auto = "Auto"
}
declare enum ContactType {
    Email = "Email",
    Telegram = "Telegram",
    Discord = "Discord",
    Phone = "Phone"
}
interface Report {
    reportType: IssueType;
    summary: string;
    description?: string;
    userAddress?: string;
    msafeAddress?: string;
    stack?: string;
    contactType: ContactType;
    contact: string;
}

declare class CoinHelper {
    private _client;
    private _queryCache;
    private _coinMetaReg;
    constructor(client: SuiClient);
    getCoinMeta(coinType: string): Promise<CoinMetadata | undefined>;
    private queryCoinMeta;
}
declare const COIN_TYPE_ARG_REGEX: RegExp;
declare class Coin {
    static isCoin(type: string | undefined | null): boolean;
    static getCoinType(type: string): string;
    static getBalance(data: SuiObjectData): bigint | undefined;
}

interface ParsedObjectTransfer {
    type: 'object_transfer';
    from: string;
    to: string;
    objects: {
        objectId: string;
        version: string;
        type: string;
    }[];
}
interface ParsedCoinTransfer {
    type: 'coin_transfer';
    from: string;
    to: string;
    amount: string;
    coinType: string;
}
type ParsedTransaction = ParsedCoinTransfer | ParsedObjectTransfer;

declare class TxParser {
    static fetchAndParse(suiClient: SuiClient, digest: string): Promise<ParsedTransaction | undefined>;
    static parse(resp: SuiTransactionBlockResponse): ParsedTransaction | undefined;
    static parseCoinTransfer(resp: SuiTransactionBlockResponse): ParsedCoinTransfer | undefined;
    static parseObjectTransfer(resp: SuiTransactionBlockResponse): ParsedObjectTransfer | undefined;
    private static getOwnedObject;
    private static getPureAddress;
    private static getInput;
}

export { ADDRESS_BOOK_SETTING_KEY, API_SIGNATURE_KEY_HEADER, AccountConfig, AddressBookMode, type AggregatedAssets, COIN_TYPE_ARG_REGEX, type CancelStreamIntentionData, type ClaimByProxyStreamIntentionData, type ClaimStreamIntentionData, Coin, CoinHelper, type CoinReceiveType, type CoinTransferIntention, type CoinTransferIntentionItem, type CoinTransferPayload, ContactType, type CreateAccountType, type CreateStreamIntentionData, type DeleteAddressBookEntry, type EventCreateStream, type EventStreamConfig, type EventStreamStatus, type GetHistoryTransactionsResponse, type GetPendingTransactionResponse, type GetTransactionIntentionsResponse, HexToUint8Array, type HistoryTransactionItem, type HistoryTransactionReceiveItem, type HistoryTransactionSendItem, type HistoryVote, type IAuthLoginReq, type IAuthLoginResp, type IBuildTransactionRequest, type ICoinPrice, type ICreateMSafeReq, type ICreateReportReq, type IDashboardNetWorth, type IExistMSafeResp, type IGasOption, type IGetAddressBookModeResult, type IGetAddressBookResult, type IGetAddressBookResultEntry, type IGetCheckpointResp, type IGetDashboardReq, type IGetDashboardResp, type IGetHistoryTransactionsRequest, type IGetIntentionsRequest, type IGetMSafeQuery, type IGetMSafesQuery, type IGetPendingTransactionRequest, type IGetPublicKeyBatchQuery, type IGetPublicKeyBatchResp, type IGetSequenceNumberRequest, type IMSafeAddressRequest, type IMSafeConfig, type IMSafeConfigDtoInternal, type IMSafeInfoResp, type IOwnerWithWeight, type IOwnerWithWeightPK, type IOwnerWithWeightPKEncoded, type IOwnerWithWeightPKEncodedWithStatus, type IPageOptions, type IPagedMeta, type IPagedResult, type IProcessCoinTransferRequest, type IProcessObjectTransferRequest, type IProcessTransactionRequest, type IProposeIntentionAndBuildAndVoteRequest, type IProposeIntentionRequest, type IPublicKeyEncoded, type IRejectTransactionRequest, type ISetAddressBookModeReq, type ISetCheckpointReq, type ISimulateIntentionRequest, type ISkipIntentionRequest, type IUpdateAddressBookEntry, type IUpdateAddressBookReq, type IUpdateMSafeStatusReq, type IUserInfoResp, type IValueItem, type IVoteTransactionRequest, IntentionBuildStatus, IssueType, type JWTToken, type MSafeConfig, type MessageType, MultiSigAccount, type MultiSigConfig, type ObjectReceiveType, type ObjectTransferIntention, type ObjectTransferIntentionItem, type ObjectTransferPayload, OpAddressBookType, type OtherIntentionItem, type ParsedCoinTransfer, type ParsedObjectTransfer, type ParsedTransaction, type PendingTransactionItem, type PendingVote, type PlainPayloadIntention, type PlainPayloadIntentionItem, PublicKeyManager, PublicKeySerde, type PublicKeyWithSchema, type PublicKeyWithWeight, RawStreamStatusEnum, type RecipientWithAmount, type RejectIntention, type Report, SUI_COIN, type SetAutoClaimIntentionData, SigningMessageHelper, type SimulateIntentionResponse, StreamEventType, StreamHelper, StreamStatus, StreamTransactionType, type SuiAddress, SyncApiService, SyncField, TransactionDefaultApplication, type TransactionIntentionItem, TransactionIntentionStatus, TransactionResponseDataDecoder, TransactionStatus, TransactionSubTypes, TransactionType, type TxIntention, TxParser, UNKNOWN_COIN, Uint8ArrayToHex, type UpdateAddressBookEntry, type UpsertAddressBookEntry, UserMSafeStatus, buildCoinTransferTxb, buildObjectTransferTxb, buildOtherCoinTransferTxb, buildRejectTxb, buildSuiCoinTransferTxb, createAccountCreationMessage, createLoginMessage, createLoginMessageWithTimestamp, createProposeIntentionMessage, decodeLoginMessageTimestamp, deserializeIntention, deserializePublicKey, getAllCoins, getPublicKeyFromPersonalSignature, getPublicKeyFromSignature, isCoinObjectType, isSameAddress, isSuiStructEqual, serializeIntention, serializePublicKey, stringToBuffer, verifyPersonalSignature, verifySignature, verifyTransactionSignature };