import { BaseApp, AppBaseInitialize, DeeplinkConnect, ContentType, MessageToSign, SignMessagesEvent, BaseClient, ClientBaseInitialize, Connect as Connect$1, HttpBaseClient, HttpBaseClientInitialize, RequestContent } from '@nightlylabs/nightly-connect-base';
import { InjectedAccounts, InjectedAccount, Unsubcall, InjectedExtension } from '@polkadot/extension-inject/types';
import { EventEmitter } from 'eventemitter3';
import { Signer as Signer$1, SignerResult } from '@polkadot/api/types';
import { SignerPayloadRaw, SignerPayloadJSON, SignerResult as SignerResult$1 } from '@polkadot/types/types';

interface UserDisconnectedEvent {
    message: string;
}

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;
}

declare class Accounts implements InjectedAccounts {
    activeAccounts: InjectedAccount[];
    sub: {
        [key in string]: (accounts: InjectedAccount[]) => void;
    };
    constructor();
    private _triggerSubs;
    addAccount: (account: InjectedAccount) => void;
    updateActiveAccounts: (activeAccounts: InjectedAccount[]) => void;
    get: (anyType?: boolean) => Promise<InjectedAccount[]>;
    subscribe: (cb: (accounts: InjectedAccount[]) => unknown) => Unsubcall;
}

declare class Signer implements Signer$1 {
    base: BaseApp;
    constructor(base: BaseApp);
    signRaw: (payload: SignerPayloadRaw) => Promise<SignerResult>;
    signPayload: (payload: SignerPayloadJSON) => Promise<SignerResult>;
}

type AppPolkadotInitialize = AppBaseInitialize;
interface PolkadotAppEvents {
    userConnected: (e: InjectedAccount[]) => void;
    userDisconnected: (e: UserDisconnectedEvent) => void;
    serverDisconnected: () => void;
}
declare class AppPolkadot extends EventEmitter<PolkadotAppEvents> implements InjectedExtension {
    sessionId: string;
    initData: AppPolkadotInitialize;
    name: string;
    version: string;
    accounts: Accounts;
    signer: Signer;
    constructor(base: BaseApp, initData: AppPolkadotInitialize);
    private tryReconnect;
    hasBeenRestored: () => boolean;
    static getWalletsMetadata: (url?: string) => Promise<WalletMetadata[]>;
    static build: (initData: AppPolkadotInitialize) => Promise<AppPolkadot>;
    connectDeeplink: (data: DeeplinkConnect) => Promise<void>;
    disconnectFromDApp: () => void;
}

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 SignTransactionsPolkadotRequest {
    type: ContentType.SignTransactions;
    requestId: string;
    transactions: Array<SignerPayloadRaw | SignerPayloadJSON>;
    sessionId: string;
    network?: string;
}
interface SignMessagesPolkadotRequest {
    type: ContentType.SignMessages;
    requestId: string;
    messages: Array<MessageToSign>;
    sessionId: string;
    network?: string;
}
interface CustomPolkadotRequest {
    type: ContentType.Custom;
    requestId: string;
    content?: string;
    sessionId: string;
    network?: string;
}
type PolkadotRequest = SignTransactionsPolkadotRequest | SignMessagesPolkadotRequest | CustomPolkadotRequest;

interface SignPolkadotTransactionEvent {
    requestId: string;
    transactions: Array<SignerPayloadRaw | SignerPayloadJSON>;
    sessionId: string;
    network?: string;
}
type SignPolkadotMessageEvent = SignMessagesEvent;
interface ClientPolkadotEvents {
    signTransactions: (e: SignPolkadotTransactionEvent) => void;
    appDisconnected: (e: AppDisconnectedEvent) => void;
}
declare class ClientPolkadot extends EventEmitter<ClientPolkadotEvents> {
    baseClient: BaseClient;
    sessionId: string | undefined;
    network: Network;
    private constructor();
    static build: (sessionId: string, initData: ClientBaseInitialize, network: Network) => Promise<{
        client: ClientPolkadot;
        data: GetInfoResponse;
    }>;
    static create: (initData: ClientBaseInitialize, network: Network) => Promise<ClientPolkadot>;
    getInfo: (sessionId: string) => Promise<GetInfoResponse>;
    connect: (connect: Connect) => Promise<void>;
    getPendingRequests: (sessionId?: string) => Promise<PolkadotRequest[]>;
    resolveSignTransaction: ({ requestId, signedTransactions, sessionId }: ResolveSignPolkadotTransactions$1) => Promise<void>;
    rejectRequest: ({ requestId, reason, sessionId }: RejectRequest$1) => Promise<void>;
    getSessions: () => Promise<string[]>;
    dropSessions: (sessionsToDrop: string[]) => Promise<string[]>;
}
type Connect = Connect$1 & {
    walletsMetadata: InjectedAccount[];
};
interface RejectRequest$1 {
    requestId: string;
    reason?: string;
    sessionId?: string;
}
interface ResolveSignPolkadotTransactions$1 {
    requestId: string;
    signedTransactions: SignerResult$1[];
    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 HttpGetPendingRequestsRequest {
    clientId: string;
    sessionId: string;
}

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

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

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

declare class HttpClientPolkadot {
    baseClient: HttpBaseClient;
    clientId: string | undefined;
    constructor({ clientId, timeout, url }: HttpBaseClientInitialize);
    getInfo: (sessionId: string) => Promise<HttpGetSessionInfoResponse>;
    connect: (connect: HttpConnect) => Promise<void>;
    getPendingRequests: (request: Omit<HttpGetPendingRequestsRequest, 'clientId'>) => Promise<PolkadotRequest[]>;
    getPendingRequest: (request: Omit<HttpGetPendingRequestRequest, 'clientId'>) => Promise<PolkadotRequest>;
    resolveSignTransaction: ({ requestId, signedTransactions, sessionId, network }: ResolveSignPolkadotTransactions) => Promise<void>;
    rejectRequest: ({ requestId, reason, sessionId }: RejectRequest) => Promise<void>;
}
type HttpConnect = Omit<HttpConnectSessionRequest, 'clientId'> & {
    walletsMetadata: InjectedAccount[];
};
interface RejectRequest {
    requestId: string;
    sessionId: string;
    reason?: string;
}
interface ResolveSignPolkadotTransactions {
    requestId: string;
    signedTransactions: SignerResult$1[];
    sessionId: string;
    network: Network;
}

declare const parseRequest: (request: RequestContent, sessionId: string) => PolkadotRequest;

export { Accounts, AppPolkadot, AppPolkadotInitialize, ClientPolkadot, ClientPolkadotEvents, Connect, CustomPolkadotRequest, HttpClientPolkadot, PolkadotRequest, RejectRequest as RejectHttpRequest, RejectRequest$1 as RejectRequest, ResolveSignPolkadotTransactions, SignMessagesPolkadotRequest, SignPolkadotMessageEvent, SignPolkadotTransactionEvent, SignTransactionsPolkadotRequest, Signer, WalletMetadata, parseRequest };