@pezkuwi/api 16.5.5 → 16.5.8

package/build-deno/types/index.ts

@@ -0,0 +1,124 @@
+
+import type { ApiTypes, DeriveCustom, QueryableStorageMulti } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { ApiInterfaceRx as ApiInterfaceBase } from 'https://deno.land/x/pezkuwi/api-base/types/api.ts';
+import type { QueryableCalls } from 'https://deno.land/x/pezkuwi/api-base/types/calls.ts';
+import type { QueryableConsts } from 'https://deno.land/x/pezkuwi/api-base/types/consts.ts';
+import type { DecoratedErrors } from 'https://deno.land/x/pezkuwi/api-base/types/errors.ts';
+import type { DecoratedEvents } from 'https://deno.land/x/pezkuwi/api-base/types/events.ts';
+import type { QueryableStorage } from 'https://deno.land/x/pezkuwi/api-base/types/storage.ts';
+import type { ProviderInterface, ProviderInterfaceEmitted } from 'https://deno.land/x/pezkuwi/rpc-provider/types.ts';
+import type { ExtDef } from 'https://deno.land/x/pezkuwi/types/extrinsic/signedExtensions/types.ts';
+import type { Call, Extrinsic, Hash, RuntimeVersionPartial } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { CallFunction, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, RegisteredTypes, Registry, RegistryError, SignatureOptions, Signer } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { HexString } from 'https://deno.land/x/pezkuwi/util/types.ts';
+import type { ApiBase } from '../base/index.ts';
+import type { SubmittableExtrinsic } from '../types/submittable.ts';
+import type { AllDerives } from '../util/decorate.ts';
+
+export type { Signer, SignerResult } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+export { ApiBase } from '../base/index.ts';
+
+export * from 'https://deno.land/x/pezkuwi/api/types/calls.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/consts.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/errors.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/events.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/storage.ts';
+export * from 'https://deno.land/x/pezkuwi/api/types/submittable.ts';
+export * from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+
+export interface ApiInterfaceRx extends ApiInterfaceBase {
+  derive: AllDerives<'rxjs'>;
+}
+
+export interface ApiOptions extends RegisteredTypes {
+  /**
+   * @description Add custom derives to be injected
+   */
+  derives?: DeriveCustom;
+  /**
+   * @description Control the initialization of the wasm libraries. When not specified, it defaults to `true`, initializing the wasm libraries, set to `false` to not initialize wasm. (No sr25519 support)
+   */
+  initWasm?: boolean;
+  /**
+   * @description Controls the checking of storage values once they have been contructed. When not specified this defaults to `true`. Set to `false` to forgo any checking on storage results.
+   */
+  isPedantic?: boolean;
+  /**
+   * @description pre-bundles is a map of 'genesis hash and runtime spec version' as key to a metadata hex string
+   * if genesis hash and runtime spec version matches, then use metadata, else fetch it from chain
+   */
+  metadata?: Record<string, HexString>;
+  /**
+   * @description Don't display any warnings on initialization (missing RPC methods & runtime calls)
+   */
+  noInitWarn?: boolean;
+  /**
+   * @description Transport Provider from rpc-provider. If not specified, it will default to
+   * connecting to a WsProvider connecting localhost with the default port, i.e. `ws://127.0.0.1:9944`
+   */
+  provider?: ProviderInterface;
+  /**
+   * @description A type registry to use along with this instance
+   */
+  registry?: Registry;
+  /**
+   * @description User-defined RPC methods
+   */
+  rpc?: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>;
+  /**
+   * @description Defines the size of the cache for the rpc-core. Defaults to 1024 * 10 * 10.
+   */
+  rpcCacheCapacity?: number;
+  /**
+   * @description Overrides for state_call usage (this will be removed in some future version)
+   */
+  runtime?: DefinitionsCall;
+  /**
+   * @description Any chain-specific signed extensions that are now well-known
+   */
+  signedExtensions?: ExtDef;
+  /**
+   * @description An external signer which will be used to sign extrinsic when account passed in is not KeyringPair
+   */
+  signer?: Signer;
+  /**
+   * @description The source object to use for runtime information (only used when cloning)
+   */
+  source?: ApiBase<any>;
+  /**
+   * @description Throws an error when the initial connection fails (same as isReadyOrError)
+   */
+  throwOnConnect?: boolean;
+  /**
+   * @description Throws an error when some types are unknown (useful with throwOnConnect)
+   */
+  throwOnUnknown?: boolean;
+}
+
+export type ApiInterfaceEvents = ProviderInterfaceEmitted | 'ready' | 'decorated';
+
+export interface SignerOptions extends SignatureOptions {
+  blockNumber: BN;
+  genesisHash: Hash;
+}
+
+export interface ApiDecoration<ApiType extends ApiTypes> {
+  call: QueryableCalls<ApiType>;
+  consts: QueryableConsts<ApiType>;
+  errors: DecoratedErrors<ApiType>;
+  events: DecoratedEvents<ApiType>;
+  query: QueryableStorage<ApiType>;
+  registry: Registry;
+  runtimeVersion: RuntimeVersionPartial;
+  rx: {
+    call: QueryableCalls<'rxjs'>;
+    query: QueryableStorage<'rxjs'>;
+  };
+  tx: (extrinsic: Call | Extrinsic | Uint8Array | string) => SubmittableExtrinsic<ApiType>;
+
+  findCall (callIndex: Uint8Array | string): CallFunction;
+  findError (errorIndex: Uint8Array | string): RegistryError;
+  queryMulti: QueryableStorageMulti<ApiType>;
+}

