signify-ts 0.1.0 → 0.2.0

package/dist/keri/core/core.d.ts

@@ -1,68 +1,59 @@
-export declare const VERRAWSIZE = 6;
-export declare const Versionage: {
-    major: number;
-    minor: number;
-};
-export declare const Serialage: {
-    json: string;
-    mgpk: string;
-    cbor: string;
-};
-export declare const Vstrings: {
-    json: string;
-    mgpk: string;
-    cbor: string;
-};
-export declare const Serials: {
-    json: string;
-    mgpk: string;
-    cbor: string;
-};
-export declare const IcpExcludes: string[];
-export declare const DipExcludes: string[];
-export declare const Ilks: {
-    icp: string;
-    rot: string;
-    ixn: string;
-    dip: string;
-    drt: string;
-    rct: string;
-    vrc: string;
-};
-export declare const IcpLabels: string[];
-export declare const DipLabels: string[];
-export declare const RotLabels: string[];
-export declare const DrtLabels: string[];
-export declare const IxnLabels: string[];
-export declare const KsnLabels: string[];
-export declare const RpyLabels: string[];
-export declare const VERFULLSIZE = 17;
-export declare const MINSNIFFSIZE: number;
-export declare const MINSIGSIZE = 4;
-/**
- * @description  It will return version string
- */
-export declare function versify(version: {
-    major: number;
-    minor: number;
-}, kind: string | undefined, size: number): string;
-export declare const VEREX = "KERI([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})";
-/**
- * @description This function is use to deversify the version
- * Here we will use regex to  to validate and extract serialization kind,size and version
- * @param {string} vs   version string
- * @return {Object}  contaning kind of serialization like cbor,json,mgpk
- *                    version = version of object ,size = raw size integer
- */
-export declare function deversify(versionString: string): (string | {
-    major: number;
-    minor: number;
-})[];
-export declare const B64ChrByIdx: Map<number, string>;
-export declare const B64IdxByChr: Map<string, number>;
-export declare function intToB64(i: number | undefined, l?: number): string;
-export declare function intToB64b(n: number, l?: number): Uint8Array;
-export declare function b64ToInt(s: string): number;
-export declare function b(s?: string): Uint8Array;
-export declare function d(u?: Uint8Array): string;
-export declare function readInt(array: Uint8Array): number;
+export declare enum Serials {
+    JSON = "JSON"
+}
+export declare enum Ident {
+    KERI = "KERI",
+    ACDC = "ACDC"
+}
+export declare class Version {
+    major: number;
+    minor: number;
+    constructor(major?: number, minor?: number);
+}
+export declare const Versionage: Version;
+export declare const Ilks: {
+    icp: string;
+    rot: string;
+    ixn: string;
+    dip: string;
+    drt: string;
+    rct: string;
+    vrc: string;
+    rpy: string;
+    exn: string;
+    vcp: string;
+    iss: string;
+    rev: string;
+};
+export declare const IcpLabels: string[];
+export declare const DipLabels: string[];
+export declare const RotLabels: string[];
+export declare const DrtLabels: string[];
+export declare const IxnLabels: string[];
+export declare const KsnLabels: string[];
+export declare const RpyLabels: string[];
+export declare const VERFULLSIZE = 17;
+export declare const MINSNIFFSIZE: number;
+export declare const MINSIGSIZE = 4;
+export declare const VEREX = "(KERI|ACDC)([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})_";
+export interface Dict<TValue> {
+    [id: string]: TValue;
+}
+/**
+ * @description This function is use to deversify the version
+ * Here we will use regex to  to validate and extract serialization kind,size and version
+ * @param {string} versionString   version string
+ * @return {Object}  contaning prototol (KERI or ACDC), kind of serialization like cbor,json,mgpk
+ *                    version = version of object ,size = raw size integer
+ */
+export declare function deversify(versionString: string): [Ident, Serials, Version, string];
+export declare function versify(ident?: Ident, version?: Version, kind?: Serials, size?: number): string;
+export declare const B64ChrByIdx: Map<number, string>;
+export declare const B64IdxByChr: Map<string, number>;
+export declare function intToB64(i: number, l?: number): string;
+export declare function intToB64b(n: number, l?: number): Uint8Array;
+export declare function b64ToInt(s: string): number;
+export declare function b(s?: string): Uint8Array;
+export declare function d(u?: Uint8Array): string;
+export declare function concat(one: Uint8Array, two: Uint8Array): Uint8Array;
+export declare function readInt(array: Uint8Array): number;

