@verana-labs/vs-agent-client 2.0.0-dev.7 → 2.0.0-dev.72

package/build/types/events.d.ts

@@ -0,0 +1,189 @@
+import { CredentialState, DidExchangeState, ProofState, VtFlowState } from './common';
+import { BasicMessageRecord, ConnectionRecord, CredentialExchangeRecord, MessageReactionAction, MessageState, PresentationRecord, ProfilePicture, SharedMediaItem } from './didcomm';
+import { VtFlowRecord } from './vt';
+export type ConnectionStateUpdatedData = ConnectionRecord & {
+    previousState: DidExchangeState | null;
+};
+export type PresentationStateUpdatedData = PresentationRecord & {
+    previousState: ProofState | null;
+};
+export type CredentialExchangeStateUpdatedData = CredentialExchangeRecord & {
+    previousState: CredentialState | null;
+};
+export type VtFlowStateUpdatedData = VtFlowRecord & {
+    previousState: VtFlowState | null;
+};
+export interface MessageReceiptsReceivedData {
+    connectionId: string;
+    receipts?: {
+        messageId: string;
+        state: MessageState;
+        timestamp: string;
+    }[];
+}
+export interface MessageReactionsReceivedData {
+    connectionId: string;
+    reactions?: {
+        messageId: string;
+        emoji: string;
+        action: MessageReactionAction;
+        timestamp: string;
+    }[];
+}
+export interface ReceivedUserProfile {
+    displayName?: string;
+    displayPicture?: ProfilePicture | null | '';
+    displayIcon?: ProfilePicture | null | '';
+    description?: string;
+    preferredLanguage?: string;
+}
+export interface ProfileReceivedData {
+    connectionId: string;
+    threadId?: string;
+    profile: ReceivedUserProfile;
+    sendBackYours: boolean;
+}
+export interface RequestProfileReceivedData {
+    connectionId: string;
+    threadId: string;
+    query?: string[];
+}
+export interface ShareMediaReceivedData {
+    connectionId: string;
+    threadId?: string;
+    description?: string;
+    items?: (SharedMediaItem & {
+        id: string;
+    })[];
+}
+export interface RequestMediaReceivedData {
+    connectionId: string;
+    threadId: string;
+    description?: string;
+    itemIds: string[];
+}
+export interface CallOfferReceivedData {
+    connectionId: string;
+    threadId: string;
+    callType: string;
+    parameters: Record<string, unknown>;
+    description?: string;
+    offerStartTime?: string;
+    offerExpirationTime?: string;
+}
+export interface CallAcceptReceivedData {
+    connectionId: string;
+    threadId: string;
+    parameters: Record<string, unknown>;
+}
+export interface CallThreadData {
+    connectionId: string;
+    threadId: string;
+}
+export interface MenuRequestReceivedData {
+    connectionId: string;
+    threadId: string;
+}
+export interface PerformReceivedData {
+    connectionId: string;
+    threadId: string;
+    name: string;
+    params?: Record<string, string>;
+}
+export interface AnswerReceivedData {
+    connectionId: string;
+    threadId: string;
+    response: string;
+}
+export interface MrzDataReceivedData {
+    connectionId: string;
+    threadId: string;
+    mrzData: {
+        raw: string | string[];
+        parsed: {
+            format?: string;
+            fields: Partial<Record<string, string | null>>;
+            valid: boolean;
+        };
+    };
+}
+export interface EmrtdDataReceivedData {
+    connectionId: string;
+    threadId: string;
+    dataGroups: {
+        raw: Record<string, string>;
+        parsed: {
+            fields?: Record<string, unknown>;
+            valid: boolean;
+        };
+        verification?: {
+            authenticity: boolean;
+            integrity: boolean;
+            details?: string;
+        };
+    };
+}
+export type MrtdProblemReportReason = 'e.p.mrz-refused' | 'e.p.emrtd-refused' | 'e.p.mrz-timeout' | 'e.p.emrtd-timeout';
+export interface MrtdProblemReportReceivedData {
+    connectionId: string;
+    threadId: string;
+    reason: MrtdProblemReportReason;
+}
+export interface VprNotificationPayload {
+    module: string;
+    action: string;
+    messageType: string;
+    txIndex: number;
+    messageIndex: number;
+    sender: string;
+    relatedDids: string[];
+    entityType?: string;
+    entityId?: string;
+}
+export interface VprNotificationData {
+    timestamp: string;
+    eventType: string;
+    did: string;
+    blockHeight: number;
+    txHash: string;
+    payload: VprNotificationPayload;
+    changes?: Record<string, unknown>;
+}
+export interface EventDataMap {
+    'didcomm.connections.state-updated': ConnectionStateUpdatedData;
+    'didcomm.basic-messages.message-received': BasicMessageRecord;
+    'didcomm.receipts.message-receipts-received': MessageReceiptsReceivedData;
+    'didcomm.reactions.message-reactions-received': MessageReactionsReceivedData;
+    'didcomm.user-profile.profile-received': ProfileReceivedData;
+    'didcomm.user-profile.request-profile-received': RequestProfileReceivedData;
+    'didcomm.media-sharing.share-media-received': ShareMediaReceivedData;
+    'didcomm.media-sharing.request-media-received': RequestMediaReceivedData;
+    'didcomm.calls.call-offer-received': CallOfferReceivedData;
+    'didcomm.calls.call-accept-received': CallAcceptReceivedData;
+    'didcomm.calls.call-reject-received': CallThreadData;
+    'didcomm.calls.call-end-received': CallThreadData;
+    'didcomm.action-menu.menu-request-received': MenuRequestReceivedData;
+    'didcomm.action-menu.perform-received': PerformReceivedData;
+    'didcomm.question-answer.answer-received': AnswerReceivedData;
+    'didcomm.mrtd.mrz-data-received': MrzDataReceivedData;
+    'didcomm.mrtd.emrtd-data-received': EmrtdDataReceivedData;
+    'didcomm.mrtd.problem-report-received': MrtdProblemReportReceivedData;
+    'didcomm.presentations.state-updated': PresentationStateUpdatedData;
+    'didcomm.credential-exchanges.state-updated': CredentialExchangeStateUpdatedData;
+    'vt.flows.state-updated': VtFlowStateUpdatedData;
+    'vpr.notification': VprNotificationData;
+}
+export type EventType = keyof EventDataMap;
+export type EventEnvelope<T extends EventType = EventType> = T extends EventType ? {
+    id: string;
+    type: T;
+    timestamp: string;
+    data: EventDataMap[T];
+} : never;
+export interface UnknownEventEnvelope {
+    id: string;
+    type: string;
+    timestamp: string;
+    data: unknown;
+}
+export type EventHandlerFn<T extends EventType> = (data: EventDataMap[T], envelope: EventEnvelope<T>) => void | Promise<void>;