package/build-deno/types/storage.ts

@@ -0,0 +1,2 @@
+
+export * from 'https://deno.land/x/pezkuwi/api-base/types/storage.ts';

package/build-deno/types/submittable.ts

@@ -0,0 +1,2 @@
+
+export * from 'https://deno.land/x/pezkuwi/api-base/types/submittable.ts';

package/build-deno/util/augmentObject.ts

@@ -0,0 +1,109 @@
+
+import { lazyMethods, logger, objectClear } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+type Sections <T> = Record<string, Methods<T>>;
+
+type Methods <T> = Record<string, T>;
+
+type StringsStrings = [string[], string[]];
+
+const l = logger('api/augment');
+
+function logLength (type: 'added' | 'removed', values: string[], and: string[] = []): string {
+  return values.length
+    ? ` ${values.length} ${type}${and.length ? ' and' : ''}`
+    : '';
+}
+
+function logValues (type: 'added' | 'removed', values: string[]): string {
+  return values.length
+    ? `\n\t${type.padStart(7)}: ${values.sort().join(', ')}`
+    : '';
+}
+
+function warn (prefix: string, type: 'calls' | 'modules', [added, removed]: StringsStrings): void {
+  if (added.length || removed.length) {
+    l.warn(`api.${prefix}: Found${logLength('added', added, removed)}${logLength('removed', removed)} ${type}:${logValues('added', added)}${logValues('removed', removed)}`);
+  }
+}
+
+function findSectionExcludes (a: string[], b: string[]): string[] {
+  return a.filter((s) => !b.includes(s));
+}
+
+function findSectionIncludes (a: string[], b: string[]): string[] {
+  return a.filter((s) => b.includes(s));
+}
+
+function extractSections <T> (src: Sections<T>, dst: Sections<T>): StringsStrings {
+  const srcSections = Object.keys(src);
+  const dstSections = Object.keys(dst);
+
+  return [
+    findSectionExcludes(srcSections, dstSections),
+    findSectionExcludes(dstSections, srcSections)
+  ];
+}
+
+function findMethodExcludes <T> (src: Sections<T>, dst: Sections<T>): string[] {
+  const srcSections = Object.keys(src);
+  const dstSections = findSectionIncludes(Object.keys(dst), srcSections);
+  const excludes: string[] = [];
+
+  for (let s = 0, scount = dstSections.length; s < scount; s++) {
+    const section = dstSections[s];
+    const srcMethods = Object.keys(src[section]);
+    const dstMethods = Object.keys(dst[section]);
+
+    for (let d = 0, mcount = dstMethods.length; d < mcount; d++) {
+      const method = dstMethods[d];
+
+      if (!srcMethods.includes(method)) {
+        excludes.push(`${section}.${method}`);
+      }
+    }
+  }
+
+  return excludes;
+}
+
+function extractMethods <T> (src: Sections<T>, dst: Sections<T>): StringsStrings {
+  return [
+    findMethodExcludes(dst, src),
+    findMethodExcludes(src, dst)
+  ];
+}
+
+/**
+ * @description Takes a decorated api section (e.g. api.tx) and augment it with the details. It does not override what is
+ * already available, but rather just adds new missing items into the result object.
+ * @internal
+ */
+export function augmentObject <T> (prefix: string | null, src: Sections<T>, dst: Sections<T>, fromEmpty = false): Sections<T> {
+  fromEmpty && objectClear(dst);
+
+  // NOTE: This part is slightly problematic since it will get the
+  // values for at least all the sections and the names of the methods
+  // (Since methods won't be decorated before lazy, this _may_ be ok)
+  if (prefix && Object.keys(dst).length) {
+    warn(prefix, 'modules', extractSections(src, dst));
+    warn(prefix, 'calls', extractMethods(src, dst));
+  }
+
+  const sections = Object.keys(src);
+
+  for (let i = 0, count = sections.length; i < count; i++) {
+    const section = sections[i];
+    const methods = src[section];
+
+    // We don't set here with a lazy interface, we decorate based
+    // on the top-level structure (this bypasses adding lazy onto lazy)
+    if (!dst[section]) {
+      dst[section] = {};
+    }
+
+    lazyMethods(dst[section], Object.keys(methods), (m: string) => methods[m]);
+  }
+
+  return dst;
+}