package/dist/keri/core/counter.d.ts

@@ -0,0 +1,43 @@
+import { Codex, Sizage } from './matter';
+export interface CounterArgs {
+    code?: string;
+    count?: number;
+    countB64?: string;
+    qb64b?: Uint8Array;
+    qb64?: string;
+    qb2?: Uint8Array;
+    strip?: boolean;
+}
+export declare class CounterCodex extends Codex {
+    ControllerIdxSigs: string;
+    WitnessIdxSigs: string;
+    NonTransReceiptCouples: string;
+    TransReceiptQuadruples: string;
+    FirstSeenReplayCouples: string;
+    TransIdxSigGroups: string;
+    SealSourceCouples: string;
+    TransLastIdxSigGroups: string;
+    SealSourceTriples: string;
+    SadPathSig: string;
+    SadPathSigGroup: string;
+    PathedMaterialQuadlets: string;
+    AttachedMaterialQuadlets: string;
+    BigAttachedMaterialQuadlets: string;
+    KERIProtocolStack: string;
+}
+export declare const CtrDex: CounterCodex;
+export declare class Counter {
+    static Sizes: Map<string, Sizage>;
+    static Hards: Map<string, number>;
+    private _code;
+    private _count;
+    constructor({ code, count, countB64, qb64b, qb64, qb2 }: CounterArgs);
+    get code(): string;
+    get count(): number;
+    get qb64(): string;
+    get qb64b(): Uint8Array;
+    countToB64(l?: number): string;
+    static semVerToB64(version?: string, major?: number, minor?: number, patch?: number): string;
+    private _infil;
+    private _exfil;
+}

package/dist/keri/core/decrypter.d.ts

@@ -1,10 +1,10 @@
-import { Matter, MatterArgs } from './matter';
-import { Signer } from "./signer";
-import { Cipher } from "./cipher";
-import { Salter } from "./salter";
-export declare class Decrypter extends Matter {
-    private readonly _decrypt;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, seed?: Uint8Array | undefined);
-    decrypt(ser?: Uint8Array | null, cipher?: Cipher | null, transferable?: boolean): any;
-    _x25519(cipher: Cipher, prikey: Uint8Array, transferable?: boolean): Signer | Salter;
-}
+import { Matter, MatterArgs } from './matter';
+import { Signer } from './signer';
+import { Cipher } from './cipher';
+import { Salter } from './salter';
+export declare class Decrypter extends Matter {
+    private readonly _decrypt;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, seed?: Uint8Array | undefined);
+    decrypt(ser?: Uint8Array | null, cipher?: Cipher | null, transferable?: boolean): any;
+    _x25519(cipher: Cipher, prikey: Uint8Array, transferable?: boolean): Signer | Salter;
+}

package/dist/keri/core/diger.d.ts

@@ -1,21 +1,21 @@
-import { Matter, MatterArgs } from './matter';
-/**
- * @description : Diger is subset of Matter and is used to verify the digest of serialization
- * It uses  .raw : as digest
- * .code as digest algorithm
- *
- */
-export declare class Diger extends Matter {
-    private readonly _verify;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, ser?: Uint8Array | null);
-    /**
-     *
-     * @param {Uint8Array} ser  serialization bytes
-     * @description  This method will return true if digest of bytes serialization ser matches .raw
-     * using .raw as reference digest for ._verify digest algorithm determined
-     by .code
-     */
-    verify(ser: Uint8Array): boolean;
-    compare(ser: Uint8Array, dig?: any, diger?: Diger | null): boolean;
-    blake3_256(ser: Uint8Array, dig: any): boolean;
-}
+import { Matter, MatterArgs } from './matter';
+/**
+ * @description : Diger is subset of Matter and is used to verify the digest of serialization
+ * It uses  .raw : as digest
+ * .code as digest algorithm
+ *
+ */
+export declare class Diger extends Matter {
+    private readonly _verify;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, ser?: Uint8Array | null);
+    /**
+     *
+     * @param {Uint8Array} ser  serialization bytes
+     * @description  This method will return true if digest of bytes serialization ser matches .raw
+     * using .raw as reference digest for ._verify digest algorithm determined
+     by .code
+     */
+    verify(ser: Uint8Array): boolean;
+    compare(ser: Uint8Array, dig?: any, diger?: Diger | null): boolean;
+    blake3_256(ser: Uint8Array, dig: any): boolean;
+}

