signify-ts 0.1.0 → 0.2.0

package/dist/keri/app/coring.d.ts

@@ -0,0 +1,121 @@
+import { SignifyClient } from './clienting';
+export declare function randomPasscode(): string;
+export declare function randomNonce(): string;
+export declare class Oobis {
+    client: SignifyClient;
+    /**
+     * Oobis
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Get the OOBI(s) for a managed indentifier for a given role
+     * @param {string} name Name or alias of the identifier
+     * @param {string} role Authorized role
+     * @returns {Promise<any>} A promise to the OOBI(s)
+     */
+    get(name: string, role?: string): Promise<any>;
+    /**
+     * Resolve an OOBI
+     * @async
+     * @param {string} oobi The OOBI to be resolver
+     * @param {string} [alias] Optional name or alias to link the OOBI resolution to a contact
+     * @returns {Promise<any>} A promise to the long-running operation
+     */
+    resolve(oobi: string, alias?: string): Promise<any>;
+}
+export interface Operation<T = unknown> {
+    name: string;
+    metadata?: {
+        depends?: Operation;
+        [property: string]: any;
+    };
+    done?: boolean;
+    error?: any;
+    response?: T;
+}
+/**
+ * Operations
+ * @remarks
+ * Operations represent the status and result of long running tasks performed by KERIA agent
+ */
+export declare class Operations {
+    client: SignifyClient;
+    /**
+     * Operations
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Get operation status
+     * @async
+     * @param {string} name Name of the operation
+     * @returns {Promise<Operation>} A promise to the status of the operation
+     */
+    get<T = unknown>(name: string): Promise<Operation<T>>;
+    /**
+     * List operations
+     * @async
+     * @param {string} type Select operations by type
+     * @returns {Promise<Operation[]>} A list of operations
+     */
+    list(type?: string): Promise<Operation<any>[]>;
+    /**
+     * Delete operation
+     * @async
+     * @param {string} name Name of the operation
+     */
+    delete(name: string): Promise<void>;
+}
+/**
+ * KeyEvents
+ */
+export declare class KeyEvents {
+    client: SignifyClient;
+    /**
+     * KeyEvents
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Retrieve key events for an identifier
+     * @async
+     * @param {string} pre Identifier prefix
+     * @returns {Promise<any>} A promise to the key events
+     */
+    get(pre: string): Promise<any>;
+}
+/**
+ * KeyStates
+ */
+export declare class KeyStates {
+    client: SignifyClient;
+    /**
+     * KeyStates
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Retriene the key state for an identifier
+     * @async
+     * @param {string} pre Identifier prefix
+     * @returns {Promise<any>} A promise to the key states
+     */
+    get(pre: string): Promise<any>;
+    /**
+     * Retrieve the key state for a list of identifiers
+     * @async
+     * @param {Array<string>} pres List of identifier prefixes
+     * @returns {Promise<any>} A promise to the key states
+     */
+    list(pres: string[]): Promise<any>;
+    /**
+     * Query the key state of an identifier for a given sequence number or anchor
+     * @async
+     * @param {string} pre Identifier prefix
+     * @param {number} [sn] Optional sequence number
+     * @param {any} [anchor] Optional anchor
+     * @returns {Promise<any>} A promise to the long-running operation
+     */
+    query(pre: string, sn?: string, anchor?: any): Promise<any>;
+}

package/dist/keri/app/credentialing.d.ts

