import { KeyPair } from '@tonconnect/protocol';
import { MessageEvent as MessageEvent_2 } from 'react-native-sse';
import { Subscription } from 'rxjs';
import { Transaction } from '@solana/web3.js';
import { VersionedTransaction } from '@solana/web3.js';

export declare class BaseProvider {
    private readonly defaultTtl;
    private bridgeUrl;
    private deeplink;
    private eventSource;
    private namespaceKey;
    private metadata;
    private namespace;
    private valid;
    private resolve;
    private reject;
    walletInfo: WalletInfo;
    connection: OmniConnection;
    constructor(options: any);
    getWalletInfo(): WalletInfo;
    onStatusChange(callback: any, errorsHandler: any): Subscription;
    syncEventSourceMessage(): Promise<any>;
    connect(options: ConnectingOptions): Promise<any>;
    getAddress(): any;
    disconnect(response?: any): void;
    distribute({ method, payload, settings, }: {
        method: RequestMethods;
        payload: any;
        settings: {
            preventPopup?: PreventType;
        };
    }): Promise<any>;
    handleMessage(messageEvent: MessageEvent_2): Promise<void>;
    send(request: OmniAppRequest, ttl?: number): Promise<void>;
    restoreConnection(cb?: any): Promise<any>;
    setWalletInfo(walletInfo: any): void;
    next(v: any): void;
    close(): void;
    eventSourceErrorHandle(event: any): void;
    removeConnection(): void;
    connectedNeededAssert(): void;
    openlinkInCommonWay(preventPopup?: PreventType): void;
    validationAssert(): void;
}

export declare interface ConnectingOptions {
    request?: any;
    ret?: string;
    callback?: () => void;
}

export declare const defaultEip155Namespace: {
    chains: string[];
    methods: Eip155SigningMethods[];
};

export declare const DefaultSupportedChainIds: string[];

export declare interface Eip155Namespace {
    eip155: {
        chains: Array<number | string>;
        methods?: Array<string>;
        events?: Array<string>;
    };
}

export declare class Eip155Provider extends BaseProvider {
    chains?: Array<string>;
    chainId?: string;
    constructor(options: any);
    request(args: any): Promise<any>;
    getAccounts(): Promise<any>;
    connect(opt?: any): Promise<{
        account: any;
        chainId: any;
    }>;
    signMessage(options: Eip155SigningMessageOptions): Promise<any>;
    signTransaction(options: SigningTxOptions): Promise<any>;
    sendTransaction(options: SigningTxOptions): Promise<any>;
    restoreConnection(): Promise<{
        account: any;
        chainId: any;
    }>;
}

export declare interface Eip155SigningMessageOptions {
    method: Eip155SigningMethods;
    params: Array<any>;
    settings?: {
        preventPopup?: PreventType;
    };
}

export declare enum Eip155SigningMethods {
    EthSign = "eth_sign",
    PersonalSign = "personal_sign",
    EthSignTypedData = "eth_signTypedData",
    EthSignTypedDataV3 = "eth_signTypedData_v3",
    EthSignTypedDataV4 = "eth_signTypedData_v4",
    EthSignTransaction = "eth_signTransaction",
    EthSendTransaction = "eth_sendTransaction",
    EthSendRawTransaction = "eth_sendRawTransaction"
}

export declare const generateClientId: (keyPair?: KeyPair) => {
    sessionKeyPair: KeyPair;
    sessionId: string;
};

export declare const getTransactionVersion: (transaction: SolTransaction) => string;

export declare const InitWalletInfo: {
    namespaceKey: string;
    connected: boolean;
    result: {};
};

export declare function isTelegramEnvironment(): Promise<boolean>;

export declare function isVersionedTransaction(transaction: SolTransaction): boolean;

export declare interface MessageStream {
    id: number;
    namespaceKey: string;
    event: string;
    connected: boolean;
    result: {
        [key: string]: any;
    };
}

export declare interface MessageStreamError {
    error: {
        code: number;
        message: string;
    };
}

