import { SuiSignTransactionBlockInput, SuiSignPersonalMessageInput, SuiSignAndExecuteTransactionBlockInput, SuiSignAndExecuteTransactionBlockOutput } from '@mysten/wallet-standard';
import { ContentType, TransactionToSign, MessageToSign, AppBaseInitialize, RequestContent, BaseApp, DeeplinkConnect, SignMessagesEvent, BaseClient, ClientBaseInitialize, Connect, HttpBaseClient, HttpBaseClientInitialize } from '@nightlylabs/nightly-connect-base';
import { EventEmitter } from 'eventemitter3';
import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
import { Transaction } from '@mysten/sui/transactions';
import { SuiTransactionBlockResponse } from '@mysten/sui/client';

interface UserConnectedEvent {
    publicKeys: Array<string>;
    metadata?: string;
}

type UserDisconnectedEvent = null;

interface Deeplink {
    native: string | null;
    universal: string | null;
    redirectToAppBrowser: string | null;
}

interface Images {
    default: string;
    sm: string;
    md: string;
    lg: string;
}

type Network = string;

type Platform = "browser" | "ios" | "android" | "macos" | "windows" | "linux" | "chrome" | "firefox" | "opera" | "edge" | "brave" | "safari" | "other";

type Version = string;

type WalletType = "mobile" | "extension" | "hybrid";

interface WalletMetadata {
    slug: string;
    name: string;
    description: string;
    homepage: string;
    chains: Array<Network>;
    version: Version;
    walletType: WalletType;
    mobile: Deeplink | null;
    desktop: Deeplink | null;
    image: Images;
    app: Record<Platform, string>;
    injectPath: Record<Network, string>;
    lastUpdatedTimestamp: bigint;
}

interface SignTransactionsSuiRequest {
    type: ContentType.SignTransactions;
    requestId: string;
    transactions: Array<TransactionToSign>;
    sessionId: string;
}
interface SignMessagesSuiRequest {
    type: ContentType.SignMessages;
    requestId: string;
    messages: Array<MessageToSign>;
    sessionId: string;
}
interface CustomSuiRequest {
    type: ContentType.Custom;
    requestId: string;
    content?: string;
    sessionId: string;
}
type SuiRequest = SignTransactionsSuiRequest | SignMessagesSuiRequest | CustomSuiRequest;

type AppSuiInitialize = Omit<AppBaseInitialize, 'network'>;
declare const SUI_NETWORK = "Sui";
type SerializedSignature = string;
type SignedTransaction = {
    transactionBlockBytes: string;
    signature: SerializedSignature;
};
type SignedMessage = {
    messageBytes: string;
    signature: SerializedSignature;
};
declare const signTransactionBlock: (tx: Transaction, account: Ed25519Keypair) => Promise<{
    transactionBlockBytes: Uint8Array;
    signature: string;
}>;
declare const parseRequest: (request: RequestContent, sessionId: string) => SuiRequest;

interface SuiAppEvents {
    userConnected: (e: UserConnectedEvent) => void;
    userDisconnected: (e: UserDisconnectedEvent) => void;
    serverDisconnected: () => void;
}
declare class AppSui extends EventEmitter<SuiAppEvents> {
    sessionId: string;
    base: BaseApp;
    initData: AppSuiInitialize;
    constructor(base: BaseApp, initData: AppSuiInitialize);
    private tryReconnect;
    hasBeenRestored: () => boolean;
    get connectedPublicKeys(): string[];
    static getWalletsMetadata: (url?: string) => Promise<WalletMetadata[]>;
    static build: (initData: AppSuiInitialize) => Promise<AppSui>;
    connectDeeplink: (data: DeeplinkConnect) => Promise<void>;
    signTransactionBlock: (input: SuiSignTransactionBlockInput) => Promise<SignedTransaction>;
    signMessage: (input: SuiSignPersonalMessageInput, encoding?: string) => Promise<SignedMessage>;
    signAndExecuteTransactionBlock: (input: SuiSignAndExecuteTransactionBlockInput) => Promise<SuiSignAndExecuteTransactionBlockOutput>;
}

interface AppDisconnectedEvent {
    sessionId: string;
    reason: string;
}

interface AppMetadata {
    name: string;
    url?: string;
    description?: string;
    icon?: string;
    additionalInfo?: string;
}

interface GetInfoResponse {
    responseId: string;
    network: Network;
    version: Version;
    appMetadata: AppMetadata;
}

