@pezkuwi/extension-base 0.62.8

package/build/background/types.d.ts

@@ -0,0 +1,343 @@
+import type { InjectedAccount, InjectedMetadataKnown, MetadataDef, ProviderList, ProviderMeta } from '@pezkuwi/extension-inject/types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@pezkuwi/keyring/types';
+import type { JsonRpcResponse } from '@pezkuwi/rpc-provider/types';
+import type { Registry, SignerPayloadJSON, SignerPayloadRaw } from '@pezkuwi/types/types';
+import type { KeyringPairs$Json } from '@pezkuwi/ui-keyring/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { KeypairType } from '@pezkuwi/util-crypto/types';
+import type { ALLOWED_PATH } from '../defaults.js';
+import type { AuthResponse } from './handlers/State.js';
+type KeysWithDefinedValues<T> = {
+    [K in keyof T]: T[K] extends undefined ? never : K;
+}[keyof T];
+type NoUndefinedValues<T> = {
+    [K in KeysWithDefinedValues<T>]: T[K];
+};
+type IsNull<T, K extends keyof T> = {
+    [K1 in Exclude<keyof T, K>]: T[K1];
+} & T[K] extends null ? K : never;
+type NullKeys<T> = {
+    [K in keyof T]: IsNull<T, K>;
+}[keyof T];
+export type AuthUrls = Record<string, AuthUrlInfo>;
+export interface AuthUrlInfo {
+    count: number;
+    id: string;
+    isAllowed?: boolean;
+    origin: string;
+    url: string;
+    authorizedAccounts: string[];
+}
+export type SeedLengths = 12 | 24;
+export interface AccountJson extends KeyringPair$Meta {
+    address: string;
+}
+export type AccountWithChildren = AccountJson & {
+    children?: AccountWithChildren[];
+};
+export interface AccountsContext {
+    accounts: AccountJson[];
+    hierarchy: AccountWithChildren[];
+    master?: AccountJson;
+    selectedAccounts?: AccountJson['address'][];
+    setSelectedAccounts?: (address: AccountJson['address'][]) => void;
+}
+export interface AuthorizeRequest {
+    id: string;
+    request: RequestAuthorizeTab;
+    url: string;
+}
+export interface MetadataRequest {
+    id: string;
+    request: MetadataDef;
+    url: string;
+}
+export interface SigningRequest {
+    account: AccountJson;
+    id: string;
+    request: RequestSign;
+    url: string;
+}
+export type ConnectedTabsUrlResponse = string[];
+export interface RequestSignatures {
+    'pri(accounts.create.external)': [RequestAccountCreateExternal, boolean];
+    'pri(accounts.create.hardware)': [RequestAccountCreateHardware, boolean];
+    'pri(accounts.create.suri)': [RequestAccountCreateSuri, boolean];
+    'pri(accounts.edit)': [RequestAccountEdit, boolean];
+    'pri(accounts.export)': [RequestAccountExport, ResponseAccountExport];
+    'pri(accounts.batchExport)': [RequestAccountBatchExport, ResponseAccountsExport];
+    'pri(accounts.forget)': [RequestAccountForget, boolean];
+    'pri(accounts.list)': [RequestAccountList, InjectedAccount[]];
+    'pri(accounts.show)': [RequestAccountShow, boolean];
+    'pri(accounts.tie)': [RequestAccountTie, boolean];
+    'pri(accounts.subscribe)': [RequestAccountSubscribe, boolean, AccountJson[]];
+    'pri(accounts.validate)': [RequestAccountValidate, boolean];
+    'pri(accounts.changePassword)': [RequestAccountChangePassword, boolean];
+    'pri(authorize.approve)': [RequestAuthorizeApprove, boolean];
+    'pri(authorize.list)': [null, ResponseAuthorizeList];
+    'pri(authorize.requests)': [RequestAuthorizeSubscribe, boolean, AuthorizeRequest[]];
+    'pri(authorize.remove)': [string, ResponseAuthorizeList];
+    'pri(authorize.reject)': [string, void];
+    'pri(authorize.cancel)': [string, void];
+    'pri(authorize.update)': [RequestUpdateAuthorizedAccounts, void];
+    'pri(activeTabsUrl.update)': [RequestActiveTabsUrlUpdate, void];
+    'pri(connectedTabsUrl.get)': [null, ConnectedTabsUrlResponse];
+    'pri(derivation.create)': [RequestDeriveCreate, boolean];
+    'pri(derivation.validate)': [RequestDeriveValidate, ResponseDeriveValidate];
+    'pri(json.restore)': [RequestJsonRestore, void];
+    'pri(json.batchRestore)': [RequestBatchRestore, void];
+    'pri(json.account.info)': [KeyringPair$Json, ResponseJsonGetAccountInfo];
+    'pri(metadata.approve)': [RequestMetadataApprove, boolean];
+    'pri(metadata.get)': [string | null, MetadataDef | null];
+    'pri(metadata.reject)': [RequestMetadataReject, boolean];
+    'pri(metadata.requests)': [RequestMetadataSubscribe, boolean, MetadataRequest[]];
+    'pri(metadata.list)': [null, MetadataDef[]];
+    'pri(ping)': [null, boolean];
+    'pri(seed.create)': [RequestSeedCreate, ResponseSeedCreate];
+    'pri(seed.validate)': [RequestSeedValidate, ResponseSeedValidate];
+    'pri(settings.notification)': [string, boolean];
+    'pri(signing.approve.password)': [RequestSigningApprovePassword, boolean];
+    'pri(signing.approve.signature)': [RequestSigningApproveSignature, boolean];
+    'pri(signing.cancel)': [RequestSigningCancel, boolean];
+    'pri(signing.isLocked)': [RequestSigningIsLocked, ResponseSigningIsLocked];
+    'pri(signing.requests)': [RequestSigningSubscribe, boolean, SigningRequest[]];
+    'pri(window.open)': [AllowedPath, boolean];
+    'pub(accounts.list)': [RequestAccountList, InjectedAccount[]];
+    'pub(accounts.subscribe)': [RequestAccountSubscribe, string, InjectedAccount[]];
+    'pub(accounts.unsubscribe)': [RequestAccountUnsubscribe, boolean];
+    'pub(authorize.tab)': [RequestAuthorizeTab, Promise<AuthResponse>];
+    'pub(bytes.sign)': [SignerPayloadRaw, ResponseSigning];
+    'pub(extrinsic.sign)': [SignerPayloadJSON, ResponseSigning];
+    'pub(metadata.list)': [null, InjectedMetadataKnown[]];
+    'pub(metadata.provide)': [MetadataDef, boolean];
+    'pub(phishing.redirectIfDenied)': [null, boolean];
+    'pub(ping)': [null, boolean];
+    'pub(rpc.listProviders)': [void, ResponseRpcListProviders];
+    'pub(rpc.send)': [RequestRpcSend, JsonRpcResponse<unknown>];
+    'pub(rpc.startProvider)': [string, ProviderMeta];
+    'pub(rpc.subscribe)': [RequestRpcSubscribe, number, JsonRpcResponse<unknown>];
+    'pub(rpc.subscribeConnected)': [null, boolean, boolean];
+    'pub(rpc.unsubscribe)': [RequestRpcUnsubscribe, boolean];
+}
+export type MessageTypes = keyof RequestSignatures;
+export type RequestTypes = {
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][0];
+};
+export type MessageTypesWithNullRequest = NullKeys<RequestTypes>;
+export interface TransportRequestMessage<TMessageType extends MessageTypes> {
+    id: string;
+    message: TMessageType;
+    origin: string;
+    request: RequestTypes[TMessageType];
+}
+export interface RequestAuthorizeTab {
+    origin: string;
+}
+export interface RequestAuthorizeApprove {
+    id: string;
+    authorizedAccounts: string[];
+}
+export interface RequestUpdateAuthorizedAccounts {
+    url: string;
+    authorizedAccounts: string[];
+}
+export type RequestAuthorizeSubscribe = null;
+export interface RequestMetadataApprove {
+    id: string;
+}
+export interface RequestMetadataReject {
+    id: string;
+}
+export type RequestMetadataSubscribe = null;
+export interface RequestAccountCreateExternal {
+    address: string;
+    genesisHash?: HexString | null;
+    name: string;
+}
+export interface RequestAccountCreateSuri {
+    name: string;
+    genesisHash?: HexString | null;
+    password: string;
+    suri: string;
+    type?: KeypairType;
+}
+export interface RequestAccountCreateHardware {
+    accountIndex: number;
+    address: string;
+    addressOffset: number;
+    genesisHash: HexString;
+    hardwareType: string;
+    name: string;
+    type: KeypairType;
+}
+export interface RequestAccountChangePassword {
+    address: string;
+    oldPass: string;
+    newPass: string;
+}
+export interface RequestAccountEdit {
+    address: string;
+    genesisHash?: HexString | null;
+    name: string;
+}
+export interface RequestAccountForget {
+    address: string;
+}
+export interface RequestAccountShow {
+    address: string;
+    isShowing: boolean;
+}
+export interface RequestAccountTie {
+    address: string;
+    genesisHash: HexString | null;
+}
+export interface RequestAccountValidate {
+    address: string;
+    password: string;
+}
+export interface RequestDeriveCreate {
+    name: string;
+    genesisHash?: HexString | null;
+    suri: string;
+    parentAddress: string;
+    parentPassword: string;
+    password: string;
+}
+export interface RequestDeriveValidate {
+    suri: string;
+    parentAddress: string;
+    parentPassword: string;
+}
+export interface RequestAccountExport {
+    address: string;
+    password: string;
+}
+export interface RequestAccountBatchExport {
+    addresses: string[];
+    password: string;
+}
+export interface RequestAccountList {
+    anyType?: boolean;
+}
+export type RequestAccountSubscribe = null;
+export interface RequestActiveTabsUrlUpdate {
+    urls: string[];
+}
+export interface RequestAccountUnsubscribe {
+    id: string;
+}
+export interface RequestRpcSend {
+    method: string;
+    params: unknown[];
+}
+export interface RequestRpcSubscribe extends RequestRpcSend {
+    type: string;
+}
+export interface RequestRpcUnsubscribe {
+    method: string;
+    subscriptionId: number | string;
+    type: string;
+}
+export interface RequestSigningApprovePassword {
+    id: string;
+    password?: string;
+    savePass: boolean;
+}
+export interface RequestSigningApproveSignature {
+    id: string;
+    signature: HexString;
+    signedTransaction?: HexString;
+}
+export interface RequestSigningCancel {
+    id: string;
+}
+export interface RequestSigningIsLocked {
+    id: string;
+}
+export interface ResponseSigningIsLocked {
+    isLocked: boolean;
+    remainingTime: number;
+}
+export type RequestSigningSubscribe = null;
+export interface RequestSeedCreate {
+    length?: SeedLengths;
+    seed?: string;
+    type?: KeypairType;
+}
+export interface RequestSeedValidate {
+    suri: string;
+    type?: KeypairType;
+}
+export type ResponseTypes = {
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][1];
+};
+export type ResponseType<TMessageType extends keyof RequestSignatures> = RequestSignatures[TMessageType][1];
+interface TransportResponseMessageSub<TMessageType extends MessageTypesWithSubscriptions> {
+    error?: string;
+    id: string;
+    response?: ResponseTypes[TMessageType];
+    subscription?: SubscriptionMessageTypes[TMessageType];
+}
+interface TransportResponseMessageNoSub<TMessageType extends MessageTypesWithNoSubscriptions> {
+    error?: string;
+    id: string;
+    response?: ResponseTypes[TMessageType];
+}
+export type TransportResponseMessage<TMessageType extends MessageTypes> = TMessageType extends MessageTypesWithNoSubscriptions ? TransportResponseMessageNoSub<TMessageType> : TMessageType extends MessageTypesWithSubscriptions ? TransportResponseMessageSub<TMessageType> : never;
+export interface ResponseSigning {
+    id: string;
+    signature: HexString;
+    signedTransaction?: HexString;
+}
+export interface ResponseDeriveValidate {
+    address: string;
+    suri: string;
+}
+export interface ResponseSeedCreate {
+    address: string;
+    seed: string;
+}
+export interface ResponseSeedValidate {
+    address: string;
+    suri: string;
+}
+export interface ResponseAccountExport {
+    exportedJson: KeyringPair$Json;
+}
+export interface ResponseAccountsExport {
+    exportedJson: KeyringPairs$Json;
+}
+export type ResponseRpcListProviders = ProviderList;
+export type SubscriptionMessageTypes = NoUndefinedValues<{
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][2];
+}>;
+export type MessageTypesWithSubscriptions = keyof SubscriptionMessageTypes;
+export type MessageTypesWithNoSubscriptions = Exclude<MessageTypes, keyof SubscriptionMessageTypes>;
+export interface RequestSign {
+    readonly payload: SignerPayloadJSON | SignerPayloadRaw;
+    sign(registry: Registry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}
+export interface RequestJsonRestore {
+    file: KeyringPair$Json;
+    password: string;
+}
+export interface RequestBatchRestore {
+    file: KeyringPairs$Json;
+    password: string;
+}
+export interface ResponseJsonRestore {
+    error: string | null;
+}
+export type AllowedPath = typeof ALLOWED_PATH[number];
+export interface ResponseJsonGetAccountInfo {
+    address: string;
+    name: string;
+    genesisHash: HexString;
+    type: KeypairType;
+}
+export interface ResponseAuthorizeList {
+    list: AuthUrls;
+}
+export {};

package/build/background/types.js

@@ -0,0 +1,3 @@
+// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export {};

package/build/bundle.d.ts

@@ -0,0 +1 @@
+export { packageInfo } from './packageInfo.js';

package/build/bundle.js

@@ -0,0 +1,3 @@
+// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { packageInfo } from './packageInfo.js';

package/build/defaults.d.ts

@@ -0,0 +1,9 @@
+export declare const EXTENSION_PREFIX: string;
+export declare const PORT_CONTENT: string;
+export declare const PORT_EXTENSION: string;
+export declare const MESSAGE_ORIGIN_PAGE: string;
+export declare const MESSAGE_ORIGIN_CONTENT: string;
+export declare const ALLOWED_PATH: readonly ["/", "/account/import-ledger", "/account/restore-json"];
+export declare const PASSWORD_EXPIRY_MIN = 15;
+export declare const PASSWORD_EXPIRY_MS: number;
+export declare const PHISHING_PAGE_REDIRECT = "/phishing-page-detected";

package/build/defaults.js

@@ -0,0 +1,17 @@
+// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// this _must_ be changed for each extension
+export var EXTENSION_PREFIX = process.env['EXTENSION_PREFIX'] || '';
+if (!EXTENSION_PREFIX && !process.env['PORT_PREFIX']) {
+    throw new Error('CRITICAL: The extension does not define an own EXTENSION_PREFIX environment variable as part of the build, this is required to ensure that messages are not shared between extensions. Failure to do so will yield messages sent to multiple extensions.');
+}
+var PORT_PREFIX = "".concat(EXTENSION_PREFIX || 'unknown', "-").concat(process.env['PORT_PREFIX'] || 'unknown');
+export var PORT_CONTENT = "".concat(PORT_PREFIX, "-content");
+export var PORT_EXTENSION = "".concat(PORT_PREFIX, "-extension");
+export var MESSAGE_ORIGIN_PAGE = "".concat(PORT_PREFIX, "-page");
+export var MESSAGE_ORIGIN_CONTENT = "".concat(PORT_PREFIX, "-content");
+export var ALLOWED_PATH = ['/', '/account/import-ledger', '/account/restore-json'];
+export var PASSWORD_EXPIRY_MIN = 15;
+export var PASSWORD_EXPIRY_MS = PASSWORD_EXPIRY_MIN * 60 * 1000;
+export var PHISHING_PAGE_REDIRECT = '/phishing-page-detected';
+// console.log(`Extension is sending and receiving messages on ${PORT_PREFIX}-*`);

package/build/index.d.ts

@@ -0,0 +1 @@
+export * from './bundle.js';

package/build/index.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Since we inject into pages, we skip this
+// import './detectPackage';
+export * from './bundle.js';

package/build/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/build/packageDetect.js

@@ -0,0 +1,10 @@
+// Copyright 2017-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Do not edit, auto-generated by @pezkuwi/dev
+// (packageInfo imports will be kept as-is, user-editable)
+import { packageInfo as chainsInfo } from '@pezkuwi/extension-chains/packageInfo';
+import { packageInfo as dappInfo } from '@pezkuwi/extension-dapp/packageInfo';
+import { packageInfo as injectInfo } from '@pezkuwi/extension-inject/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+import { packageInfo } from './packageInfo.js';
+detectPackage(packageInfo, null, [chainsInfo, dappInfo, injectInfo]);

package/build/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build/packageInfo.js

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Do not edit, auto-generated by @pezkuwi/dev
+export var packageInfo = { name: '@pezkuwi/extension-base', path: 'auto', type: 'auto', version: '0.62.6' };

package/build/page/Accounts.d.ts

@@ -0,0 +1,7 @@
+import type { InjectedAccount, InjectedAccounts, Unsubcall } from '@pezkuwi/extension-inject/types';
+import type { SendRequest } from './types.js';
+export default class Accounts implements InjectedAccounts {
+    constructor(_sendRequest: SendRequest);
+    get(anyType?: boolean): Promise<InjectedAccount[]>;
+    subscribe(cb: (accounts: InjectedAccount[]) => unknown): Unsubcall;
+}

package/build/page/Accounts.js

@@ -0,0 +1,26 @@
+// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// External to class, this.# is not private enough (yet)
+var sendRequest;
+var Accounts = /** @class */ (function () {
+    function Accounts(_sendRequest) {
+        sendRequest = _sendRequest;
+    }
+    Accounts.prototype.get = function (anyType) {
+        return sendRequest('pub(accounts.list)', { anyType: anyType });
+    };
+    Accounts.prototype.subscribe = function (cb) {
+        var id = null;
+        sendRequest('pub(accounts.subscribe)', null, cb)
+            .then(function (subId) {
+            id = subId;
+        })
+            .catch(console.error);
+        return function () {
+            id && sendRequest('pub(accounts.unsubscribe)', { id: id })
+                .catch(console.error);
+        };
+    };
+    return Accounts;
+}());
+export default Accounts;

package/build/page/Injected.d.ts

@@ -0,0 +1,13 @@
+import type { Injected } from '@pezkuwi/extension-inject/types';
+import type { SendRequest } from './types.js';
+import Accounts from './Accounts.js';
+import Metadata from './Metadata.js';
+import PostMessageProvider from './PostMessageProvider.js';
+import Signer from './Signer.js';
+export default class implements Injected {
+    readonly accounts: Accounts;
+    readonly metadata: Metadata;
+    readonly provider: PostMessageProvider;
+    readonly signer: Signer;
+    constructor(sendRequest: SendRequest);
+}

package/build/page/Injected.js

@@ -0,0 +1,21 @@
+// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import Accounts from './Accounts.js';
+import Metadata from './Metadata.js';
+import PostMessageProvider from './PostMessageProvider.js';
+import Signer from './Signer.js';
+var default_1 = /** @class */ (function () {
+    function default_1(sendRequest) {
+        this.accounts = new Accounts(sendRequest);
+        this.metadata = new Metadata(sendRequest);
+        this.provider = new PostMessageProvider(sendRequest);
+        this.signer = new Signer(sendRequest);
+        setInterval(function () {
+            sendRequest('pub(ping)', null).catch(function () {
+                console.error('Extension unavailable, ping failed');
+            });
+        }, 5000 + Math.floor(Math.random() * 5000));
+    }
+    return default_1;
+}());
+export default default_1;

package/build/page/Metadata.d.ts

@@ -0,0 +1,7 @@
+import type { InjectedMetadata, InjectedMetadataKnown, MetadataDef } from '@pezkuwi/extension-inject/types';
+import type { SendRequest } from './types.js';
+export default class Metadata implements InjectedMetadata {
+    constructor(_sendRequest: SendRequest);
+    get(): Promise<InjectedMetadataKnown[]>;
+    provide(definition: MetadataDef): Promise<boolean>;
+}

package/build/page/Metadata.js

@@ -0,0 +1,17 @@
+// Copyright 2019-2025 @pezkuwi/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// External to class, this.# is not private enough (yet)
+var sendRequest;
+var Metadata = /** @class */ (function () {
+    function Metadata(_sendRequest) {
+        sendRequest = _sendRequest;
+    }
+    Metadata.prototype.get = function () {
+        return sendRequest('pub(metadata.list)');
+    };
+    Metadata.prototype.provide = function (definition) {
+        return sendRequest('pub(metadata.provide)', definition);
+    };
+    return Metadata;
+}());
+export default Metadata;

package/build/page/PostMessageProvider.d.ts

@@ -0,0 +1,63 @@
+import type { InjectedProvider, ProviderList, ProviderMeta } from '@pezkuwi/extension-inject/types';
+import type { ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@pezkuwi/rpc-provider/types';
+import type { AnyFunction } from '@pezkuwi/types/types';
+import type { SendRequest } from './types.js';
+type CallbackHandler = (error?: null | Error, value?: unknown) => void;
+interface SubscriptionHandler {
+    callback: CallbackHandler;
+    type: string;
+}
+/**
+ * @name PostMessageProvider
+ *
+ * @description Extension provider to be used by dapps
+ */
+export default class PostMessageProvider implements InjectedProvider {
+    #private;
+    /**
+     * @param {function}  sendRequest  The function to be called to send requests to the node
+     * @param {function}  subscriptionNotificationHandler  Channel for receiving subscription messages
+     */
+    constructor(_sendRequest: SendRequest);
+    get isClonable(): boolean;
+    /**
+     * @description Returns a clone of the object
+     */
+    clone(): PostMessageProvider;
+    /**
+     * @description Manually disconnect from the connection, clearing autoconnect logic
+     */
+    connect(): Promise<void>;
+    /**
+     * @description Manually disconnect from the connection, clearing autoconnect logic
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @summary `true` when this provider supports subscriptions
+     */
+    get hasSubscriptions(): boolean;
+    /**
+     * @summary Whether the node is connected or not.
+     * @return {boolean} true if connected
+     */
+    get isConnected(): boolean;
+    listProviders(): Promise<ProviderList>;
+    /**
+     * @summary Listens on events after having subscribed using the [[subscribe]] function.
+     * @param  {ProviderInterfaceEmitted} type Event
+     * @param  {ProviderInterfaceEmitCb}  sub  Callback
+     * @return unsubscribe function
+     */
+    on(type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): () => void;
+    send(method: string, params: unknown[], _?: boolean, subscription?: SubscriptionHandler): Promise<any>;
+    /**
+     * @summary Spawn a provider on the extension background.
+     */
+    startProvider(key: string): Promise<ProviderMeta>;
+    subscribe(type: string, method: string, params: unknown[], callback: AnyFunction): Promise<number>;
+    /**
+     * @summary Allows unsubscribing to subscriptions made with [[subscribe]].
+     */
+    unsubscribe(type: string, method: string, id: number): Promise<boolean>;
+}
+export {};