signify-ts 0.1.0 → 0.2.0

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

@@ -1,22 +1,22 @@
-import { Indexer, IndexerArgs } from "./indexer";
-import { Verfer } from "./verfer";
-/**
-   Siger is subclass of Indexer, indexed signature material,
-    Adds .verfer property which is instance of Verfer that provides
-          associated signature verifier.
+import { Indexer, IndexerArgs } from './indexer';
+import { Verfer } from './verfer';
+/**
+   Siger is subclass of Indexer, indexed signature material,
+    Adds .verfer property which is instance of Verfer that provides
+          associated signature verifier.
 
-    See Indexer for inherited attributes and properties:
+    See Indexer for inherited attributes and properties:
 
-    Attributes:
+    Attributes:
 
-    Properties:
-        .verfer is Verfer object instance
+    Properties:
+        .verfer is Verfer object instance
 
-    Methods:
- **/
-export declare class Siger extends Indexer {
-    private _verfer?;
-    constructor({ raw, code, qb64, qb64b, qb2 }: IndexerArgs, verfer?: Verfer);
-    get verfer(): Verfer | undefined;
-    set verfer(verfer: Verfer | undefined);
-}
+    Methods:
+ **/
+export declare class Siger extends Indexer {
+    private _verfer?;
+    constructor({ raw, code, index, ondex, qb64, qb64b, qb2 }: IndexerArgs, verfer?: Verfer);
+    get verfer(): Verfer | undefined;
+    set verfer(verfer: Verfer | undefined);
+}

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

@@ -1,34 +1,34 @@
-export {};
-import { Matter } from './matter';
-import { Verfer } from "./verfer";
-import { Cigar } from "./cigar";
-import { Siger } from "./siger";
-/**
- * @description Signer is Matter subclass with method to create signature of serialization
- * It will use .raw as signing (private) key seed
- * .code as cipher suite for signing and new property .verfer whose property
- *  .raw is public key for signing.
- *  If not provided .verfer is generated from private key seed using .code
- as cipher suite for creating key-pair.
- */
-interface SignerArgs {
-    raw?: Uint8Array | undefined;
-    code?: string;
-    qb64b?: Uint8Array | undefined;
-    qb64?: string;
-    qb2?: Uint8Array | undefined;
-    transferable?: boolean;
-}
-export declare class Signer extends Matter {
-    private readonly _sign;
-    private readonly _verfer;
-    constructor({ raw, code, qb64, qb64b, qb2, transferable }: SignerArgs);
-    /**
-     * @description Property verfer:
-     Returns Verfer instance
-     Assumes ._verfer is correctly assigned
-     */
-    get verfer(): Verfer;
-    sign(ser: Uint8Array, index?: number | null, only?: boolean, ondex?: number | undefined): any;
-    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null, only: boolean | undefined, ondex: number | undefined): Cigar | Siger;
-}
+export {};
+import { Matter } from './matter';
+import { Verfer } from './verfer';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
+/**
+ * @description Signer is Matter subclass with method to create signature of serialization
+ * It will use .raw as signing (private) key seed
+ * .code as cipher suite for signing and new property .verfer whose property
+ *  .raw is public key for signing.
+ *  If not provided .verfer is generated from private key seed using .code
+ as cipher suite for creating key-pair.
+ */
+interface SignerArgs {
+    raw?: Uint8Array | undefined;
+    code?: string;
+    qb64b?: Uint8Array | undefined;
+    qb64?: string;
+    qb2?: Uint8Array | undefined;
+    transferable?: boolean;
+}
+export declare class Signer extends Matter {
+    private readonly _sign;
+    private readonly _verfer;
+    constructor({ raw, code, qb64, qb64b, qb2, transferable, }: SignerArgs);
+    /**
+     * @description Property verfer:
+     Returns Verfer instance
+     Assumes ._verfer is correctly assigned
+     */
+    get verfer(): Verfer;
+    sign(ser: Uint8Array, index?: number | null, only?: boolean, ondex?: number | undefined): Siger | Cigar;
+    _ed25519(ser: Uint8Array, seed: Uint8Array, verfer: Verfer, index: number | null, only: boolean | undefined, ondex: number | undefined): Cigar | Siger;
+}

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