package/dist/keri/core/encrypter.d.ts

@@ -1,9 +1,9 @@
-import { Matter, MatterArgs } from './matter';
-import { Cipher } from "./cipher";
-export declare class Encrypter extends Matter {
-    private _encrypt;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verkey?: Uint8Array | null);
-    verifySeed(seed: Uint8Array): boolean;
-    encrypt(ser?: Uint8Array | null, matter?: Matter | null): any;
-    _x25519(ser: Uint8Array, pubkey: Uint8Array, code: string): Cipher;
-}
+import { Matter, MatterArgs } from './matter';
+import { Cipher } from './cipher';
+export declare class Encrypter extends Matter {
+    private _encrypt;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verkey?: Uint8Array | null);
+    verifySeed(seed: Uint8Array): boolean;
+    encrypt(ser?: Uint8Array | null, matter?: Matter | null): any;
+    _x25519(ser: Uint8Array, pubkey: Uint8Array, code: string): Cipher;
+}

package/dist/keri/core/eventing.d.ts

@@ -0,0 +1,54 @@
+import { Serials, Version } from './core';
+import { Serder } from './serder';
+import { Siger } from './siger';
+import { Cigar } from './cigar';
+export interface RotateArgs {
+    pre?: string;
+    keys: Array<string>;
+    dig?: string;
+    ilk?: string;
+    sn?: number;
+    isith?: number | string | Array<string>;
+    ndigs?: Array<string>;
+    nsith?: number | string | Array<string>;
+    toad?: number;
+    wits?: Array<string>;
+    cuts?: Array<string>;
+    adds?: Array<string>;
+    cnfg?: Array<string>;
+    data?: Array<object>;
+    version?: Version;
+    kind?: Serials;
+    size?: number;
+    intive?: boolean;
+}
+export declare function rotate({ pre, keys, dig, ilk, sn, isith, ndigs, nsith, wits, cuts, adds, toad, data, version, kind, intive, }: RotateArgs): Serder;
+export declare function ample(n: number, f?: number, weak?: boolean): number;
+export interface InceptArgs {
+    keys: Array<string>;
+    isith?: number | string | Array<string>;
+    ndigs?: Array<string>;
+    nsith?: number | string | Array<string>;
+    toad?: number | string;
+    wits?: Array<string>;
+    cnfg?: Array<string>;
+    data?: Array<object>;
+    version?: Version;
+    kind?: Serials;
+    code?: string;
+    intive?: boolean;
+    delpre?: string;
+}
+export declare function incept({ keys, isith, ndigs, nsith, toad, wits, cnfg, data, version, kind, code, intive, delpre, }: InceptArgs): Serder;
+export declare function messagize(serder: Serder, sigers?: Array<Siger>, seal?: any, wigers?: Array<Cigar>, cigars?: Array<Cigar>, pipelined?: boolean): Uint8Array;
+interface InteractArgs {
+    pre: string;
+    dig: string;
+    sn: number;
+    data: Array<any>;
+    version: Version | undefined;
+    kind: Serials | undefined;
+}
+export declare function interact(args: InteractArgs): Serder;
+export declare function reply(route: string | undefined, data: any | undefined, stamp: string | undefined, version: Version | undefined, kind?: Serials): Serder;
+export {};

package/dist/keri/core/httping.d.ts