package/build/types/events.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=events.js.map

package/build/types/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/types/events.ts"],"names":[],"mappings":""}

package/build/types/index.d.ts

@@ -1 +1,7 @@
-export * from './enums';
+export * from './agent';
+export * from './anoncreds';
+export * from './auth';
+export * from './common';
+export * from './didcomm';
+export * from './events';
+export * from './vt';

package/build/types/index.js

@@ -14,5 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./enums"), exports);
+__exportStar(require("./agent"), exports);
+__exportStar(require("./anoncreds"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./common"), exports);
+__exportStar(require("./didcomm"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./vt"), exports);
 //# sourceMappingURL=index.js.map

package/build/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAuB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAuB;AACvB,8CAA2B;AAC3B,yCAAsB;AACtB,2CAAwB;AACxB,4CAAyB;AACzB,2CAAwB;AACxB,uCAAoB"}

package/build/types/vt.d.ts

@@ -0,0 +1,116 @@
+import { PaginationQuery, VtConnectionState, VtFlowRole, VtFlowState, VtFlowVariant } from './common';
+export type VtFlowPendingAction = 'APPLICANT' | 'VALIDATOR' | 'AGENT' | 'CHAIN' | 'NONE';
+export interface VtFlowOobLink {
+    url: string;
+    description: string;
+    expiresAt?: string;
+    at: string;
+}
+export interface VtFlowMessage {
+    type: 'oob-link' | 'validating' | 'problem-report';
+    text?: string;
+    at: string;
+    url?: string;
+}
+export interface VtFlowTx {
+    hash?: string;
+    submittedAt?: string;
+    height?: number;
+    status: 'SUBMITTED' | 'SUCCEEDED' | 'FAILED';
+    reason?: string;
+    error?: string;
+}
+export interface VtFlowValidation {
+    decidedAt: string;
+    submission: 'AGENT' | 'OPERATOR';
+    validationFees?: number;
+    issuanceFees?: number;
+    verificationFees?: number;
+    issuanceFeeDiscount?: number;
+    verificationFeeDiscount?: number;
+    effectiveUntil?: string;
+    opSummaryDigest?: string;
+    tx?: VtFlowTx;
+}
+export interface VtFlowRecord {
+    id: string;
+    participantSessionId: string;
+    flowState: VtFlowState;
+    connectionState: VtConnectionState;
+    role: VtFlowRole;
+    variant: VtFlowVariant;
+    threadId: string;
+    connectionId: string;
+    agentParticipantId: string;
+    walletAgentParticipantId: string;
+    peerDid?: string;
+    applicantParticipantId?: string;
+    validatorParticipantId?: string;
+    schemaId?: string;
+    claims?: Record<string, unknown>;
+    proofs?: unknown[];
+    oobLink?: VtFlowOobLink;
+    messages: VtFlowMessage[];
+    pendingAction: VtFlowPendingAction;
+    validation?: VtFlowValidation;
+    issuance?: {
+        tx?: VtFlowTx;
+    };
+    credentialExchangeRecordId?: string;
+    credentialId?: string;
+    credentialDigest?: string;
+    subprotocolThid?: string;
+    errorMessage?: string;
+    createdAt: string;
+    updatedAt: string;
+    lastEventAt: string;
+}
+export interface ListFlowsQuery extends PaginationQuery {
+    role?: VtFlowRole;
+    connectionState?: VtConnectionState;
+    flowState?: VtFlowState;
+    peerDid?: string;
+    applicantParticipantId?: string;
+    validatorParticipantId?: string;
+    schemaId?: string;
+    participantSessionId?: string;
+}
+export interface EditClaimsBody {
+    claims: Record<string, unknown>;
+}
+export interface SendOobLinkBody {
+    url: string;
+    description: string;
+    expiresAt?: string;
+}
+export interface StartValidationBody {
+    comment?: string;
+}
+export interface ValidateFlowBody {
+    validationFees?: number;
+    issuanceFees?: number;
+    verificationFees?: number;
+    issuanceFeeDiscount?: number;
+    verificationFeeDiscount?: number;
+    effectiveUntil?: string;
+    opSummaryDigest?: string;
+}
+export interface RejectFlowBody {
+    code?: 'vt-flow.validation-refused' | 'vt-flow.session-terminated' | 'vt-flow.oob-expired';
+    description: string;
+}
+export type ServiceEndpointValue = string | Record<string, unknown> | Array<string | Record<string, unknown>>;
+export interface ServiceEndpoint {
+    id: string;
+    type: string;
+    serviceEndpoint: ServiceEndpointValue;
+}
+export interface AddServiceEndpointBody {
+    type: string;
+    serviceEndpoint: ServiceEndpointValue;
+    id?: string;
+}
+export interface UpdateServiceEndpointBody {
+    type?: string;
+    serviceEndpoint?: ServiceEndpointValue;
+}

package/build/types/vt.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=vt.js.map

package/build/types/vt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vt.js","sourceRoot":"","sources":["../../src/types/vt.ts"],"names":[],"mappings":""}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@verana-labs/vs-agent-client",
   "main": "build/index",
   "types": "build/index",
-  "version": "2.0.0-dev.7",
+  "version": "2.0.0-dev.72",
   "repository": {
     "type": "git",
     "url": "https://github.com/verana-labs/vs-agent"
@@ -14,20 +14,8 @@
     "access": "public"
   },
   "license": "Apache-2.0",
-  "dependencies": {
-    "class-transformer": "0.5.1",
-    "class-validator": "0.14.1",
-    "express": "^4.18.1",
-    "tslog": "^4.8.2",
-    "@verana-labs/vs-agent-model": "2.0.0-dev.7"
-  },
-  "devDependencies": {
-    "@nestjs/common": "^10.0.0",
-    "@types/express": "^4.17.13",
-    "ts-node-dev": "^2.0.0"
-  },
-  "peerDependencies": {
-    "@credo-ts/core": "0.7.1-pr-2704-20260630143332"
+  "engines": {
+    "node": ">=18"
   },
   "scripts": {
     "build": "pnpm run clean && pnpm run compile",

package/build/handlers/ExpressEventHandler.d.ts

@@ -1,71 +0,0 @@
-import { Express, Request, Response } from 'express';
-type Handler = (req: Request, res: Response) => Promise<void>;
-/**
- * `ExpressEventHandler` class for defining express event handling methods.
- * Extend this class in other projects to implement specific endpoint handlers
- * for different types of events. Each method is mapped to an HTTP POST endpoint
- * with a specified route on express structure
- *
- * Usage:
- * Extend `EventHandler` in your subclass and implement each method to
- * handle incoming events as per the business requirements.
- */
-export declare class ExpressEventHandler {
-    private app;
-    constructor(app: Express);
-    /**
-     * Handles the event for updating the state of a connection.
-     *
-     * Endpoint: POST `/connection-state-updated`
-     * Expected Payload: an `Event` object containing the connection state update details.
-     *
-     * @param {Event} event - The event object containing the connection state update details.
-     * @throws {Error} Throws an error if not implemented by subclass.
-     * @example
-     * const event = {
-     * 	 type: "connection-state-updated",
-     *   connectionId: "e2037401-aa91-4302-8927-ac07f06d9d60",
-     *   invitationId: "2232eb0f-643b-4a00-b014-3d1d85b8f4de",
-     *   state: "completed",
-     * }
-     */
-    connectionState(handler: Handler): void;
-    /**
-     * Handles the event for updating the state of a message.
-     *
-     * Endpoint: POST `/message-state-updated`
-     * Expected Payload: an `Event` object containing the new message state details.
-     *
-     * @param {Event} event - The event object containing the message state update details.
-     * @throws {Error} Throws an error if not implemented by subclass.
-     * @example
-     * const event = {
-     * 	 type: "message-state-updated",
-     *   messageId: "12345",
-     *   state: "delivered",
-     *   timestamp: "2023-10-01T12:00:00Z",
-     *   connectionId: "conn123"
-     * }
-     */
-    messageStateUpdated(handler: Handler): void;
-    /**
-     * Handles the event when a new message is received.
-     *
-     * Endpoint: POST `/message-received`
-     * Expected Payload: an `Event` object containing the message details.
-     *
-     * @param {Event} event - The event object containing the message details.
-     * @throws {Error} Throws an error if not implemented by subclass.
-     * @example
-     * const event = {
-     * 	 type: "message-received",
-     *   message: {
-     * 		type: text,
-     * 		content: "test"
-     * 	 },
-     *   timestamp: "2023-10-01T12:00:00Z",
-     * }
-     */
-    messageReceived(handler: Handler): void;
-}
-export {};

package/build/handlers/ExpressEventHandler.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressEventHandler = void 0;
-const vs_agent_model_1 = require("@verana-labs/vs-agent-model");
-/**
- * `ExpressEventHandler` class for defining express event handling methods.
- * Extend this class in other projects to implement specific endpoint handlers
- * for different types of events. Each method is mapped to an HTTP POST endpoint
- * with a specified route on express structure
- *
- * Usage:
- * Extend `EventHandler` in your subclass and implement each method to
- * handle incoming events as per the business requirements.
- */
-class ExpressEventHandler {
-    constructor(app) {
-        this.app = app;
-    }
-    /**
-     * Handles the event for updating the state of a connection.
-     *
-     * Endpoint: POST `/connection-state-updated`
-     * Expected Payload: an `Event` object containing the connection state update details.
-     *
-     * @param {Event} event - The event object containing the connection state update details.
-     * @throws {Error} Throws an error if not implemented by subclass.
-     * @example
-     * const event = {
-     * 	 type: "connection-state-updated",
-     *   connectionId: "e2037401-aa91-4302-8927-ac07f06d9d60",
-     *   invitationId: "2232eb0f-643b-4a00-b014-3d1d85b8f4de",
-     *   state: "completed",
-     * }
-     */
-    connectionState(handler) {
-        this.app.post(`/${vs_agent_model_1.EventType.ConnectionStateUpdated}`, async (req, res) => {
-            try {
-                await handler(req, res);
-            }
-            catch (error) {
-                res.status(500).json({ message: 'Internal Server Error', error });
-            }
-        });
-    }
-    /**
-     * Handles the event for updating the state of a message.
-     *
-     * Endpoint: POST `/message-state-updated`
-     * Expected Payload: an `Event` object containing the new message state details.
-     *
-     * @param {Event} event - The event object containing the message state update details.
-     * @throws {Error} Throws an error if not implemented by subclass.
-     * @example
-     * const event = {
-     * 	 type: "message-state-updated",
-     *   messageId: "12345",
-     *   state: "delivered",
-     *   timestamp: "2023-10-01T12:00:00Z",
-     *   connectionId: "conn123"
-     * }
-     */
-    messageStateUpdated(handler) {
-        this.app.post(`/${vs_agent_model_1.EventType.MessageStateUpdated}`, async (req, res) => {
-            try {
-                await handler(req, res);
-            }
-            catch (error) {
-                res.status(500).json({ message: 'Internal Server Error', error });
-            }
-        });
-    }
-    /**
-     * Handles the event when a new message is received.
-     *
-     * Endpoint: POST `/message-received`
-     * Expected Payload: an `Event` object containing the message details.
-     *
-     * @param {Event} event - The event object containing the message details.
-     * @throws {Error} Throws an error if not implemented by subclass.
-     * @example
-     * const event = {
-     * 	 type: "message-received",
-     *   message: {
-     * 		type: text,
-     * 		content: "test"
-     * 	 },
-     *   timestamp: "2023-10-01T12:00:00Z",
-     * }
-     */
-    messageReceived(handler) {
-        this.app.post(`/${vs_agent_model_1.EventType.MessageReceived}`, async (req, res) => {
-            try {
-                await handler(req, res);
-            }
-            catch (error) {
-                res.status(500).json({ message: 'Internal Server Error', error });
-            }
-        });
-    }
-}
-exports.ExpressEventHandler = ExpressEventHandler;
-//# sourceMappingURL=ExpressEventHandler.js.map

package/build/handlers/ExpressEventHandler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ExpressEventHandler.js","sourceRoot":"","sources":["../../src/handlers/ExpressEventHandler.ts"],"names":[],"mappings":";;;AAAA,gEAAuD;AAKvD;;;;;;;;;GASG;AACH,MAAa,mBAAmB;IAG9B,YAAY,GAAY;QACtB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;IAChB,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,eAAe,CAAC,OAAgB;QACrC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,0BAAS,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;YAC1F,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;YACzB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,CAAC,CAAA;YACnE,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACI,mBAAmB,CAAC,OAAgB;QACzC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,0BAAS,CAAC,mBAAmB,EAAE,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;YACvF,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;YACzB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,CAAC,CAAA;YACnE,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,eAAe,CAAC,OAAgB;QACrC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,0BAAS,CAAC,eAAe,EAAE,EAAE,KAAK,EAAE,GAAY,EAAE,GAAa,EAAE,EAAE;YACnF,IAAI,CAAC;gBACH,MAAM,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;YACzB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,uBAAuB,EAAE,KAAK,EAAE,CAAC,CAAA;YACnE,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;CACF;AAvFD,kDAuFC"}

package/build/handlers/index.d.ts

@@ -1 +0,0 @@
-export * from './ExpressEventHandler';

package/build/handlers/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ExpressEventHandler"), exports);
-//# sourceMappingURL=index.js.map

package/build/handlers/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/handlers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAqC"}

package/build/services/CredentialTypeService.d.ts

@@ -1,19 +0,0 @@
-import { CredentialTypeInfo, CredentialTypeResult, ImportCredentialTypeOptions } from '@verana-labs/vs-agent-model';
-import { ApiVersion } from '../types/enums';
-/**
- * `CredentialTypeService` class for managing credential types and interacting with
- * the available endpoints related to credential types in the Agent Service.
- *
- * This class provides methods for querying, creating, and managing credential types.
- * For a list of available endpoints and functionality, refer to the methods within this class.
- */
-export declare class CredentialTypeService {
-    private baseURL;
-    private version;
-    private url;
-    constructor(baseURL: string, version: ApiVersion);
-    import(importData: ImportCredentialTypeOptions): Promise<CredentialTypeInfo>;
-    export(credentialTypeId: string): Promise<unknown>;
-    create(credentialType: CredentialTypeInfo): Promise<CredentialTypeInfo>;
-    getAll(): Promise<CredentialTypeResult[]>;
-}

package/build/services/CredentialTypeService.js

@@ -1,66 +0,0 @@
-"use strict";
-// src/services/CredentialTypeService.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CredentialTypeService = void 0;
-const tslog_1 = require("tslog");
-const logger = new tslog_1.Logger({
-    name: 'CredentialTypeService',
-    type: 'pretty',
-    prettyLogTemplate: '{{logLevelName}} [{{name}}]: ',
-});
-/**
- * `CredentialTypeService` class for managing credential types and interacting with
- * the available endpoints related to credential types in the Agent Service.
- *
- * This class provides methods for querying, creating, and managing credential types.
- * For a list of available endpoints and functionality, refer to the methods within this class.
- */
-class CredentialTypeService {
-    constructor(baseURL, version) {
-        this.baseURL = baseURL;
-        this.version = version;
-        this.url = `${this.baseURL.replace(/\/$/, '')}/${this.version}/credential-types`;
-    }
-    async import(importData) {
-        logger.info(`Importing credential type ${importData.id}`);
-        const response = await fetch(`${this.url}/import`, {
-            method: 'POST',
-            body: JSON.stringify(importData),
-            headers: { accept: 'application/json', 'Content-Type': 'application/json' },
-        });
-        if (!response.ok)
-            throw new Error(`Cannot import credential type: status ${response.status}`);
-        return (await response.json());
-    }
-    async export(credentialTypeId) {
-        logger.info(`Exporting credential type ${credentialTypeId}`);
-        const response = await fetch(`${this.url}/export/${encodeURIComponent(credentialTypeId)}`, {
-            method: 'GET',
-            headers: { accept: 'application/json' },
-        });
-        if (!response.ok)
-            throw new Error(`Cannot export credential type: status ${response.status}}`);
-        return await response.json();
-    }
-    async create(credentialType) {
-        const response = await fetch(`${this.url}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(credentialType),
-        });
-        return (await response.json());
-    }
-    async getAll() {
-        const response = await fetch(this.url, {
-            method: 'GET',
-            headers: { accept: 'application/json', 'Content-Type': 'application/json' },
-        });
-        const types = await response.json();
-        if (!Array.isArray(types)) {
-            throw new Error('Invalid response from VS Agent');
-        }
-        return types.map(value => value);
-    }
-}
-exports.CredentialTypeService = CredentialTypeService;
-//# sourceMappingURL=CredentialTypeService.js.map