@@ -0,0 +1,239 @@
+import { SignifyClient } from './clienting';
+import { Dict } from '../core/core';
+import { Serder } from '../core/serder';
+import { Operation } from './coring';
+/** Types of credentials */
+export declare class CredentialTypes {
+    static issued: string;
+    static received: string;
+}
+/** Credential filter parameters */
+export interface CredentialFilter {
+    filter?: object;
+    sort?: object[];
+    skip?: number;
+    limit?: number;
+}
+export interface IssueCredentialArgs {
+    /**
+     * Name of the issuer identifier
+     */
+    issuerName: string;
+    /**
+     * QB64 AID of credential registry
+     */
+    registryId: string;
+    /**
+     * SAID Of the schema
+     */
+    schemaId: string;
+    /**
+     * Prefix of recipient identifier
+     */
+    recipient?: string;
+    /**
+     * Credential data
+     */
+    data?: Record<string, unknown>;
+    /**
+     * Credential rules
+     */
+    rules?: string | Record<string, unknown>;
+    /**
+     * Credential sources
+     */
+    source?: Record<string, unknown>;
+    /**
+     * Datetime to set for the credential
+     */
+    datetime?: string;
+    /**
+     * Flag to issue a credential with privacy preserving features
+     */
+    privacy?: boolean;
+}
+export interface IssueCredentialResult {
+    acdc: Serder;
+    anc: Serder;
+    iss: Serder;
+    op: Operation;
+}
+export interface IpexGrantArgs {
+    /**
+     * Alias for the IPEX sender AID
+     */
+    senderName: string;
+    /**
+     * Prefix of the IPEX recipient AID
+     */
+    recipient: string;
+    /**
+     * Message to send
+     */
+    message?: string;
+    /**
+     * qb64 SAID of agree message this grant is responding to
+     */
+    agree?: string;
+    datetime?: string;
+    acdc: Serder;
+    acdcAttachment?: string;
+    iss: Serder;
+    issAttachment?: string;
+    anc: Serder;
+    ancAttachment?: string;
+}
+/**
+ * Credentials
+ */
+export declare class Credentials {
+    client: SignifyClient;
+    /**
+     * Credentials
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * List credentials
+     * @async
+     * @param {CredentialFilter} [kargs] Optional parameters to filter the credentials
+     * @returns {Promise<any>} A promise to the list of credentials
+     */
+    list(kargs?: CredentialFilter): Promise<any>;
+    /**
+     * Get a credential
+     * @async
+     * @param {string} said - SAID of the credential
+     * @param {boolean} [includeCESR=false] - Optional flag export the credential in CESR format
+     * @returns {Promise<any>} A promise to the credential
+     */
+    get(said: string, includeCESR?: boolean): Promise<any>;
+    /**
+     * Issue a credential
+     */
+    issue(args: IssueCredentialArgs): Promise<IssueCredentialResult>;
+    /**
+     * Revoke credential
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} said SAID of the credential
+     * @returns {Promise<any>} A promise to the long-running operation
+     */
+    revoke(name: string, said: string): Promise<any>;
+    /**
+     * Present a credential
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} said SAID of the credential
+     * @param {string} recipient Identifier prefix of the receiver of the presentation
+     * @param {boolean} [include=true] Flag to indicate whether to stream credential alongside presentation exchange message
+     * @returns {Promise<string>} A promise to the long-running operation
+     */
+    present(name: string, said: string, recipient: string, include?: boolean): Promise<string>;
+    /**
+     * Request a presentation of a credential
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} recipient Identifier prefix of the receiver of the presentation
+     * @param {string} schema SAID of the schema
+     * @param {string} [issuer] Optional prefix of the issuer of the credential
+     * @returns {Promise<string>} A promise to the long-running operation
+     */
+    request(name: string, recipient: string, schema: string, issuer?: string): Promise<string>;
+}
+export interface CreateRegistryArgs {
+    name: string;
+    registryName: string;
+    toad?: string | number | undefined;
+    noBackers?: boolean;
+    baks?: string[];
+    nonce?: string;
+}
+export declare class RegistryResult {
+    private readonly _regser;
+    private readonly _serder;
+    private readonly _sigs;
+    private readonly promise;
+    constructor(regser: Serder, serder: Serder, sigs: any[], promise: Promise<Response>);
+    get regser(): any;
+    get serder(): Serder;
+    get sigs(): string[];
+    op(): Promise<any>;
+}
+/**
+ * Registries
+ */
+export declare class Registries {
+    client: SignifyClient;
+    /**
+     * Registries
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * List registries
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @returns {Promise<any>} A promise to the list of registries
+     */
+    list(name: string): Promise<any>;
+    /**
+     * Create a registry
+     * @async
+     * @param {CreateRegistryArgs}
+     * @returns {Promise<[any, Serder, any[], object]> } A promise to the long-running operation
+     */
+    create({ name, registryName, noBackers, toad, baks, nonce, }: CreateRegistryArgs): Promise<RegistryResult>;
+    createFromEvents(hab: Dict<any>, name: string, registryName: string, vcp: Dict<any>, ixn: Dict<any>, sigs: any[]): Promise<Response>;
+}
+/**
+ * Schemas
+ */
+export declare class Schemas {
+    client: SignifyClient;
+    /**
+     * Schemas
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Get a schema
+     * @async
+     * @param {string} said SAID of the schema
+     * @returns {Promise<any>} A promise to the schema
+     */
+    get(said: string): Promise<any>;
+    /**
+     * List schemas
+     * @async
+     * @returns {Promise<any>} A promise to the list of schemas
+     */
+    list(): Promise<any>;
+}
+/**
+ * Ipex
+ */
+export declare class Ipex {
+    client: SignifyClient;
+    /**
+     * Schemas
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Create an IPEX grant EXN message
+     */
+    grant(args: IpexGrantArgs): Promise<[Serder, string[], string]>;
+    submitGrant(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
+    /**
+     * Create an IPEX admit EXN message
+     * @async
+     * @param {string} name Name or alias of the identifier
+     * @param {string} message accompany human readable description of the credential being admitted
+     * @param {string} grant qb64 SAID of grant message this admit is responding to
+     * @param {string} datetime Optional datetime to set for the credential
+     * @returns {Promise<[Serder, string[], string]>} A promise to the long-running operation
+     */
+    admit(name: string, message: string, grant: string, datetime?: string): Promise<[Serder, string[], string]>;
+    submitAdmit(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
+}

package/dist/keri/app/escrowing.d.ts

@@ -0,0 +1,19 @@
+import { SignifyClient } from './clienting';
+/**
+ * Escrows
+ */
+export declare class Escrows {
+    client: SignifyClient;
+    /**
+     * Escrows
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * List replay messages
+     * @async
+     * @param {string} [route] Optional route in the replay message
+     * @returns {Promise<any>} A promise to the list of replay messages
+     */
+    listReply(route?: string): Promise<any>;
+}

package/dist/keri/app/exchanging.d.ts

@@ -0,0 +1,60 @@
+import { SignifyClient } from './clienting';
+import { Dict } from '../core/core';
+import { Serder } from '../core/serder';
+/**
+ * Exchanges
+ */
+export declare class Exchanges {
+    client: SignifyClient;
+    /**
+     * Exchanges
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Create exn message
+     * @async
+     * @returns {Promise<any>} A promise to the list of replay messages
+     * @param sender
+     * @param route
+     * @param payload
+     * @param embeds
+     * @param recipient
+     * @param datetime
+     * @param dig
+     */
+    createExchangeMessage(sender: Dict<any>, route: string, payload: Dict<any>, embeds: Dict<any>, recipient?: string, datetime?: string, dig?: string): Promise<[Serder, string[], string]>;
+    /**
+     * Send exn messages to list of recipients
+     * @async
+     * @returns {Promise<any>} A promise to the list of replay messages
+     * @param name
+     * @param topic
+     * @param sender
+     * @param route
+     * @param payload
+     * @param embeds
+     * @param recipients
+     */
+    send(name: string, topic: string, sender: Dict<any>, route: string, payload: Dict<any>, embeds: Dict<any>, recipients: string[]): Promise<any>;
+    /**
+     * Send exn messaget to list of recipients
+     * @async
+     * @returns {Promise<any>} A promise to the list of replay messages
+     * @param name
+     * @param topic
+     * @param exn
+     * @param sigs
+     * @param atc
+     * @param recipients
+     */
+    sendFromEvents(name: string, topic: string, exn: Serder, sigs: string[], atc: string, recipients: string[]): Promise<any>;
+    /**
+     * Get exn message by said
+     * @async
+     * @returns A promise to the exn message
+     * @param said The said of the exn message
+     */
+    get(said: string): Promise<any>;
+}
+export declare function exchange(route: string, payload: Dict<any>, sender: string, recipient?: string, date?: string, dig?: string, modifiers?: Dict<any>, embeds?: Dict<any>): [Serder, Uint8Array];

package/dist/keri/app/grouping.d.ts

@@ -0,0 +1,44 @@
+import { SignifyClient } from './clienting';
+import { Dict } from '../core/core';
+/**
+ * Groups
+ */
+export declare class Groups {
+    client: SignifyClient;
+    /**
+     * Groups
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * Get group request messages
+     * @async
+     * @param {string} [said] SAID of exn message to load
+     * @returns {Promise<any>} A promise to the list of replay messages
+     */
+    getRequest(said: string): Promise<any>;
+    /**
+     * Send multisig exn request  messages to other group members
+     * @async
+     * @param {string} [name] human readable name of group AID
+     * @param {Dict<any>} [exn] exn message to send to other members
+     * @param {string[]} [sigs] signature of the participant over the exn
+     * @param {string} [atc] additional attachments from embedded events in exn
+     * @returns {Promise<any>} A promise to the list of replay messages
+     */
+    sendRequest(name: string, exn: Dict<any>, sigs: string[], atc: string): Promise<any>;
+    /**
+     * Join multisig group using rotation event.
+     * This can be used by participants being asked to contribute keys to a rotation event to join an existing group.
+     * @async
+     * @param {string} [name] human readable name of group AID
+     * @param {any} [rot] rotation event
+     * @param {any} [sigs] signatures
+     * @param {string} [gid] prefix
+     * @param {string[]} [smids] array of particpants
+     * @param {string[]} [rmids] array of particpants
+     * @returns {Promise<any>} A promise to the list of replay messages
+     */
+    join(name: string, rot: any, sigs: any, //string[],
+    gid: string, smids: string[], rmids: string[]): Promise<any>;
+}

package/dist/keri/app/habery.d.ts

@@ -0,0 +1,48 @@
+import { Manager } from '../core/manager';
+import { Serder } from '../core/serder';
+export declare class TraitCodex {
+    EstOnly: string;
+    DoNotDelegate: string;
+    NoBackers: string;
+}
+export declare const TraitDex: TraitCodex;
+export interface HaberyArgs {
+    name: string;
+    passcode?: string;
+    seed?: string | undefined;
+    aeid?: string | undefined;
+    pidx?: number | undefined;
+    salt?: string | undefined;
+    tier?: string | undefined;
+}
+export interface MakeHabArgs {
+    code?: string;
+    transferable?: boolean;
+    isith?: string;
+    icount?: number;
+    nsith?: string;
+    ncount?: number;
+    toad?: string | number;
+    wits?: Array<string>;
+    delpre?: string;
+    estOnly?: boolean;
+    DnD?: boolean;
+    data?: any;
+}
+export declare class Hab {
+    name: string;
+    serder: Serder;
+    constructor(name: string, icp: Serder);
+    get pre(): string;
+}
+export declare class Habery {
+    private readonly _name;
+    private readonly _mgr;
+    private readonly _habs;
+    constructor({ name, passcode, seed, aeid, pidx, salt }: HaberyArgs);
+    get mgr(): Manager;
+    get habs(): Array<Hab>;
+    habByName(name: string): Hab | undefined;
+    makeHab(name: string, { code, transferable, isith, icount, nsith, ncount, toad, wits, delpre, estOnly, DnD, data, }: MakeHabArgs): Hab;
+    get name(): string;
+}

package/dist/keri/app/notifying.d.ts

@@ -0,0 +1,34 @@
+import { SignifyClient } from './clienting';
+/**
+ * Notifications
+ */
+export declare class Notifications {
+    client: SignifyClient;
+    /**
+     * Notifications
+     * @param {SignifyClient} client
+     */
+    constructor(client: SignifyClient);
+    /**
+     * List notifications
+     * @async
+     * @param {number} [start=0] Start index of list of notifications, defaults to 0
+     * @param {number} [end=24] End index of list of notifications, defaults to 24
+     * @returns {Promise<any>} A promise to the list of notifications
+     */
+    list(start?: number, end?: number): Promise<any>;
+    /**
+     * Mark a notification as read
+     * @async
+     * @param {string} said SAID of the notification
+     * @returns {Promise<string>} A promise to the result of the marking
+     */
+    mark(said: string): Promise<string>;
+    /**
+     * Delete a notification
+     * @async
+     * @param {string} said SAID of the notification
+     * @returns {Promise<any>} A promise to the result of the deletion
+     */
+    delete(said: string): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import { Signer } from './signer';
+import { Verfer } from './verfer';
+export declare class Authenticater {
+    static DefaultFields: string[];
+    private _verfer;
+    private readonly _csig;
+    constructor(csig: Signer, verfer: Verfer);
+    verify(headers: Headers, method: string, path: string): boolean;
+    sign(headers: Headers, method: string, path: string, fields?: Array<string>): Headers;
+}

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

@@ -0,0 +1,7 @@
+import { Matter, MatterArgs } from './matter';
+export declare const Reb64: RegExp;
+export declare class Bexter extends Matter {
+    constructor({ raw, code, qb64b, qb64, qb2 }: MatterArgs, bext?: string);
+    static _rawify(bext: string): Uint8Array;
+    get bext(): string;
+}

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

@@ -1,8 +1,8 @@
-import { Verfer } from "./verfer";
-import { Matter, MatterArgs } from "./matter";
-export declare class Cigar extends Matter {
-    private _verfer;
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer: Verfer);
-    get verfer(): Verfer;
-    set verfer(verfer: Verfer);
-}
+import { Verfer } from './verfer';
+import { Matter, MatterArgs } from './matter';
+export declare class Cigar extends Matter {
+    private _verfer;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer?: Verfer);
+    get verfer(): Verfer | undefined;
+    set verfer(verfer: Verfer | undefined);
+}

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

@@ -1,5 +1,5 @@
-import { Matter, MatterArgs } from "./matter";
-export declare class Cipher extends Matter {
-    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs);
-    decrypt(prikey?: Uint8Array | undefined, seed?: Uint8Array | undefined): any;
-}
+import { Matter, MatterArgs } from './matter';
+export declare class Cipher extends Matter {
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs);
+    decrypt(prikey?: Uint8Array | undefined, seed?: Uint8Array | undefined): any;
+}