@@ -0,0 +1,44 @@
+import { Signer } from './signer';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
+export declare function normalize(header: string): string;
+export interface SiginputArgs {
+    name: string;
+    method: string;
+    path: string;
+    headers: Headers;
+    fields: Array<string>;
+    expires?: number;
+    nonce?: string;
+    alg?: string;
+    keyid?: string;
+    context?: string;
+}
+export declare function siginput(signer: Signer, { name, method, path, headers, fields, expires, nonce, alg, keyid, context, }: SiginputArgs): [Map<string, string>, Siger | Cigar];
+export declare class Unqualified {
+    private readonly _raw;
+    constructor(raw: Uint8Array);
+    get qb64(): string;
+    get qb64b(): Uint8Array;
+}
+export declare class Inputage {
+    name: any;
+    fields: any;
+    created: any;
+    expires: any;
+    nonce: any;
+    alg: any;
+    keyid: any;
+    context: any;
+}
+export declare function desiginput(value: string): Array<Inputage>;
+/** Parse start, end and total from HTTP Content-Range header value
+ * @param {string|null} header - HTTP Range header value
+ * @param {string} typ - type of range, e.g. "aids"
+ * @returns {start: number, end: number, total: number} - object with start, end and total properties
+ */
+export declare function parseRangeHeaders(header: string | null, typ: string): {
+    start: number;
+    end: number;
+    total: number;
+};

package/dist/keri/core/indexer.d.ts