package/build-deno/util/decorate.ts

@@ -0,0 +1,38 @@
+
+import type { ExactDerive } from 'https://deno.land/x/pezkuwi/api-derive/mod.ts';
+import type { AnyFunction } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { ApiTypes, DecorateMethod, MethodResult } from '../types/index.ts';
+
+import { lazyDeriveSection } from 'https://deno.land/x/pezkuwi/api-derive/mod.ts';
+
+type AnyDeriveSection = Record<string, AnyFunction>;
+
+type AnyDerive = Record<string, AnyDeriveSection>;
+
+type DeriveSection<ApiType extends ApiTypes, Section extends AnyDeriveSection> = {
+  [M in keyof Section]: MethodResult<ApiType, Section[M]>
+};
+
+export type AllDerives<ApiType extends ApiTypes> = {
+  [S in keyof ExactDerive]: DeriveSection<ApiType, ExactDerive[S]>
+};
+
+/**
+ * This is a section decorator which keeps all type information.
+ */
+export function decorateDeriveSections<ApiType extends ApiTypes> (decorateMethod: DecorateMethod<ApiType>, derives: AnyDerive): AllDerives<ApiType> {
+  const getKeys = (s: string) =>
+    Object.keys(derives[s]);
+
+  const creator = (s: string, m: string) =>
+    decorateMethod(derives[s][m]) as AnyFunction;
+
+  const result: AnyDerive = {};
+  const names = Object.keys(derives);
+
+  for (let i = 0, count = names.length; i < count; i++) {
+    lazyDeriveSection(result, names[i], getKeys, creator);
+  }
+
+  return result as AllDerives<ApiType>;
+}

package/build-deno/util/filterEvents.ts

@@ -0,0 +1,32 @@
+
+import type { BlockNumber, EventRecord, ExtrinsicStatus, H256, SignedBlock } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+
+import { isCompact } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { l } from './logging.ts';
+
+export function filterEvents (txHash: H256, { block: { extrinsics, header } }: SignedBlock, allEvents: EventRecord[], status: ExtrinsicStatus): { events?: EventRecord[], txIndex?: number, blockNumber?: BlockNumber } {
+  // extrinsics to hashes
+  for (const [txIndex, x] of extrinsics.entries()) {
+    if (x.hash.eq(txHash)) {
+      return {
+        blockNumber: isCompact<BlockNumber>(header.number) ? header.number.unwrap() : header.number,
+        events: allEvents.filter(({ phase }) =>
+          phase.isApplyExtrinsic &&
+          phase.asApplyExtrinsic.eqn(txIndex)
+        ),
+        txIndex
+      };
+    }
+  }
+
+  // if we do get the block after finalized, it _should_ be there
+  // only warn on filtering with isInBlock (finalization finalizes after)
+  if (status.isInBlock) {
+    const allHashes = extrinsics.map((x) => x.hash.toHex());
+
+    l.warn(`block ${header.hash.toHex()}: Unable to find extrinsic ${txHash.toHex()} inside ${allHashes.join(', ')}`);
+  }
+
+  return {};
+}

package/build-deno/util/index.ts

@@ -0,0 +1,6 @@
+
+export { filterEvents } from './filterEvents.ts';
+export { isKeyringPair } from './isKeyringPair.ts';
+export { l } from './logging.ts';
+
+export * from './decorate.ts';

package/build-deno/util/isKeyringPair.ts