@@ -0,0 +1,29 @@
+export declare class Tholder {
+    private _weighted;
+    private _thold;
+    private _size;
+    private _number;
+    private _satisfy;
+    constructor(kargs: {
+        thold?: any;
+        limen?: any;
+        sith?: any;
+    });
+    get weighted(): boolean;
+    get thold(): any;
+    get size(): number;
+    get limen(): any;
+    get sith(): string;
+    get json(): string;
+    get num(): number | undefined;
+    private _processThold;
+    private _processLimen;
+    private _processSith;
+    private _processClauses;
+    private _processUnweighted;
+    private _processWeighted;
+    private weight;
+    private _satisfy_numeric;
+    private _satisfy_weighted;
+    satisfy(indices: any): boolean;
+}

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

@@ -1,16 +1,22 @@
-export declare function pad(n: any, width?: number, z?: number): string;
-/**
- * @description  Returns list of depth first recursively extracted values from elements of
-    key event dict ked whose flabels are in lables list
+import { Serder } from './serder';
+export declare function pad(n: any, width?: number, z?: number): string;
+/**
+ * @description  Returns list of depth first recursively extracted values from elements of
+    key event dict ked whose flabels are in lables list
 
- * @param {*} ked  ked is key event dict
- * @param {*} labels    labels is list of element labels in ked from which to extract values
- */
-export declare function extractValues(ked: any, labels: any): any;
-export declare function arrayEquals(ar1: Uint8Array, ar2: Uint8Array): boolean;
-/**
- * @description Returns True if obj is non-string iterable, False otherwise
+ * @param {*} ked  ked is key event dict
+ * @param {*} labels    labels is list of element labels in ked from which to extract values
+ */
+export declare function extractValues(ked: any, labels: any): any;
+export declare function arrayEquals(ar1: Uint8Array, ar2: Uint8Array): boolean;
+/**
+ * @description Returns True if obj is non-string iterable, False otherwise
 
- * @param {*} obj
- */
-export declare function range(start: any, stop: any, step: any): any[];
+ * @param {*} obj
+ */
+export declare function nowUTC(): Date;
+export declare function range(start: number, stop: number, step: number): number[];
+export declare function intToBytes(value: number, length: number): Uint8Array;
+export declare function bytesToInt(ar: Uint8Array): number;
+export declare function serializeACDCAttachment(anc: Serder): Uint8Array;
+export declare function serializeIssExnAttachment(anc: Serder): Uint8Array;

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

@@ -0,0 +1,16 @@
+import { Serials, Version } from '../core/core';
+import { Serder } from './serder';
+declare namespace vdr {
+    interface VDRInceptArgs {
+        pre: string;
+        toad?: number | string;
+        nonce?: string;
+        baks?: string[];
+        cnfg?: string[];
+        version?: Version;
+        kind?: Serials;
+        code?: string;
+    }
+    function incept({ pre, toad, nonce, baks, cnfg, version, kind, code, }: VDRInceptArgs): Serder;
+}
+export { vdr };

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

@@ -0,0 +1,13 @@
+export {};
+import { Matter, MatterArgs } from './matter';
+/**
+ * @description  Verfer :sublclass of Matter,helps to verify signature of serialization
+ *  using .raw as verifier key and .code as signature cypher suite
+ */
+export declare class Verfer extends Matter {
+    private readonly _verify;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs);
+    verify(sig: any, ser: any): boolean;
+    _ed25519(sig: any, ser: any, key: any): boolean;
+    _secp256r1(sig: any, ser: any, key: any): any;
+}

package/dist/keri/end/ending.d.ts

@@ -0,0 +1,13 @@
+export declare const FALSY: (string | number | boolean)[];
+export declare const TRUTHY: (string | number | boolean)[];
+export declare class Signage {
+    constructor(markers: any, indexed?: boolean, signer?: string, ordinal?: string, digest?: string, kind?: string);
+    markers: any;
+    indexed: boolean | undefined;
+    signer: string | undefined;
+    ordinal: string | undefined;
+    digest: string | undefined;
+    kind: string | undefined;
+}
+export declare function signature(signages: Array<Signage>): Headers;
+export declare function designature(value: string): Signage[];

package/dist/math.d.ts

@@ -0,0 +1 @@
+export declare const math: import("mathjs").MathJsStatic;

package/dist/ready.d.ts

@@ -0,0 +1 @@
+export declare const ready: () => Promise<void>;