@@ -1,88 +1,98 @@
-export declare class IndexerCodex {
-    Ed25519_Sig: string;
-    Ed25519_Crt_Sig: string;
-    ECDSA_256k1_Sig: string;
-    ECDSA_256k1_Crt_Sig: string;
-    Ed448_Sig: string;
-    Ed448_Crt_Sig: string;
-    Ed25519_Big_Sig: string;
-    Ed25519_Big_Crt_Sig: string;
-    ECDSA_256k1_Big_Sig: string;
-    ECDSA_256k1_Big_Crt_Sig: string;
-    Ed448_Big_Sig: string;
-    Ed448_Big_Crt_Sig: string;
-}
-export declare const IdrDex: IndexerCodex;
-export declare class IndexedSigCodex {
-    Ed25519_Sig: string;
-    Ed25519_Crt_Sig: string;
-    ECDSA_256k1_Sig: string;
-    ECDSA_256k1_Crt_Sig: string;
-    Ed448_Sig: string;
-    Ed448_Crt_Sig: string;
-    Ed25519_Big_Sig: string;
-    Ed25519_Big_Crt_Sig: string;
-    ECDSA_256k1_Big_Sig: string;
-    ECDSA_256k1_Big_Crt_Sig: string;
-    Ed448_Big_Sig: string;
-    Ed448_Big_Crt_Sig: string;
-    has(prop: string): boolean;
-}
-export declare const IdxSigDex: IndexedSigCodex;
-export declare class IndexedCurrentSigCodex {
-    Ed25519_Crt_Sig: string;
-    ECDSA_256k1_Crt_Sig: string;
-    Ed448_Crt_Sig: string;
-    Ed25519_Big_Crt_Sig: string;
-    ECDSA_256k1_Big_Crt_Sig: string;
-    Ed448_Big_Crt_Sig: string;
-    has(prop: string): boolean;
-}
-export declare const IdxCrtSigDex: IndexedCurrentSigCodex;
-export declare class IndexedBothSigCodex {
-    Ed25519_Sig: string;
-    ECDSA_256k1_Sig: string;
-    Ed448_Sig: string;
-    Ed25519_Big_Sig: string;
-    ECDSA_256k1_Big_Sig: string;
-    Ed448_Big_Sig: string;
-    has(prop: string): boolean;
-}
-export declare const IdxBthSigDex: IndexedBothSigCodex;
-export declare class Xizage {
-    hs: number;
-    ss: number;
-    os: number;
-    fs?: number;
-    ls: number;
-    constructor(hs: number, ss: number, os: number, fs?: number, ls?: number);
-}
-export interface IndexerArgs {
-    raw?: Uint8Array | undefined;
-    code?: string | undefined;
-    index?: number;
-    ondex?: number;
-    qb64b?: Uint8Array | undefined;
-    qb64?: string | undefined;
-    qb2?: Uint8Array | undefined;
-}
-export declare class Indexer {
-    Codex: IndexerCodex;
-    static Hards: Map<string, number>;
-    static Sizes: Map<string, Xizage>;
-    private _code;
-    private _index;
-    private _ondex;
-    private _raw;
-    constructor({ raw, code, index, ondex, qb64b, qb64, qb2 }: IndexerArgs);
-    private _bexfil;
-    static _rawSize(code: string): number;
-    get code(): string;
-    get raw(): Uint8Array;
-    get index(): number;
-    get ondex(): number | undefined;
-    get qb64(): string;
-    get qb64b(): Uint8Array;
-    private _infil;
-    _exfil(qb64: string): void;
-}
+export declare class IndexerCodex {
+    Ed25519_Sig: string;
+    Ed25519_Crt_Sig: string;
+    ECDSA_256k1_Sig: string;
+    ECDSA_256k1_Crt_Sig: string;
+    ECDSA_256r1_Sig: string;
+    ECDSA_256r1_Crt_Sig: string;
+    Ed448_Sig: string;
+    Ed448_Crt_Sig: string;
+    Ed25519_Big_Sig: string;
+    Ed25519_Big_Crt_Sig: string;
+    ECDSA_256k1_Big_Sig: string;
+    ECDSA_256k1_Big_Crt_Sig: string;
+    ECDSA_256r1_Big_Sig: string;
+    ECDSA_256r1_Big_Crt_Sig: string;
+    Ed448_Big_Sig: string;
+    Ed448_Big_Crt_Sig: string;
+}
+export declare const IdrDex: IndexerCodex;
+export declare class IndexedSigCodex {
+    Ed25519_Sig: string;
+    Ed25519_Crt_Sig: string;
+    ECDSA_256k1_Sig: string;
+    ECDSA_256k1_Crt_Sig: string;
+    ECDSA_256r1_Sig: string;
+    ECDSA_256r1_Crt_Sig: string;
+    Ed448_Sig: string;
+    Ed448_Crt_Sig: string;
+    Ed25519_Big_Sig: string;
+    Ed25519_Big_Crt_Sig: string;
+    ECDSA_256k1_Big_Sig: string;
+    ECDSA_256k1_Big_Crt_Sig: string;
+    ECDSA_256r1_Big_Sig: string;
+    ECDSA_256r1_Big_Crt_Sig: string;
+    Ed448_Big_Sig: string;
+    Ed448_Big_Crt_Sig: string;
+    has(prop: string): boolean;
+}
+export declare const IdxSigDex: IndexedSigCodex;
+export declare class IndexedCurrentSigCodex {
+    Ed25519_Crt_Sig: string;
+    ECDSA_256k1_Crt_Sig: string;
+    ECDSA_256r1_Crt_Sig: string;
+    Ed448_Crt_Sig: string;
+    Ed25519_Big_Crt_Sig: string;
+    ECDSA_256k1_Big_Crt_Sig: string;
+    ECDSA_256r1_Big_Crt_Sig: string;
+    Ed448_Big_Crt_Sig: string;
+    has(prop: string): boolean;
+}
+export declare const IdxCrtSigDex: IndexedCurrentSigCodex;
+export declare class IndexedBothSigCodex {
+    Ed25519_Sig: string;
+    ECDSA_256k1_Sig: string;
+    Ed448_Sig: string;
+    Ed25519_Big_Sig: string;
+    ECDSA_256k1_Big_Sig: string;
+    Ed448_Big_Sig: string;
+    has(prop: string): boolean;
+}
+export declare const IdxBthSigDex: IndexedBothSigCodex;
+export declare class Xizage {
+    hs: number;
+    ss: number;
+    os: number;
+    fs?: number;
+    ls: number;
+    constructor(hs: number, ss: number, os: number, fs?: number, ls?: number);
+}
+export interface IndexerArgs {
+    raw?: Uint8Array | undefined;
+    code?: string | undefined;
+    index?: number;
+    ondex?: number;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string | undefined;
+    qb2?: Uint8Array | undefined;
+}
+export declare class Indexer {
+    Codex: IndexerCodex;
+    static Hards: Map<string, number>;
+    static Sizes: Map<string, Xizage>;
+    private _code;
+    private _index;
+    private _ondex;
+    private _raw;
+    constructor({ raw, code, index, ondex, qb64b, qb64, qb2, }: IndexerArgs);
+    private _bexfil;
+    static _rawSize(code: string): number;
+    get code(): string;
+    get raw(): Uint8Array;
+    get index(): number;
+    get ondex(): number | undefined;
+    get qb64(): string;
+    get qb64b(): Uint8Array;
+    private _infil;
+    _exfil(qb64: string): void;
+}

