signify-ts 0.3.0-rc2 → 0.3.0

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

@@ -3,11 +3,12 @@ import { Algos } from '../core/manager.ts';
 import { Serder } from '../core/serder.ts';
 import { IdentifierManagerFactory } from '../core/keeping.ts';
 import { HabState } from '../core/keyState.ts';
+import { components } from '../../types/keria-api-schema.ts';
 /** Arguments required to create an identfier */
 export interface CreateIdentiferArgs {
     transferable?: boolean;
-    isith?: string | number | string[];
-    nsith?: string | number | string[];
+    isith?: string | number | string[] | string[][];
+    nsith?: string | number | string[] | string[][];
     wits?: string[];
     toad?: number;
     proxy?: string;
@@ -58,6 +59,13 @@ export interface IdentifierDeps {
 export interface IdentifierInfo {
     name: string;
 }
+export interface LocSchemeArgs {
+    url: string;
+    scheme?: string;
+    eid?: string;
+    stamp?: string;
+}
+export type GroupMembers = components['schemas']['GroupMember'];
 /** Identifier */
 export declare class Identifier {
     client: IdentifierDeps;
@@ -138,13 +146,21 @@ export declare class Identifier {
      * @returns {Serder} The reply message
      */
     private makeEndRole;
+    /**
+     * Authorises a new location scheme (endpoint) for a particular endpoint identifier.
+     * @param {LocSchemeArgs} args
+     * @param name Name or alias of the identifier to sign reply message
+     * @param args Arguments to create authorising reply message from
+     * @returns A promise to the result of the authorization
+     */
+    addLocScheme(name: string, args: LocSchemeArgs): Promise<EventResult>;
     /**
      * Get the members of a group identifier
      * @async
      * @param {string} name - Name or alias of the identifier
-     * @returns {Promise<any>} - A promise to the list of members
+     * @returns {Promise<GroupMembers>} - A promise to the list of members
      */
-    members(name: string): Promise<any>;
+    members(name: string): Promise<GroupMembers>;
 }
 /** Event Result */
 export declare class EventResult {

package/dist/keri/app/aiding.js

@@ -332,11 +332,36 @@ export class Identifier {
         const route = '/end/role/add';
         return reply(route, data, stamp, undefined, Serials.JSON);
     }
+    /**
+     * Authorises a new location scheme (endpoint) for a particular endpoint identifier.
+     * @param {LocSchemeArgs} args
+     * @param name Name or alias of the identifier to sign reply message
+     * @param args Arguments to create authorising reply message from
+     * @returns A promise to the result of the authorization
+     */
+    async addLocScheme(name, args) {
+        const { url, scheme, eid, stamp } = args;
+        const hab = await this.get(name);
+        const rpyData = {
+            eid: eid !== null && eid !== void 0 ? eid : hab.prefix,
+            url,
+            scheme: scheme !== null && scheme !== void 0 ? scheme : 'http',
+        };
+        const rpy = reply('/loc/scheme', rpyData, stamp, undefined, Serials.JSON);
+        const keeper = this.client.manager.get(hab);
+        const sigs = await keeper.sign(b(rpy.raw));
+        const jsondata = {
+            rpy: rpy.sad,
+            sigs: sigs,
+        };
+        const res = await this.client.fetch('/identifiers/' + name + '/locschemes', 'POST', jsondata);
+        return new EventResult(rpy, sigs, res);
+    }
     /**
      * Get the members of a group identifier
      * @async
      * @param {string} name - Name or alias of the identifier
-     * @returns {Promise<any>} - A promise to the list of members
+     * @returns {Promise<GroupMembers>} - A promise to the list of members
      */
     async members(name) {
         const res = await this.client.fetch('/identifiers/' + name + '/members', 'GET', undefined);

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

@@ -1,3 +1,4 @@
+import { components } from '../../types/keria-api-schema.ts';
 import { Authenticater } from '../core/authing.ts';
 import { ExternalModule, IdentifierManagerFactory } from '../core/keeping.ts';
 import { Tier } from '../core/salter.ts';
@@ -11,6 +12,7 @@ import { Escrows } from './escrowing.ts';
 import { Exchanges } from './exchanging.ts';
 import { Groups } from './grouping.ts';
 import { Notifications } from './notifying.ts';
+export type AgentResourceResult = components['schemas']['AgentResourceResult'];
 declare class State {
     agent: any | null;
     controller: any | null;

package/dist/keri/app/clienting.js

@@ -104,7 +104,7 @@ export class SignifyClient {
         if (res.status == 404) {
             throw new Error(`agent does not exist for controller ${caid}`);
         }
-        const data = await res.json();
+        const data = (await res.json());
         const state = new State();
         state.agent = (_b = data.agent) !== null && _b !== void 0 ? _b : {};
         state.controller = (_c = data.controller) !== null && _c !== void 0 ? _c : {};

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

@@ -1,11 +1,8 @@
 import { SignifyClient } from './clienting.ts';
-import { Operation } from './coring.ts';
-export interface Contact {
-    alias: string;
-    oobi: string;
-    id: string;
-    [key: string]: unknown;
-}
+import { components } from '../../types/keria-api-schema.ts';
+import { ChallengeOperation } from '../core/keyState.ts';
+import { Exn } from './exchanging.ts';
+export type Contact = components['schemas']['Contact'];
 export interface ContactInfo {
     [key: string]: unknown;
 }
@@ -59,9 +56,7 @@ export declare class Contacts {
      */
     update(pre: string, info: ContactInfo): Promise<Contact>;
 }
-export interface Challenge {
-    words: string[];
-}
+export type Challenge = components['schemas']['Challenge'];
 /**
  * Challenges
  */
@@ -76,7 +71,7 @@ export declare class Challenges {
      * Generate a random challenge word list based on BIP39
      * @async
      * @param {number} strength Integer representing the strength of the challenge. Typically 128 or 256
-     * @returns {Promise<any>} A promise to the list of random words
+     * @returns {Promise<Challenge>} A promise to the generated challenge
      */
     generate(strength?: number): Promise<Challenge>;
     /**
@@ -85,16 +80,16 @@ export declare class Challenges {
      * @param name Name or alias of the identifier
      * @param recipient Prefix of the recipient of the response
      * @param words List of words to embed in the signed response
-     * @returns A promise to the result of the response
+     * @returns {Promise<Exn>} A promise to the signed response exn message
      */
-    respond(name: string, recipient: string, words: string[]): Promise<unknown>;
+    respond(name: string, recipient: string, words: string[]): Promise<Exn>;
     /**
      * Ask Agent to verify a given sender signed the provided words
      * @param source Prefix of the identifier that was challenged
      * @param words List of challenge words to check for
      * @returns A promise to the long running operation
      */
-    verify(source: string, words: string[]): Promise<Operation<unknown>>;
+    verify(source: string, words: string[]): Promise<ChallengeOperation>;
     /**
      * Mark challenge response as signed and accepted
      * @param source Prefix of the identifier that was challenged

package/dist/keri/app/contacting.js

@@ -96,7 +96,7 @@ export class Challenges {
      * Generate a random challenge word list based on BIP39
      * @async
      * @param {number} strength Integer representing the strength of the challenge. Typically 128 or 256
-     * @returns {Promise<any>} A promise to the list of random words
+     * @returns {Promise<Challenge>} A promise to the generated challenge
      */
     async generate(strength = 128) {
         const path = `/challenges?strength=${strength.toString()}`;
@@ -110,7 +110,7 @@ export class Challenges {
      * @param name Name or alias of the identifier
      * @param recipient Prefix of the recipient of the response
      * @param words List of words to embed in the signed response
-     * @returns A promise to the result of the response
+     * @returns {Promise<Exn>} A promise to the signed response exn message
      */
     async respond(name, recipient, words) {
         const hab = await this.client.identifiers().get(name);

package/dist/keri/app/controller.js

@@ -28,7 +28,7 @@ export class Agent {
     }
     parse(agent) {
         const [state, verfer] = this.event(agent);
-        this.sn = new CesrNumber({}, undefined, state['s']).num;
+        this.sn = new CesrNumber({}, state['s']).num;
         this.said = state['d'];
         if (state['et'] !== Ilks.dip) {
             throw new Error(`invalid inception event type ${state['et']}`);
@@ -125,7 +125,7 @@ export class Controller {
     approveDelegation(_agent) {
         const seqner = new Seqner({ sn: _agent.sn });
         const anchor = { i: _agent.pre, s: seqner.snh, d: _agent.said };
-        const sn = new CesrNumber({}, undefined, this.serder.sad['s']).num + 1;
+        const sn = new CesrNumber({}, this.serder.sad['s']).num + 1;
         this.serder = interact({
             pre: this.serder.pre,
             dig: this.serder.sad['d'],

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

@@ -1,5 +1,10 @@
 import { SignifyClient } from './clienting.ts';
 import { components } from '../../types/keria-api-schema.ts';
+import { OOBIOperation, QueryOperation, EndRoleOperation, WitnessOperation, DelegationOperation, RegistryOperation, LocSchemeOperation, ChallengeOperation, ExchangeOperation, SubmitOperation, DoneOperation, CredentialOperation, GroupOperation, DelegatorOperation, CompletedOOBIOperation, CompletedQueryOperation, CompletedEndRoleOperation, CompletedWitnessOperation, CompletedDelegationOperation, CompletedRegistryOperation, CompletedLocSchemeOperation, CompletedChallengeOperation, CompletedExchangeOperation, CompletedSubmitOperation, CompletedDoneOperation, CompletedCredentialOperation, CompletedGroupOperation, CompletedDelegatorOperation, CompletedOperation } from '../core/keyState.ts';
+type OOBI = components['schemas']['OOBI'];
+type KeyState = components['schemas']['KeyStateRecord'];
+type KeyEventRecord = components['schemas']['KeyEventRecord'];
+type AgentConfig = components['schemas']['AgentConfig'];
 export declare function randomPasscode(): string;
 export declare function randomNonce(): string;
 export declare class Oobis {
@@ -13,31 +18,22 @@ export declare class Oobis {
      * 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)
+     * @returns {Promise<OOBI>} A promise to the OOBI(s)
      */
-    get(name: string, role?: string): Promise<any>;
+    get(name: string, role?: string): Promise<OOBI>;
     /**
      * 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
+     * @returns {Promise<OOBIOperation>} A promise to the long-running operation
      */
-    resolve(oobi: string, alias?: string): Promise<any>;
+    resolve(oobi: string, alias?: string): Promise<OOBIOperation>;
 }
-export type Operation<T = unknown> = Omit<components['schemas']['Operation'], 'response' | 'metadata'> & {
-    response?: T;
-    metadata?: {
-        depends?: Operation;
-        [property: string]: any;
-    };
-};
+export type Operation = OOBIOperation | QueryOperation | EndRoleOperation | WitnessOperation | DelegationOperation | RegistryOperation | LocSchemeOperation | ChallengeOperation | ExchangeOperation | SubmitOperation | DoneOperation | CredentialOperation | GroupOperation | DelegatorOperation;
 export interface OperationsDeps {
     fetch(pathname: string, method: string, body: unknown, headers?: Headers): Promise<Response>;
 }
-export interface AgentConfig {
-    iurls?: string[];
-}
 /**
  * Operations
  * @remarks
@@ -50,20 +46,26 @@ export declare class Operations {
      * @param {SignifyClient} client
      */
     constructor(client: OperationsDeps);
+    private hasDepends;
+    /**
+     * Check if operation failed and throw error with details
+     * @throws {Error} If operation has an error
+     */
+    private throwIfFailed;
     /**
      * 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>>;
+    get(name: string): Promise<Operation>;
     /**
      * List operations
      * @async
      * @param {string} type Select operations by type
      * @returns {Promise<Operation[]>} A list of operations
      */
-    list(type?: string): Promise<Operation<any>[]>;
+    list(type?: string): Promise<Operation[]>;
     /**
      * Delete operation
      * @async
@@ -73,12 +75,96 @@ export declare class Operations {
     /**
      * Poll for operation to become completed.
      */
-    wait<T>(op: Operation<T>, options?: {
+    wait(op: OOBIOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedOOBIOperation>;
+    wait(op: QueryOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedQueryOperation>;
+    wait(op: EndRoleOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedEndRoleOperation>;
+    wait(op: WitnessOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedWitnessOperation>;
+    wait(op: DelegationOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedDelegationOperation>;
+    wait(op: RegistryOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedRegistryOperation>;
+    wait(op: LocSchemeOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedLocSchemeOperation>;
+    wait(op: ChallengeOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedChallengeOperation>;
+    wait(op: ExchangeOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedExchangeOperation>;
+    wait(op: SubmitOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedSubmitOperation>;
+    wait(op: DoneOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedDoneOperation>;
+    wait(op: CredentialOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedCredentialOperation>;
+    wait(op: GroupOperation, options?: {
         signal?: AbortSignal;
         minSleep?: number;
         maxSleep?: number;
         increaseFactor?: number;
-    }): Promise<Operation<T>>;
+    }): Promise<CompletedGroupOperation>;
+    wait(op: DelegatorOperation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedDelegatorOperation>;
+    wait(op: Operation, options?: {
+        signal?: AbortSignal;
+        minSleep?: number;
+        maxSleep?: number;
+        increaseFactor?: number;
+    }): Promise<CompletedOperation>;
 }
 /**
  * KeyEvents
@@ -94,9 +180,9 @@ export declare class KeyEvents {
      * Retrieve key events for an identifier
      * @async
      * @param {string} pre Identifier prefix
-     * @returns {Promise<any>} A promise to the key events
+     * @returns {Promise<KeyEventRecord[]>} A promise to the key events
      */
-    get(pre: string): Promise<any>;
+    get(pre: string): Promise<KeyEventRecord[]>;
 }
 /**
  * KeyStates
@@ -112,25 +198,25 @@ export declare class KeyStates {
      * Retriene the key state for an identifier
      * @async
      * @param {string} pre Identifier prefix
-     * @returns {Promise<any>} A promise to the key states
+     * @returns {Promise<KeyState[]>} A promise to the key states
      */
-    get(pre: string): Promise<any>;
+    get(pre: string): Promise<KeyState[]>;
     /**
      * 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>;
+    list(pres: string[]): Promise<KeyState[]>;
     /**
      * 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
+     * @returns {Promise<QueryOperation>} A promise to the long-running operation
      */
-    query(pre: string, sn?: string, anchor?: any): Promise<any>;
+    query(pre: string, sn?: string, anchor?: any): Promise<QueryOperation>;
 }
 export declare class Config {
     client: SignifyClient;
@@ -141,3 +227,4 @@ export declare class Config {
     constructor(client: SignifyClient);
     get(): Promise<AgentConfig>;
 }
+export {};

package/dist/keri/app/coring.js

@@ -24,7 +24,7 @@ export class Oobis {
      * 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)
+     * @returns {Promise<OOBI>} A promise to the OOBI(s)
      */
     async get(name, role = 'agent') {
         const path = `/identifiers/${name}/oobis?role=${role}`;
@@ -37,7 +37,7 @@ export class Oobis {
      * @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
+     * @returns {Promise<OOBIOperation>} A promise to the long-running operation
      */
     async resolve(oobi, alias) {
         const path = `/oobis`;
@@ -65,6 +65,21 @@ export class Operations {
     constructor(client) {
         this.client = client;
     }
+    hasDepends(op) {
+        return op.metadata !== undefined && 'depends' in op.metadata;
+    }
+    /**
+     * Check if operation failed and throw error with details
+     * @throws {Error} If operation has an error
+     */
+    throwIfFailed(op) {
+        if ('error' in op && op.error !== null) {
+            const details = op.error.details
+                ? ` Details: ${JSON.stringify(op.error.details)}`
+                : '';
+            throw new Error(`Operation '${op.name}' failed [Code ${op.error.code}]: ${op.error.message}${details}`);
+        }
+    }
     /**
      * Get operation status
      * @async
@@ -106,30 +121,31 @@ export class Operations {
         const method = 'DELETE';
         await this.client.fetch(path, method, data);
     }
-    /**
-     * Poll for operation to become completed.
-     */
     async wait(op, options = {}) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d;
         const minSleep = (_a = options.minSleep) !== null && _a !== void 0 ? _a : 10;
         const maxSleep = (_b = options.maxSleep) !== null && _b !== void 0 ? _b : 10000;
         const increaseFactor = (_c = options.increaseFactor) !== null && _c !== void 0 ? _c : 50;
-        if (((_e = (_d = op.metadata) === null || _d === void 0 ? void 0 : _d.depends) === null || _e === void 0 ? void 0 : _e.done) === false) {
+        if (this.hasDepends(op) &&
+            op.metadata.depends &&
+            !op.metadata.depends.done) {
             await this.wait(op.metadata.depends, options);
         }
         if (op.done === true) {
+            this.throwIfFailed(op);
             return op;
         }
         let retries = 0;
         while (true) {
             op = await this.get(op.name);
-            const delay = Math.max(minSleep, Math.min(maxSleep, 2 ** retries * increaseFactor));
-            retries++;
             if (op.done === true) {
+                this.throwIfFailed(op);
                 return op;
             }
+            const delay = Math.max(minSleep, Math.min(maxSleep, 2 ** retries * increaseFactor));
+            retries++;
             await new Promise((resolve) => setTimeout(resolve, delay));
-            (_f = options.signal) === null || _f === void 0 ? void 0 : _f.throwIfAborted();
+            (_d = options.signal) === null || _d === void 0 ? void 0 : _d.throwIfAborted();
         }
     }
 }
@@ -148,7 +164,7 @@ export class KeyEvents {
      * Retrieve key events for an identifier
      * @async
      * @param {string} pre Identifier prefix
-     * @returns {Promise<any>} A promise to the key events
+     * @returns {Promise<KeyEventRecord[]>} A promise to the key events
      */
     async get(pre) {
         const path = `/events?pre=${pre}`;
@@ -173,7 +189,7 @@ export class KeyStates {
      * Retriene the key state for an identifier
      * @async
      * @param {string} pre Identifier prefix
-     * @returns {Promise<any>} A promise to the key states
+     * @returns {Promise<KeyState[]>} A promise to the key states
      */
     async get(pre) {
         const path = `/states?pre=${pre}`;
@@ -201,7 +217,7 @@ export class KeyStates {
      * @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
+     * @returns {Promise<QueryOperation>} A promise to the long-running operation
      */
     async query(pre, sn, anchor) {
         const path = `/queries`;

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

@@ -1,8 +1,7 @@
 import { SignifyClient } from './clienting.ts';
 import { Dict } from '../core/core.ts';
 import { Serder } from '../core/serder.ts';
-import { Operation } from './coring.ts';
-import { HabState } from '../core/keyState.ts';
+import { ExchangeOperation, CredentialOperation, GroupOperation, DelegationOperation, WitnessOperation, DoneOperation, HabState, RegistryOperation } from '../core/keyState.ts';
 import { components } from '../../types/keria-api-schema.ts';
 export type CredentialResult = components['schemas']['Credential'];
 export type Registry = components['schemas']['Registry'];
@@ -74,12 +73,12 @@ export interface IssueCredentialResult {
     acdc: Serder;
     anc: Serder;
     iss: Serder;
-    op: Operation;
+    op: CredentialOperation;
 }
 export interface RevokeCredentialResult {
     anc: Serder;
     rev: Serder;
-    op: Operation;
+    op: GroupOperation | DelegationOperation | WitnessOperation | DoneOperation;
 }
 export interface IpexApplyArgs {
     /**
@@ -218,6 +217,7 @@ export declare class Credentials {
     get(said: string): Promise<CredentialResult>;
     get(said: string, includeCESR: false): Promise<CredentialResult>;
     get(said: string, includeCESR: true): Promise<string>;
+    get(said: string, includeCESR: boolean): Promise<CredentialResult | string>;
     /**
      * Delete a credential from the DB
      * @async
@@ -264,7 +264,7 @@ export declare class RegistryResult {
     get regser(): any;
     get serder(): Serder;
     get sigs(): string[];
-    op(): Promise<Registry>;
+    op(): Promise<RegistryOperation>;
 }
 /**
  * Registries
@@ -339,25 +339,25 @@ export declare class Ipex {
      * Create an IPEX apply EXN message
      */
     apply(args: IpexApplyArgs): Promise<[Serder, string[], string]>;
-    submitApply(name: string, exn: Serder, sigs: string[], recp: string[]): Promise<any>;
+    submitApply(name: string, exn: Serder, sigs: string[], recp: string[]): Promise<ExchangeOperation>;
     /**
      * Create an IPEX offer EXN message
      */
     offer(args: IpexOfferArgs): Promise<[Serder, string[], string]>;
-    submitOffer(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
+    submitOffer(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<ExchangeOperation>;
     /**
      * Create an IPEX agree EXN message
      */
     agree(args: IpexAgreeArgs): Promise<[Serder, string[], string]>;
-    submitAgree(name: string, exn: Serder, sigs: string[], recp: string[]): Promise<any>;
+    submitAgree(name: string, exn: Serder, sigs: string[], recp: string[]): Promise<ExchangeOperation>;
     /**
      * 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>;
+    submitGrant(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<ExchangeOperation>;
     /**
      * Create an IPEX admit EXN message
      */
     admit(args: IpexAdmitArgs): Promise<[Serder, string[], string]>;
-    submitAdmit(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<any>;
+    submitAdmit(name: string, exn: Serder, sigs: string[], atc: string, recp: string[]): Promise<ExchangeOperation>;
 }

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

@@ -1,4 +1,6 @@
 import { SignifyClient } from './clienting.ts';
+import { components } from '../../types/keria-api-schema.ts';
+export type Rpy = components['schemas']['Rpy'];
 /**
  * Escrows
  */
@@ -13,7 +15,7 @@ export declare class Escrows {
      * List replay messages
      * @async
      * @param {string} [route] Optional route in the replay message
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Rpy[]>} A promise to the list of replay messages
      */
-    listReply(route?: string): Promise<any>;
+    listReply(route?: string): Promise<Rpy[]>;
 }

package/dist/keri/app/escrowing.js

@@ -13,7 +13,7 @@ export class Escrows {
      * List replay messages
      * @async
      * @param {string} [route] Optional route in the replay message
-     * @returns {Promise<any>} A promise to the list of replay messages
+     * @returns {Promise<Rpy[]>} A promise to the list of replay messages
      */
     async listReply(route) {
         const params = new URLSearchParams();