export declare interface OmniAppCommonResponse {
    id: number;
    event: RequestMethods;
    namespaceKey: string;
    result: any;
}

export declare interface OmniAppErrorResponse {
    id: number;
    event: RequestMethods;
    error: {
        code: number;
        message: string;
        data?: any;
    };
}

export declare interface OmniAppRequest {
    id: number;
    namespaceKey: string;
    method: RequestMethods;
    payload?: any;
}

export declare type OmniAppResponse = OmniAppCommonResponse & OmniAppErrorResponse;

export declare class OmniConnect {
    provider: Eip155Provider | SolanaProvider;
    constructor(options: OmniConnectOptions);
    initialize(options: OmniConnectOptions): Promise<void>;
}

export declare enum OmniConnectBridgeType {
    Remote = "remote",
    Injected = "injected"
}

export declare interface OmniConnection {
    sessionKeyPair: KeyPair;
    from: string;
}

export declare interface OmniConnectOptions {
    bridgeUrl?: string;
    deeplink?: string;
    namespace: OmniNamespace;
    metadata: OmniMetadata;
}

export declare interface OmniMetadata {
    name: string;
    iconUrl: string;
    url: string;
    privacyPolicyUrl?: string;
    termsOfUseUrl?: string;
}

export declare type OmniNamespace = Partial<Eip155Namespace & TonNamespace & SolNamespace>;

export declare function overrideWindowOpen(): boolean;

export declare enum PreventType {
    Open = "PreventOpen",
    Close = "PreventClose"
}

export declare enum RequestMethods {
    Connect = "Connect",
    SignMessage = "SignMessage",
    SignTransaction = "SignTransaction",
    SendTransaction = "SendTransaction",
    Disconnect = "Disconnect"
}

export declare type SigningMessageOptions = Partial<Eip155SigningMessageOptions & SolSigningMessageOptions>;

export declare type SigningTxOptions = Partial<Eip155SigningMessageOptions & SolSigningTxOptions>;

export declare interface SignMessageParams {
    type: Eip155SigningMethods;
    params: Array<any>;
}

export declare class SolanaProvider extends BaseProvider {
    chains?: Array<string>;
    constructor(options: any);
    connect(opt: any): Promise<{
        account: any;
    }>;
    signMessage(options: SolSigningMessageOptions): Promise<any>;
    signTransaction(options: SolSigningTxOptions): Promise<any>;
    restoreConnection(): Promise<{
        account: any;
    }>;
}

export declare interface SolNamespace {
    solana: {
        chains?: Array<string>;
        chainId?: string | number;
    };
}

export declare interface SolSigningMessageOptions {
    message: string;
    chain?: string;
    settings?: {
        preventPopup?: PreventType;
    };
}

export declare interface SolSigningTxOptions {
    transaction: SolTransaction;
    settings?: {
        preventPopup?: PreventType;
    };
}

export declare type SolTransaction = Partial<Transaction & VersionedTransaction>;

export declare type StreamProps = MessageStream & MessageStreamError;

export declare interface TonNamespace {
    ton: {};
}

export declare interface TransactionParams {
    nonce?: string;
    from: string;
    to?: string;
    value: string;
    data: string;
    gasLimit: string;
    gasPrice?: string;
    maxPriorityFeePerGas?: string;
    maxFeePerGas?: string;
    chainId: string | number;
}

export declare const TransactionVersion: {
    legacy: string;
    versioned: string;
};

export declare const validateNamespace: (namespace: OmniNamespace) => void;

export declare const validateSignMessageParams: ({ method, params, }: {
    method: Eip155SigningMethods;
    params: Array<any>;
}) => string | null;

export declare const validateTransactionParams: (params: TransactionParams) => string;

export declare const validateTypedDataParams: (data: any) => string | null;

export declare const validateTypedDataVParams: (data: any) => string | null;

export declare interface WalletInfo {
    namespaceKey: string;
    connected: boolean;
    result: Record<any, any>;
    from?: string;
}

export { }