@verana-labs/vs-agent-client 2.0.0-dev.1 → 2.0.0-dev.100

package/build/types/didcomm.d.ts

@@ -0,0 +1,312 @@
+import { BasicMessageRole, Claim, CredentialRole, CredentialState, DidCommVersion, DidExchangeRole, DidExchangeState, InvitationState, PaginationQuery, ProofRole, ProofState, RequestedCredential } from './common';
+export interface ProtocolModule {
+    module: string;
+    protocols: string[];
+}
+export interface ConnectionRecord {
+    id: string;
+    state: DidExchangeState;
+    role: DidExchangeRole;
+    did?: string;
+    theirDid?: string;
+    theirLabel?: string;
+    alias?: string;
+    threadId?: string;
+    imageUrl?: string;
+    invitationId: string | null;
+    parentConnectionId: string | null;
+    invitationDid?: string;
+    didcommVersion?: DidCommVersion;
+    mediatorId?: string;
+    previousDids?: string[];
+    previousTheirDids?: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ListConnectionsQuery extends PaginationQuery {
+    invitationId?: string;
+    parentConnectionId?: string;
+    state?: DidExchangeState;
+    role?: DidExchangeRole;
+    did?: string;
+    theirDid?: string;
+    threadId?: string;
+    invitationDid?: string;
+    didcommVersion?: DidCommVersion;
+    mediatorId?: string;
+}
+export interface CreateInvitationBody {
+    /** When absent, the agent creates a standalone invitation and returns it. */
+    connectionId?: string;
+    /** A referral. Requires `connectionId`. */
+    did?: string;
+    /** Requires that `connectionId` is absent. */
+    reusable?: boolean;
+    /** Ignored for a standalone invitation. */
+    label?: string;
+    /** Ignored for a standalone invitation. */
+    imageUrl?: string;
+    goal?: string;
+    goalCode?: string;
+    /** The agent ignores it when `connectionId` is present. */
+    useLegacyDid?: boolean;
+    /** The agent ignores it when `connectionId` is present. */
+    didcommVersion?: DidCommVersion;
+}
+export interface CreateInvitationResponse {
+    /** Absent for a referral. */
+    id?: string;
+    /** Present for a standalone invitation only. */
+    invitation?: Record<string, unknown>;
+    /** Present for a standalone invitation only. */
+    shortUrl?: string;
+    /** Present when the request named a `connectionId`. */
+    messageId?: string;
+}
+export interface InvitationAcceptance {
+    connectionId: string;
+    /** True when the peer accepted the invitation on a connection that it already held. */
+    reused: boolean;
+    acceptedAt: string;
+}
+export interface InvitationRecord {
+    id: string;
+    state: InvitationState;
+    didcommVersion: DidCommVersion;
+    reusable: boolean;
+    invitation: Record<string, unknown>;
+    shortUrl: string | null;
+    parentConnectionId: string | null;
+    acceptances: InvitationAcceptance[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ListInvitationsQuery extends PaginationQuery {
+    state?: InvitationState;
+    parentConnectionId?: string;
+    /** A connection that appears in `acceptances`. */
+    connectionId?: string;
+    reusable?: boolean;
+    didcommVersion?: DidCommVersion;
+}
+export interface SendBasicMessageBody {
+    connectionId: string;
+    content: string;
+}
+export interface ListBasicMessagesQuery extends PaginationQuery {
+    connectionId?: string;
+    role?: BasicMessageRole;
+}
+export interface BasicMessageRecord {
+    id: string;
+    connectionId: string;
+    role: BasicMessageRole;
+    content: string;
+    sentTime: string;
+    createdAt: string;
+}
+export type MessageState = 'created' | 'submitted' | 'received' | 'viewed' | 'deleted';
+export interface MessageReceipt {
+    messageId: string;
+    state: MessageState;
+    timestamp?: string;
+}
+export interface SendReceiptsBody {
+    connectionId: string;
+    receipts: MessageReceipt[];
+}
+export type MessageReactionAction = 'react' | 'unreact';
+export interface MessageReaction {
+    messageId: string;
+    emoji: string;
+    action: MessageReactionAction;
+    timestamp?: string;
+}
+export interface SendReactionsBody {
+    connectionId: string;
+    reactions: MessageReaction[];
+}
+export interface ProfilePicture {
+    mimeType?: string;
+    links?: string[];
+    base64?: string;
+}
+export interface UserProfile {
+    displayName?: string;
+    displayPicture?: ProfilePicture;
+    displayIcon?: ProfilePicture;
+    description?: string;
+    preferredLanguage?: string;
+}
+export interface SendProfileBody {
+    connectionId: string;
+    profile?: UserProfile;
+    sendBackYours?: boolean;
+    threadId?: string;
+}
+export interface RequestProfileBody {
+    connectionId: string;
+    query?: string[];
+}
+export interface MediaCiphering {
+    algorithm: string;
+    parameters: Record<string, unknown>;
+}
+export interface SharedMediaItem {
+    id?: string;
+    uri: string;
+    mimeType: string;
+    fileName?: string;
+    description?: string;
+    byteCount?: number;
+    ciphering?: MediaCiphering;
+    metadata?: Record<string, unknown>;
+}
+export interface ShareMediaBody {
+    connectionId: string;
+    description?: string;
+    threadId?: string;
+    items: SharedMediaItem[];
+}
+export type CallType = 'audio' | 'video' | 'service';
+export interface OfferCallBody {
+    connectionId: string;
+    callType: CallType;
+    parameters: Record<string, unknown>;
+    description?: string;
+    offerStartTime?: string;
+    offerExpirationTime?: string;
+}
+export interface CallThreadBody {
+    connectionId: string;
+    threadId: string;
+}
+export interface AcceptCallBody extends CallThreadBody {
+    parameters: Record<string, unknown>;
+}
+export type ActionMenuFormInputType = 'text';
+export interface ActionMenuFormParameter {
+    name: string;
+    title: string;
+    description: string;
+    default?: string;
+    required?: boolean;
+    type?: ActionMenuFormInputType;
+}
+export interface ActionMenuForm {
+    description: string;
+    submitLabel: string;
+    params: ActionMenuFormParameter[];
+}
+export interface ActionMenuOption {
+    name: string;
+    title: string;
+    description: string;
+    disabled?: boolean;
+    form?: ActionMenuForm;
+}
+export interface ActionMenu {
+    title: string;
+    description: string;
+    options: ActionMenuOption[];
+}
+export interface SendMenuBody {
+    connectionId: string;
+    menu: ActionMenu;
+}
+export interface ValidResponse {
+    text: string;
+}
+export interface SendQuestionBody {
+    connectionId: string;
+    question: string;
+    validResponses: ValidResponse[];
+    detail?: string;
+}
+export interface RequestMrtdBody {
+    connectionId: string;
+}
+export interface ListPresentationsQuery extends PaginationQuery {
+    connectionId?: string;
+    threadId?: string;
+    role?: ProofRole;
+    state?: ProofState;
+}
+export interface PresentationRecord {
+    proofExchangeId: string;
+    state: ProofState;
+    role: ProofRole;
+    connectionId?: string;
+    requestedCredentials: RequestedCredential[];
+    claims: Claim[];
+    verified: boolean;
+    threadId?: string;
+    errorMessage?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RequestedCredentialInput {
+    credentialDefinitionId?: string;
+    jsonSchemaCredentialId?: string;
+    attributes?: string[];
+}
+export interface CreatePresentationRequestBody {
+    requestedCredentials: RequestedCredentialInput[];
+    /** An established connection to send the request on, in place of an invitation. */
+    connectionId?: string;
+    requireNonRevocation?: boolean;
+    autoAccept?: boolean;
+    /** The agent ignores it when `connectionId` is present. */
+    useLegacyDid?: boolean;
+    /** The agent ignores it when `connectionId` is present. */
+    didcommVersion?: DidCommVersion;
+}
+export interface CreatePresentationRequestResponse {
+    proofExchangeId: string;
+    /** Absent when the request named a `connectionId`. */
+    invitation?: Record<string, unknown>;
+    /** Absent when the request named a `connectionId`. */
+    shortUrl?: string;
+}
+export interface DeclineExchangeBody {
+    reason?: string;
+}
+export interface ListCredentialExchangesQuery extends PaginationQuery {
+    connectionId?: string;
+    threadId?: string;
+    role?: CredentialRole;
+    state?: CredentialState;
+}
+export interface CredentialExchangeRecord {
+    credentialExchangeId: string;
+    state: CredentialState;
+    role: CredentialRole;
+    threadId: string;
+    connectionId?: string;
+    credentialDefinitionId?: string;
+    schemaId?: string;
+    claims: Claim[];
+    errorMessage?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateCredentialOfferBody {
+    credentialDefinitionId: string;
+    claims: Claim[];
+    /** An established connection to send the offer on, in place of an invitation. */
+    connectionId?: string;
+    revocationRegistryDefinitionId?: string;
+    revocationRegistryIndex?: number;
+    autoAccept?: boolean;
+    /** The agent ignores it when `connectionId` is present. */
+    useLegacyDid?: boolean;
+    /** The agent ignores it when `connectionId` is present. */
+    didcommVersion?: DidCommVersion;
+}
+export interface CreateCredentialOfferResponse {
+    credentialExchangeId: string;
+    /** Absent when the request named a `connectionId`. */
+    invitation?: Record<string, unknown>;
+    /** Absent when the request named a `connectionId`. */
+    shortUrl?: string;
+}

package/build/types/didcomm.js

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

package/build/types/didcomm.js.map

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

package/build/types/events.d.ts

@@ -0,0 +1,193 @@
+import { CredentialState, DidExchangeState, InvitationState, ProofState, VtFlowState } from './common';
+import { BasicMessageRecord, ConnectionRecord, CredentialExchangeRecord, InvitationRecord, MessageReactionAction, MessageState, PresentationRecord, ProfilePicture, SharedMediaItem } from './didcomm';
+import { VtFlowRecord } from './vt';
+export type ConnectionStateUpdatedData = ConnectionRecord & {
+    previousState: DidExchangeState | null;
+};
+export type InvitationStateUpdatedData = InvitationRecord & {
+    previousState: InvitationState | 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.invitations.state-updated': InvitationStateUpdatedData;
+    '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":""}