@@ -0,0 +1,9 @@
+
+import type { AccountId, Address } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { IKeyringPair } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+import { isFunction } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+export function isKeyringPair (account: string | IKeyringPair | AccountId | Address): account is IKeyringPair {
+  return isFunction((account as IKeyringPair).sign);
+}

package/build-deno/util/logging.ts

@@ -0,0 +1,4 @@
+
+import { logger } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+export const l = /*#__PURE__*/ logger('api/util');

package/build-deno/util/validate.ts

@@ -0,0 +1,32 @@
+
+import type { SiLookupTypeId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { StorageEntry } from 'https://deno.land/x/pezkuwi/types/primitive/types.ts';
+import type { Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+import { isUndefined } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+function sig ({ lookup }: Registry, { method, section }: StorageEntry, args: SiLookupTypeId[]): string {
+  return `${section}.${method}(${args.map((a) => lookup.getTypeDef(a).type).join(', ')})`;
+}
+
+export function extractStorageArgs (registry: Registry, creator: StorageEntry, _args: unknown[]): [StorageEntry, unknown[]] {
+  const args = _args.filter((a) => !isUndefined(a));
+
+  if (creator.meta.type.isPlain) {
+    if (args.length !== 0) {
+      throw new Error(`${sig(registry, creator, [])} does not take any arguments, ${args.length} found`);
+    }
+  } else {
+    const { hashers, key } = creator.meta.type.asMap;
+    const keys = hashers.length === 1
+      ? [key]
+      : registry.lookup.getSiType(key).def.asTuple.map((t) => t);
+
+    if (args.length !== keys.length) {
+      throw new Error(`${sig(registry, creator, keys)} is a map, requiring ${keys.length} arguments, ${args.length} found`);
+    }
+  }
+
+  // pass as tuple
+  return [creator, args];
+}

package/build-tsc/augment.d.ts

@@ -0,0 +1 @@
+import '@pezkuwi/api-augment';

package/build-tsc/base/Decorate.d.ts

@@ -0,0 +1,143 @@
+import type { Observable } from 'rxjs';
+import type { AugmentedCall, QueryableCalls } from '@pezkuwi/api-base/types';
+import type { RpcInterface } from '@pezkuwi/rpc-core/types';
+import type { Metadata, Text, Vec } from '@pezkuwi/types';
+import type { Hash, RuntimeApiMethodMetadataV16, RuntimeVersion } from '@pezkuwi/types/interfaces';
+import type { DecoratedMeta } from '@pezkuwi/types/metadata/decorate/types';
+import type { AnyFunction, Codec, DefinitionCall, DefinitionCallNamed, DefinitionRpc, DefinitionRpcSub, DefinitionsCall, DefinitionsCallEntry, DetectCodec, Registry, RegistryTypes } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import type { ApiDecoration, ApiInterfaceRx, ApiOptions, ApiTypes, DecoratedErrors, DecoratedEvents, DecoratedRpc, DecorateMethod, QueryableConsts, QueryableStorage, QueryableStorageMulti, SubmittableExtrinsics } from '../types/index.js';
+import type { AllDerives } from '../util/decorate.js';
+import type { VersionedRegistry } from './types.js';
+import { BehaviorSubject } from 'rxjs';
+import { RpcCore } from '@pezkuwi/rpc-core';
+import { BN } from '@pezkuwi/util';
+import { Events } from './Events.js';
+interface FullDecoration<ApiType extends ApiTypes> {
+    createdAt?: Uint8Array | undefined;
+    decoratedApi: ApiDecoration<ApiType>;
+    decoratedMeta: DecoratedMeta;
+}
+export declare abstract class Decorate<ApiType extends ApiTypes> extends Events {
+    #private;
+    protected __phantom: BN;
+    protected _type: ApiTypes;
+    protected _call: QueryableCalls<ApiType>;
+    protected _consts: QueryableConsts<ApiType>;
+    protected _derive?: ReturnType<Decorate<ApiType>['_decorateDerive']>;
+    protected _errors: DecoratedErrors<ApiType>;
+    protected _events: DecoratedEvents<ApiType>;
+    protected _extrinsics?: SubmittableExtrinsics<ApiType>;
+    protected _extrinsicType: number;
+    protected _genesisHash?: Hash;
+    protected _isConnected: BehaviorSubject<boolean>;
+    protected _isReady: boolean;
+    protected _query: QueryableStorage<ApiType>;
+    protected _queryMulti?: QueryableStorageMulti<ApiType>;
+    protected _rpc?: DecoratedRpc<ApiType, RpcInterface>;
+    protected _rpcCore: RpcCore & RpcInterface;
+    protected _runtimeMap: Record<HexString, string>;
+    protected _runtimeChain?: Text;
+    protected _runtimeMetadata?: Metadata;
+    protected _runtimeVersion?: RuntimeVersion;
+    protected _rx: ApiInterfaceRx;
+    protected readonly _options: ApiOptions;
+    /**
+     * This is the one and only method concrete children classes need to implement.
+     * It's a higher-order function, which takes one argument
+     * `method: Method extends (...args: any[]) => Observable<any>`
+     * (and one optional `options`), and should return the user facing method.
+     * For example:
+     * - For ApiRx, `decorateMethod` should just be identity, because the input
+     * function is already an Observable
+     * - For ApiPromise, `decorateMethod` should return a function that takes all
+     * the parameters from `method`, adds an optional `callback` argument, and
+     * returns a Promise.
+     *
+     * We could easily imagine other user-facing interfaces, which are simply
+     * implemented by transforming the Observable to Stream/Iterator/Kefir/Bacon
+     * via `decorateMethod`.
+     */
+    protected _decorateMethod: DecorateMethod<ApiType>;
+    /**
+     * @description Create an instance of the class
+     *
+     * @param options Options object to create API instance or a Provider instance
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * import Api from '@pezkuwi/api/promise';
+     *
+     * const api = new Api().isReady();
+     *
+     * api.rpc.subscribeNewHeads((header) => {
+     *   console.log(`new block #${header.number.toNumber()}`);
+     * });
+     * ```
+     */
+    constructor(options: ApiOptions, type: ApiTypes, decorateMethod: DecorateMethod<ApiType>);
+    abstract at(blockHash: Uint8Array | string, knownVersion?: RuntimeVersion): Promise<ApiDecoration<ApiType>>;
+    /**
+     * @description Return the current used registry
+     */
+    get registry(): Registry;
+    /**
+     * @description Creates an instance of a type as registered
+     */
+    createType<T extends Codec = Codec, K extends string = string>(type: K, ...params: unknown[]): DetectCodec<T, K>;
+    /**
+     * @description Register additional user-defined of chain-specific types in the type registry
+     */
+    registerTypes(types?: RegistryTypes): void;
+    /**
+     * @returns `true` if the API operates with subscriptions
+     */
+    get hasSubscriptions(): boolean;
+    /**
+     * @returns `true` if the API decorate multi-key queries
+     */
+    get supportMulti(): boolean;
+    protected _emptyDecorated(registry: Registry, blockHash?: Uint8Array): ApiDecoration<ApiType>;
+    protected _createDecorated(registry: VersionedRegistry<ApiType>, fromEmpty: boolean, decoratedApi: ApiDecoration<ApiType> | null, blockHash?: Uint8Array): FullDecoration<ApiType>;
+    protected _injectMetadata(registry: VersionedRegistry<ApiType>, fromEmpty?: boolean): void;
+    /**
+     * @deprecated
+     * backwards compatible endpoint for metadata injection, may be removed in the future (However, it is still useful for testing injection)
+     */
+    injectMetadata(metadata: Metadata, fromEmpty?: boolean, registry?: Registry): void;
+    private _decorateFunctionMeta;
+    protected _filterRpc(methods: string[], additional: Record<string, Record<string, DefinitionRpc | DefinitionRpcSub>>): void;
+    protected _filterRpcMethods(exposed: string[]): void;
+    private _rpcSubmitter;
+    protected _decorateRpc<ApiType extends ApiTypes>(rpc: RpcCore & RpcInterface, decorateMethod: DecorateMethod<ApiType>, input?: Partial<DecoratedRpc<ApiType, RpcInterface>>): DecoratedRpc<ApiType, RpcInterface>;
+    protected _addRuntimeDef(result: DefinitionsCall, additional?: DefinitionsCall): void;
+    protected _getRuntimeDefs(registry: Registry, specName: Text, chain?: Text | string): [string, DefinitionsCallEntry[]][];
+    protected _getMethods(registry: Registry, methods: Vec<RuntimeApiMethodMetadataV16>): Record<string, DefinitionCall>;
+    protected _getRuntimeDefsViaMetadata(registry: Registry): [string, DefinitionsCallEntry[]][];
+    protected _decorateCalls<ApiType extends ApiTypes>({ registry, runtimeVersion: { apis, specName, specVersion } }: VersionedRegistry<any>, decorateMethod: DecorateMethod<ApiType>, blockHash?: Uint8Array | string | null): QueryableCalls<ApiType>;
+    protected _decorateCall<ApiType extends ApiTypes>(registry: Registry, def: DefinitionCallNamed, stateCall: (method: string, bytes: Uint8Array) => Observable<Codec>, decorateMethod: DecorateMethod<ApiType>): AugmentedCall<ApiType>;
+    protected _decorateMulti<ApiType extends ApiTypes>(decorateMethod: DecorateMethod<ApiType>): QueryableStorageMulti<ApiType>;
+    protected _decorateMultiAt<ApiType extends ApiTypes>(atApi: ApiDecoration<ApiType>, decorateMethod: DecorateMethod<ApiType>, blockHash: Uint8Array | string): QueryableStorageMulti<ApiType>;
+    protected _decorateExtrinsics<ApiType extends ApiTypes>({ tx }: DecoratedMeta, decorateMethod: DecorateMethod<ApiType>): SubmittableExtrinsics<ApiType>;
+    private _decorateExtrinsicEntry;
+    protected _decorateStorage<ApiType extends ApiTypes>({ query, registry }: DecoratedMeta, decorateMethod: DecorateMethod<ApiType>, blockHash?: Uint8Array): QueryableStorage<ApiType>;
+    private _decorateStorageEntry;
+    private _decorateStorageEntryAt;
+    private _queueStorage;
+    private _decorateStorageCall;
+    private _retrieveMulti;
+    private _retrieveMapKeys;
+    private _retrieveMapKeysPaged;
+    private _retrieveMapEntries;
+    private _retrieveMapEntriesPaged;
+    protected _decorateDeriveRx(decorateMethod: DecorateMethod<ApiType>): AllDerives<'rxjs'>;
+    protected _decorateDerive(decorateMethod: DecorateMethod<ApiType>): AllDerives<ApiType>;
+    /**
+     * Put the `this.onCall` function of ApiRx here, because it is needed by
+     * `api._rx`.
+     */
+    protected _rxDecorateMethod: <Method extends AnyFunction>(method: Method) => Method;
+}
+export {};

package/build-tsc/base/Events.d.ts

@@ -0,0 +1,67 @@
+import type { ApiInterfaceEvents } from '../types/index.js';
+export declare class Events {
+    #private;
+    protected emit(type: ApiInterfaceEvents, ...args: unknown[]): boolean;
+    /**
+     * @description Attach an eventemitter handler to listen to a specific event
+     *
+     * @param type The type of event to listen to. Available events are `connected`, `disconnected`, `ready` and `error`
+     * @param handler The callback to be called when the event fires. Depending on the event type, it could fire with additional arguments.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.on('connected', (): void => {
+     *   console.log('API has been connected to the endpoint');
+     * });
+     *
+     * api.on('disconnected', (): void => {
+     *   console.log('API has been disconnected from the endpoint');
+     * });
+     * ```
+     */
+    on(type: ApiInterfaceEvents, handler: (...args: any[]) => any): this;
+    /**
+     * @description Remove the given eventemitter handler
+     *
+     * @param type The type of event the callback was attached to. Available events are `connected`, `disconnected`, `ready` and `error`
+     * @param handler The callback to unregister.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * const handler = (): void => {
+     *  console.log('Connected !);
+     * };
+     *
+     * // Start listening
+     * api.on('connected', handler);
+     *
+     * // Stop listening
+     * api.off('connected', handler);
+     * ```
+     */
+    off(type: ApiInterfaceEvents, handler: (...args: any[]) => any): this;
+    /**
+     * @description Attach an one-time eventemitter handler to listen to a specific event
+     *
+     * @param type The type of event to listen to. Available events are `connected`, `disconnected`, `ready` and `error`
+     * @param handler The callback to be called when the event fires. Depending on the event type, it could fire with additional arguments.
+     *
+     * @example
+     * <BR>
+     *
+     * ```javascript
+     * api.once('connected', (): void => {
+     *   console.log('API has been connected to the endpoint');
+     * });
+     *
+     * api.once('disconnected', (): void => {
+     *   console.log('API has been disconnected from the endpoint');
+     * });
+     * ```
+     */
+    once(type: ApiInterfaceEvents, handler: (...args: any[]) => any): this;
+}