package/dist/keri/core/keeping.d.ts

@@ -1 +1,103 @@
-export {};
+import { Salter } from './salter';
+import { Algos } from './manager';
+import { Tier } from './salter';
+import { Signer } from './signer';
+import { Siger } from './siger';
+import { Cigar } from './cigar';
+export {};
+/** External module definition */
+export interface ExternalModule {
+    type: string;
+    name: string;
+    module: any;
+}
+export declare class KeyManager {
+    private salter?;
+    private modules?;
+    constructor(salter: Salter, externalModules?: ExternalModule[]);
+    new(algo: Algos, pidx: number, kargs: any): any;
+    get(aid: any): any;
+}
+export declare class SaltyKeeper {
+    private aeid;
+    private encrypter;
+    private decrypter;
+    private salter;
+    private pidx;
+    private kidx;
+    private tier;
+    private transferable;
+    private stem;
+    private code;
+    private count;
+    private icodes;
+    private ncode;
+    private ncount;
+    private ncodes;
+    private dcode;
+    private sxlt;
+    private bran;
+    private creator;
+    algo: Algos;
+    signers: Signer[];
+    constructor(salter: Salter, pidx: number, kidx?: number, tier?: Tier, transferable?: boolean, stem?: undefined, code?: string, count?: number, icodes?: string[] | undefined, ncode?: string, ncount?: number, ncodes?: string[] | undefined, dcode?: string, bran?: string | undefined, sxlt?: undefined);
+    params(): {
+        sxlt: string | undefined;
+        pidx: number;
+        kidx: number;
+        stem: string | undefined;
+        tier: Tier;
+        icodes: string[] | undefined;
+        ncodes: string[] | undefined;
+        dcode: string | undefined;
+        transferable: boolean;
+    };
+    incept(transferable: boolean): string[][];
+    rotate(ncodes: string[], transferable: boolean, ..._: any[]): string[][];
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): string[];
+}
+export declare class RandyKeeper {
+    private salter;
+    private code;
+    private count;
+    private icodes;
+    private transferable;
+    private ncount;
+    private ncodes;
+    private ncode;
+    private dcode;
+    private prxs;
+    private nxts;
+    private aeid;
+    private encrypter;
+    private decrypter;
+    private creator;
+    algo: Algos;
+    signers: Signer[];
+    constructor(salter: Salter, code: string | undefined, count: number | undefined, icodes: string[] | undefined, transferable: boolean | undefined, ncode: string | undefined, ncount: number | undefined, ncodes: string[], dcode?: string, prxs?: string[] | undefined, nxts?: string[] | undefined);
+    params(): {
+        nxts: string[] | undefined;
+        prxs: string[] | undefined;
+        transferable: boolean;
+    };
+    incept(transferable: boolean): string[][];
+    rotate(ncodes: string[], transferable: boolean, ..._: any[]): any[][];
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: number[] | undefined): any[];
+}
+export declare class GroupKeeper {
+    private manager;
+    private mhab;
+    private gkeys;
+    private gdigs;
+    algo: Algos;
+    signers: Signer[];
+    constructor(manager: KeyManager, mhab?: undefined, states?: any[] | undefined, rstates?: any[] | undefined, keys?: any[] | undefined, ndigs?: any[] | undefined);
+    incept(..._: any): (string[] | undefined)[];
+    rotate(_ncodes: string[], _transferable: boolean, states: any[], rstates: any[], ..._: any): string[][];
+    sign(ser: Uint8Array, indexed?: boolean, _indices?: number[] | undefined, _ondices?: number[] | undefined): Promise<Siger[] | Cigar[]>;
+    params(): {
+        mhab: any;
+        keys: string[] | undefined;
+        ndigs: string[] | undefined;
+    };
+}

package/dist/keri/core/kering.d.ts

@@ -1,5 +1,5 @@
-export declare class EmptyMaterialError {
-    private readonly _err;
-    constructor(err: string);
-    get err(): Error;
-}
+export declare class EmptyMaterialError {
+    private readonly _err;
+    constructor(err: string);
+    get err(): Error;
+}