interface SignSuiTransactionEvent {
    sessionId: string;
    requestId: string;
    transactions: Array<TransactionToSign>;
}
type SignSuiMessageEvent = SignMessagesEvent;
interface ClientSuiEvents {
    signTransactions: (e: SignSuiTransactionEvent) => void;
    signMessages: (e: SignSuiMessageEvent) => void;
    appDisconnected: (e: AppDisconnectedEvent) => void;
}
declare class ClientSui extends EventEmitter<ClientSuiEvents> {
    baseClient: BaseClient;
    sessionId: string | undefined;
    private constructor();
    static build: (sessionId: string, initData: ClientBaseInitialize) => Promise<{
        client: ClientSui;
        data: GetInfoResponse;
    }>;
    static create: (initData: ClientBaseInitialize) => Promise<ClientSui>;
    getInfo: (sessionId: string) => Promise<GetInfoResponse>;
    connect: (connect: Connect) => Promise<void>;
    getPendingRequests: (sessionId?: string) => Promise<SuiRequest[]>;
    resolveSignTransaction: ({ responseId, signedTransactions, sessionId }: ResolveSignSuiTransactions$1) => Promise<void>;
    resolveSignMessage: ({ responseId, signature, sessionId }: ResolveSignSuiMessage$1) => Promise<void>;
    rejectRequest: ({ requestId, reason, sessionId }: RejectRequest$1) => Promise<void>;
    getSessions: () => Promise<string[]>;
    dropSessions: (sessionsToDrop: string[]) => Promise<string[]>;
}
interface RejectRequest$1 {
    requestId: string;
    reason?: string;
    sessionId?: string;
}
interface ResolveSignSuiTransactions$1 {
    responseId: string;
    signedTransactions: Array<SignedTransaction | SuiTransactionBlockResponse>;
    sessionId?: string;
}
interface ResolveSignSuiMessage$1 {
    responseId: string;
    signature: SignedMessage;
    sessionId?: string;
}

type Device = "Apple" | "Android" | "Unknown";

interface Notification {
    token: string;
    notificationEndpoint: string;
}

interface HttpConnectSessionRequest {
    clientId: string;
    publicKeys: Array<string>;
    sessionId: string;
    notification?: Notification;
    device?: Device;
    metadata?: string;
}

interface HttpGetPendingRequestRequest {
    clientId: string;
    sessionId: string;
    requestId: string;
}

interface HttpGetPendingRequestsRequest {
    clientId: string;
    sessionId: string;
}

type SessionStatus = "WaitingForClient" | "ClientConnected" | "AppConnected" | "UserDisconnected" | "AppDisconnected" | "Idle";

interface HttpGetSessionInfoResponse {
    status: SessionStatus;
    persistent: boolean;
    version: Version;
    network: Network;
    appMetadata: AppMetadata;
}

declare class HttpClientSui {
    baseClient: HttpBaseClient;
    clientId: string | undefined;
    constructor({ clientId, timeout, url }: HttpBaseClientInitialize);
    getInfo: (sessionId: string) => Promise<HttpGetSessionInfoResponse>;
    connect: (connect: Omit<HttpConnectSessionRequest, 'clientId'>) => Promise<void>;
    getPendingRequests: (request: Omit<HttpGetPendingRequestsRequest, 'clientId'>) => Promise<SuiRequest[]>;
    getPendingRequest: (request: Omit<HttpGetPendingRequestRequest, 'clientId'>) => Promise<SuiRequest>;
    resolveSignTransaction: ({ requestId, signedTransactions, sessionId }: ResolveSignSuiTransactions) => Promise<void>;
    resolveSignMessage: ({ requestId, signature, sessionId }: ResolveSignSuiMessage) => Promise<void>;
    rejectRequest: ({ requestId, reason, sessionId }: RejectRequest) => Promise<void>;
}
interface RejectRequest {
    requestId: string;
    sessionId: string;
    reason?: string;
}
interface ResolveSignSuiTransactions {
    requestId: string;
    signedTransactions: SignedTransaction[];
    sessionId: string;
}
interface ResolveSignSuiMessage {
    requestId: string;
    signature: Uint8Array;
    sessionId: string;
}

export { AppSui, AppSuiInitialize, ClientSui, ClientSuiEvents, CustomSuiRequest, HttpClientSui, RejectRequest as RejectHttpRequest, RejectRequest$1 as RejectRequest, ResolveSignSuiMessage, ResolveSignSuiTransactions, SUI_NETWORK, SignMessagesSuiRequest, SignSuiMessageEvent, SignSuiTransactionEvent, SignTransactionsSuiRequest, SignedMessage, SignedTransaction, SuiRequest, parseRequest, signTransactionBlock };