@enbox/agent 0.0.1

package/src/types/dwn.ts

@@ -0,0 +1,278 @@
+import type { DidService } from '@enbox/dids';
+import type { Readable, RequireOnly } from '@enbox/common';
+import type {
+  RecordsReadReply,
+  RecordsQueryReply,
+  RecordsReadMessage,
+  RecordsReadOptions,
+  GenericMessageReply,
+  ProtocolsQueryReply,
+  RecordsQueryMessage,
+  RecordsQueryOptions,
+  RecordsWriteMessage,
+  RecordsWriteOptions,
+  RecordsDeleteMessage,
+  RecordsDeleteOptions,
+  ProtocolsQueryMessage,
+  ProtocolsQueryOptions,
+  ProtocolsConfigureMessage,
+  ProtocolsConfigureOptions,
+  RecordsSubscribeMessage,
+  RecordsSubscribeOptions,
+  RecordsSubscribeReply,
+  MessageSubscriptionHandler,
+  RecordSubscriptionHandler,
+  MessagesQueryMessage,
+  MessagesReadMessage,
+  MessagesSubscribeMessage,
+  MessagesQueryOptions,
+  MessagesReadOptions,
+  MessagesSubscribeOptions,
+  MessagesQueryReply,
+  MessagesReadReply,
+  MessagesSubscribeReply,
+} from '@enbox/dwn-sdk-js';
+
+import {
+  RecordsRead,
+  RecordsQuery,
+  RecordsWrite,
+  DwnMethodName,
+  RecordsDelete,
+  ProtocolsQuery,
+  DwnInterfaceName,
+  ProtocolsConfigure,
+  RecordsSubscribe,
+  MessagesQuery,
+  MessagesRead,
+  MessagesSubscribe,
+} from '@enbox/dwn-sdk-js';
+
+/**
+ * Represents a Decentralized Web Node (DWN) service in a DID Document.
+ *
+ * A DWN DID service is a specialized type of DID service with the `type` set to
+ * `DecentralizedWebNode`. It includes specific properties `enc` and `sig` that are used to identify
+ * the public keys that can be used to interact with the DID Subject. The values of these properties
+ * are strings or arrays of strings containing one or more verification method `id` values present in
+ * the same DID document. If the `enc` and/or `sig` properties are an array of strings, an entity
+ * interacting with the DID subject is expected to use the verification methods in the order they
+ * are listed.
+ *
+ * @example
+ * ```ts
+ * const service: DwnDidService = {
+ *   id: 'did:example:123#dwn',
+ *   type: 'DecentralizedWebNode',
+ *   serviceEndpoint: 'https://enbox-production.up.railway.app',
+ *   enc: 'did:example:123#key-1',
+ *   sig: 'did:example:123#key-2'
+ * }
+ * ```
+ *
+ * @see {@link https://identity.foundation/decentralized-web-node/spec/ | DIF Decentralized Web Node (DWN) Specification}
+ */
+export interface DwnDidService extends DidService {
+  /**
+   * One or more verification method `id` values that can be used to encrypt information
+   * intended for the DID subject.
+   */
+  enc?: string | string[];
+
+  /**
+   * One or more verification method `id` values that will be used by the DID subject to sign data
+   * or by another entity to verify signatures created by the DID subject.
+   */
+  sig: string | string[];
+}
+
+export enum DwnInterface {
+  MessagesQuery       = DwnInterfaceName.Messages + DwnMethodName.Query,
+  MessagesRead        = DwnInterfaceName.Messages + DwnMethodName.Read,
+  MessagesSubscribe   = DwnInterfaceName.Messages + DwnMethodName.Subscribe,
+  ProtocolsConfigure  = DwnInterfaceName.Protocols + DwnMethodName.Configure,
+  ProtocolsQuery      = DwnInterfaceName.Protocols + DwnMethodName.Query,
+  RecordsDelete       = DwnInterfaceName.Records + DwnMethodName.Delete,
+  RecordsQuery        = DwnInterfaceName.Records + DwnMethodName.Query,
+  RecordsRead         = DwnInterfaceName.Records + DwnMethodName.Read,
+  RecordsSubscribe    = DwnInterfaceName.Records + DwnMethodName.Subscribe,
+  RecordsWrite        = DwnInterfaceName.Records + DwnMethodName.Write
+}
+
+export type DwnRecordsInterfaces = DwnInterface.RecordsDelete | DwnInterface.RecordsQuery | DwnInterface.RecordsRead | DwnInterface.RecordsSubscribe | DwnInterface.RecordsWrite;
+export type DwnMessageInterfaces = DwnInterface.MessagesQuery | DwnInterface.MessagesRead | DwnInterface.MessagesSubscribe;
+export type DwnProtocolInterfaces = DwnInterface.ProtocolsConfigure | DwnInterface.ProtocolsQuery;
+
+export interface DwnMessage {
+  [DwnInterface.MessagesQuery]      : MessagesQueryMessage;
+  [DwnInterface.MessagesRead]       : MessagesReadMessage;
+  [DwnInterface.MessagesSubscribe]  : MessagesSubscribeMessage;
+  [DwnInterface.ProtocolsConfigure] : ProtocolsConfigureMessage;
+  [DwnInterface.ProtocolsQuery]     : ProtocolsQueryMessage;
+  [DwnInterface.RecordsDelete]      : RecordsDeleteMessage;
+  [DwnInterface.RecordsQuery]       : RecordsQueryMessage;
+  [DwnInterface.RecordsRead]        : RecordsReadMessage;
+  [DwnInterface.RecordsSubscribe]   : RecordsSubscribeMessage;
+  [DwnInterface.RecordsWrite]       : RecordsWriteMessage;
+}
+
+export interface DwnMessageDescriptor {
+  [DwnInterface.MessagesQuery]      : MessagesQueryMessage['descriptor'];
+  [DwnInterface.MessagesRead]       : MessagesReadMessage['descriptor'];
+  [DwnInterface.MessagesSubscribe]  : MessagesSubscribeMessage['descriptor'];
+  [DwnInterface.ProtocolsConfigure] : ProtocolsConfigureMessage['descriptor'];
+  [DwnInterface.ProtocolsQuery]     : ProtocolsQueryMessage['descriptor'];
+  [DwnInterface.RecordsDelete]      : RecordsDeleteMessage['descriptor'];
+  [DwnInterface.RecordsQuery]       : RecordsQueryMessage['descriptor'];
+  [DwnInterface.RecordsRead]        : RecordsReadMessage['descriptor'];
+  [DwnInterface.RecordsSubscribe]   : RecordsSubscribeMessage['descriptor'];
+  [DwnInterface.RecordsWrite]       : RecordsWriteMessage['descriptor'];
+}
+
+export interface DwnMessageParams {
+  [DwnInterface.MessagesQuery]      : RequireOnly<MessagesQueryOptions, 'filters'>;
+  [DwnInterface.MessagesRead]       : RequireOnly<MessagesReadOptions, 'messageCid'>;
+  [DwnInterface.MessagesSubscribe]  : Partial<MessagesSubscribeOptions>;
+  [DwnInterface.ProtocolsConfigure] : RequireOnly<ProtocolsConfigureOptions, 'definition'>;
+  [DwnInterface.ProtocolsQuery]     : ProtocolsQueryOptions;
+  [DwnInterface.RecordsDelete]      : RequireOnly<RecordsDeleteOptions, 'recordId'>;
+  [DwnInterface.RecordsQuery]       : RecordsQueryOptions;
+  [DwnInterface.RecordsRead]        : RecordsReadOptions;
+  [DwnInterface.RecordsSubscribe]   : RecordsSubscribeOptions;
+  [DwnInterface.RecordsWrite]       : RecordsWriteOptions;
+}
+
+export interface DwnMessageReply {
+  [DwnInterface.MessagesQuery]      : MessagesQueryReply;
+  [DwnInterface.MessagesRead]       : MessagesReadReply;
+  [DwnInterface.MessagesSubscribe]  : MessagesSubscribeReply;
+  [DwnInterface.ProtocolsConfigure] : GenericMessageReply;
+  [DwnInterface.ProtocolsQuery]     : ProtocolsQueryReply;
+  [DwnInterface.RecordsDelete]      : GenericMessageReply;
+  [DwnInterface.RecordsQuery]       : RecordsQueryReply;
+  [DwnInterface.RecordsRead]        : RecordsReadReply;
+  [DwnInterface.RecordsSubscribe]   : RecordsSubscribeReply;
+  [DwnInterface.RecordsWrite]       : GenericMessageReply;
+}
+
+export interface MessageHandler {
+  [DwnInterface.MessagesSubscribe]  : MessageSubscriptionHandler;
+  [DwnInterface.RecordsSubscribe]   : RecordSubscriptionHandler;
+
+  // define all of them individually as undefined
+  [DwnInterface.MessagesQuery]      : undefined;
+  [DwnInterface.MessagesRead]       : undefined;
+  [DwnInterface.ProtocolsConfigure] : undefined;
+  [DwnInterface.ProtocolsQuery]     : undefined;
+  [DwnInterface.RecordsDelete]      : undefined;
+  [DwnInterface.RecordsQuery]       : undefined;
+  [DwnInterface.RecordsRead]        : undefined;
+  [DwnInterface.RecordsWrite]       : undefined;
+}
+
+export type DwnRequest<T extends DwnInterface> = {
+  author: string;
+  target: string;
+  messageType: T;
+}
+
+/**
+ * Defines the structure for response status, including a status code and detail message.
+ */
+export type DwnResponseStatus = {
+  /** Encapsulates the outcome of an operation, providing both a numeric status code and a descriptive message. */
+  status: {
+    /** Numeric status code representing the outcome of the operation. */
+    code: number;
+
+    /** Descriptive detail about the status or error. */
+    detail: string;
+  };
+};
+
+export type ProcessDwnRequest<T extends DwnInterface> = DwnRequest<T> & {
+  dataStream?: Blob | ReadableStream | Readable;
+  rawMessage?: DwnMessage[T];
+  messageParams?: DwnMessageParams[T];
+  store?: boolean;
+  signAsOwner?: boolean;
+  signAsOwnerDelegate?: boolean;
+  granteeDid?: string;
+  subscriptionHandler?: MessageHandler[T];
+}
+
+export type SendDwnRequest<T extends DwnInterface> = DwnRequest<T> & (ProcessDwnRequest<T> | { messageCid: string })
+
+export type DwnResponse<T extends DwnInterface> = {
+  message?: DwnMessage[T];
+  messageCid: string;
+  reply: DwnMessageReply[T];
+}
+
+export interface DwnMessageConstructor<T extends DwnInterface> {
+  new (): DwnMessageInstance[T];
+  create(params: DwnMessageParams[T]): Promise<DwnMessageInstance[T]>;
+  parse(rawMessage: DwnMessage[T]): Promise<DwnMessageInstance[T]>;
+}
+
+export const dwnMessageConstructors: { [T in DwnInterface]: DwnMessageConstructor<T> } = {
+  [DwnInterface.MessagesQuery]      : MessagesQuery as any,
+  [DwnInterface.MessagesRead]       : MessagesRead as any,
+  [DwnInterface.MessagesSubscribe]  : MessagesSubscribe as any,
+  [DwnInterface.ProtocolsConfigure] : ProtocolsConfigure as any,
+  [DwnInterface.ProtocolsQuery]     : ProtocolsQuery as any,
+  [DwnInterface.RecordsDelete]      : RecordsDelete as any,
+  [DwnInterface.RecordsQuery]       : RecordsQuery as any,
+  [DwnInterface.RecordsRead]        : RecordsRead as any,
+  [DwnInterface.RecordsSubscribe]   : RecordsSubscribe as any,
+  [DwnInterface.RecordsWrite]       : RecordsWrite as any,
+} as const;
+
+export type DwnMessageConstructors = typeof dwnMessageConstructors;
+
+export interface DwnMessageInstance {
+  [DwnInterface.MessagesQuery]      : MessagesQuery;
+  [DwnInterface.MessagesRead]       : MessagesRead;
+  [DwnInterface.MessagesSubscribe]  : MessagesSubscribe;
+  [DwnInterface.ProtocolsConfigure] : ProtocolsConfigure;
+  [DwnInterface.ProtocolsQuery]     : ProtocolsQuery;
+  [DwnInterface.RecordsDelete]      : RecordsDelete;
+  [DwnInterface.RecordsQuery]       : RecordsQuery;
+  [DwnInterface.RecordsRead]        : RecordsRead;
+  [DwnInterface.RecordsSubscribe]   : RecordsSubscribe;
+  [DwnInterface.RecordsWrite]       : RecordsWrite;
+}
+
+export type DwnMessageWithData<T extends DwnInterface> = {
+  message: DwnMessage[T];
+  dataStream?: Readable;
+}
+
+// The following types are exported by the DWN SDK and are re-exported here so that dependent
+// packages do not need to import the DWN SDK directly. This ensures that downstream packages are
+// always using the same version of the DWN SDK as the agent package.
+
+export {
+  DwnConstant,
+  Signer as DwnSigner,
+  DateSort as DwnDateSort,
+  DataEncodedRecordsWriteMessage as DwnDataEncodedRecordsWriteMessage,
+  PublicJwk as DwnPublicKeyJwk, // TODO: Remove once DWN SDK switches to Jwk from @enbox/crypto
+  PaginationCursor as DwnPaginationCursor,
+  MessageSubscriptionHandler as DwnMessageSubscriptionHandler,
+  RecordSubscriptionHandler as DwnRecordSubscriptionHandler,
+  MessageSubscription as DwnMessageSubscription,
+  MessagesPermissionScope as DwnMessagesPermissionScope,
+  EncryptionAlgorithm as DwnEncryptionAlgorithm,
+  KeyDerivationScheme as DwnKeyDerivationScheme,
+  PermissionGrant as DwnPermissionGrant,
+  PermissionGrantData as DwnPermissionGrantData,
+  PermissionRequest as DwnPermissionRequest,
+  PermissionRequestData as DwnPermissionRequestData,
+  PermissionsProtocol as DwnPermissionsProtocol,
+  ProtocolDefinition as DwnProtocolDefinition,
+  ProtocolPermissionScope as DwnProtocolPermissionScope,
+  RecordsPermissionScope as DwnRecordsPermissionScope,
+  PermissionConditions as DwnPermissionConditions,
+  PermissionScope as DwnPermissionScope,
+} from '@enbox/dwn-sdk-js';

package/src/types/identity-vault.ts

@@ -0,0 +1,137 @@
+import type { BearerDid } from '@enbox/dids';
+import type { KeyValueStore } from '@enbox/common';
+
+/**
+ * Represents the structure of a backup for an IdentityVault, encapsulating all necessary
+ * information to restore the vault's state.
+ *
+ * The encrypted data encompasses all necessary information to reconstruct the vault's state,
+ * including the DID, keys, and any other relevant data stored in the vault.
+ */
+export type IdentityVaultBackup = {
+  /** A timestamp to record when the backup was made. */
+  dateCreated: string;
+
+  /** The size of the backup data, in bytes. */
+  size: number;
+
+  /** Encrypted vault contents. */
+  data: string;
+}
+
+/**
+ * Represents the detailed data structure of a backup for an {@link IdentityVault}.
+ *
+ * This type is used to encapsulate the essential components needed to fully restore the identity
+ * vault from a backup. It is an intermediate representation that holds the DID and the Content
+ * Encryption Key (CEK) in Compact JWE format, as well as the current status of the identity vault.
+ */
+export type IdentityVaultBackupData = {
+  /** The encrypted DID associated with the vault in Compact JWE format. */
+  did: string;
+
+  /** The encrypted key used to secure the vault's contents in Compact JWE format. */
+  contentEncryptionKey: string;
+
+  /** An object detailing the current status of the vault at the time of the backup. */
+  status: IdentityVaultStatus;
+};
+
+/**
+ * Configuration parameters for initializing an {@link IdentityVault} instance. These parameters
+ * define the settings and resources used by the {@link IdentityVault} to secure and manage identity
+ * data.
+ */
+export type IdentityVaultParams = {
+  /**
+   * Optionally defines the computational effort required for key derivation, affecting security and
+   * performance.
+   */
+  keyDerivationWorkFactor?: number;
+
+  /** Optionally specifies a custom key-value store for persisting the vault's encrypted data. */
+  store?: KeyValueStore<string, any>;
+}
+
+export interface IdentityVault<T extends Record<string, any> = { InitializeResult: any }> {
+  /**
+   * Creates a backup of the current state of the IdentityVault instance returning an
+   * {@link IdentityVaultBackup} object.
+   *
+   * The IdentityVault must be initialized and unlocked or the backup operation will fail.
+   */
+  backup(): Promise<IdentityVaultBackup>;
+
+  /**
+   * Attempts to change the password of the IdentityVault.
+   *
+   * The IdentityVault must be initialized and the old password correct or the operation will fail.
+   *
+   * @throws An error if the IdentityVault has not been initialized or the `oldPassword` is
+   *         incorrect.
+   */
+  changePassword(params: { oldPassword: string, newPassword: string }): Promise<void>;
+
+  /**
+   * Returns the DID associated with the {@link IdentityVault} instance.
+   */
+  getDid(): Promise<BearerDid>
+
+  /**
+   * Returns an {@link IdentityVaultStatus} object, which provides information about the current
+   * status of the `IdentityVault` instance.
+   */
+  getStatus(): Promise<IdentityVaultStatus>
+
+  /**
+   * Initializes the IdentityVault instance with the given `password`.
+   */
+  initialize(params: { password: string }): Promise<T['InitializeResult']>;
+
+  /**
+   * Returns a boolean indicating whether the IdentityVault has been initialized.
+   */
+  isInitialized(): Promise<boolean>;
+
+  /**
+   * Returns a boolean indicating whether the IdentityVault is currently locked.
+   */
+  isLocked(): boolean;
+
+  /**
+   * Locks the IdentityVault, secured by a password that must be entered to unlock.
+   */
+  lock(): Promise<void>;
+
+  /**
+   * Restores the IdentityVault instance to the state in the provided {@link IdentityVaultBackup}
+   * object.
+   *
+   * @throws An error if the backup is invalid or the password is incorrect.
+   */
+  restore(params: { backup: IdentityVaultBackup, password: string }): Promise<void>;
+
+  /**
+   * Attempts to unlock the IdentityVault with the provided password.
+   *
+   * @throws An error if the password is incorrect.
+   */
+  unlock(params: { password: string }): Promise<void>;
+}
+
+export type IdentityVaultStatus = {
+  /**
+   * Boolean indicating whether the IdentityVault has been initialized.
+   */
+  initialized: boolean;
+
+  /**
+   * The timestamp of the last backup.
+   */
+  lastBackup: string | null;
+
+  /**
+   * The timestamp of the last restore.
+   */
+  lastRestore: string | null;
+}

package/src/types/identity.ts

@@ -0,0 +1,18 @@
+import type { PortableDid } from '@enbox/dids';
+
+/**
+ * Represents metadata about a Web5 Identity.
+ */
+export interface IdentityMetadata {
+  name: string;
+  tenant: string;
+  uri: string;
+  connectedDid?: string;
+}
+
+export interface PortableIdentity {
+  portableDid: PortableDid;
+
+  /** {@inheritDoc IdentityMetadata} */
+  metadata: IdentityMetadata;
+}

package/src/types/key-manager.ts

@@ -0,0 +1,15 @@
+import type { Cipher, Jwk, KeyIdentifier, KeyWrapper, KmsExportKeyParams, KmsImportKeyParams } from '@enbox/crypto';
+
+import type { Web5PlatformAgent } from './agent.js';
+import type { KeyManager } from '../prototyping/crypto/types/key-manager.js';
+import type { KeyDeleter, KeyExporter, KeyImporter } from '../prototyping/crypto/types/key-io.js';
+import type { KmsCipherParams, KmsDeleteKeyParams, KmsUnwrapKeyParams, KmsWrapKeyParams } from '../prototyping/crypto/types/params-kms.js';
+export interface AgentKeyManager extends KeyManager,
+  Cipher<KmsCipherParams, KmsCipherParams>,
+  KeyImporter<KmsImportKeyParams, KeyIdentifier>,
+  KeyExporter<KmsExportKeyParams, Jwk>,
+  KeyDeleter<KmsDeleteKeyParams>,
+  KeyWrapper<KmsWrapKeyParams, KmsUnwrapKeyParams> {
+
+  agent: Web5PlatformAgent;
+}

package/src/types/permissions.ts

@@ -0,0 +1,115 @@
+import { DwnDataEncodedRecordsWriteMessage, DwnInterface, DwnPermissionGrant, DwnPermissionRequest, DwnPermissionScope } from './dwn.js';
+
+export type FetchPermissionsParams = {
+  author: string;
+  target: string;
+  grantee?: string;
+  grantor?: string;
+  protocol?: string;
+  remote?: boolean;
+}
+
+export type FetchPermissionRequestParams = {
+  author: string;
+  target: string;
+  protocol?: string;
+  remote?: boolean;
+}
+
+export type IsGrantRevokedParams = {
+  author: string;
+  target: string;
+  grantRecordId: string;
+  remote?: boolean;
+}
+
+export type PermissionGrantEntry = {
+  grant: DwnPermissionGrant;
+  message: DwnDataEncodedRecordsWriteMessage;
+}
+
+export type PermissionRequestEntry = {
+  request: DwnPermissionRequest;
+  message: DwnDataEncodedRecordsWriteMessage;
+}
+
+export type PermissionRevocationEntry = {
+  message: DwnDataEncodedRecordsWriteMessage;
+}
+
+export type CreateGrantParams = {
+  store?: boolean;
+  requestId?: string;
+  author: string;
+  description?: string;
+  dateExpires: string;
+  grantedTo: string;
+  scope: DwnPermissionScope;
+  delegated?: boolean;
+}
+
+export type CreateRequestParams = {
+  store?: boolean;
+  author: string;
+  description?: string;
+  scope: DwnPermissionScope;
+  delegated?: boolean;
+}
+
+export type CreateRevocationParams = {
+  store?: boolean;
+  author: string;
+  grant: DwnPermissionGrant;
+  description?: string;
+}
+
+export type GetPermissionParams = {
+  connectedDid: string;
+  delegateDid: string;
+  messageType: DwnInterface;
+  protocol?: string;
+  cached?: boolean;
+  delegate?: boolean;
+}
+
+export interface PermissionsApi {
+  /**
+   * Get the permission grant for a given author, target, and protocol. To be used when authoring delegated requests.
+   */
+  getPermissionForRequest: (params: GetPermissionParams) => Promise<PermissionGrantEntry>;
+
+  /**
+   * Fetch all grants for a given author and target, optionally filtered by a specific grantee, grantor, or protocol.
+   */
+  fetchGrants: (params: FetchPermissionsParams) => Promise<PermissionGrantEntry[]>;
+
+  /**
+   * Fetch all requests for a given author and target, optionally filtered by a specific protocol.
+   */
+  fetchRequests: (params: FetchPermissionRequestParams) => Promise<PermissionRequestEntry[]>;
+
+  /**
+  * Check whether a grant is revoked by reading the revocation record for a given grant recordId.
+  */
+  isGrantRevoked: (request: IsGrantRevokedParams) => Promise<boolean>;
+
+  /**
+   * Create a new permission grant, optionally storing it in the DWN.
+   */
+  createGrant:(params: CreateGrantParams) => Promise<PermissionGrantEntry>;
+
+  /**
+   * Create a new permission request, optionally storing it in the DWN.
+   */
+  createRequest(params: CreateRequestParams): Promise<PermissionRequestEntry>;
+
+  /**
+   * Create a new permission revocation, optionally storing it in the DWN.
+   */
+  createRevocation(params: CreateRevocationParams): Promise<PermissionRevocationEntry>;
+
+  /**
+   * Clears the cache of matched permissions.
+   */
+  clear: () => Promise<void>;
+}

package/src/types/sync.ts

@@ -0,0 +1,58 @@
+import type { Web5PlatformAgent } from './agent.js';
+
+/**
+ * The SyncEngine is responsible for syncing messages between the agent and the platform.
+ */
+export type SyncIdentityOptions = {
+  /**
+   * The delegate DID that should be used to sign the sync messages.
+   */
+  delegateDid?: string;
+  /**
+   * The protocols that should be synced for this identity, if an empty array is provided, all messages for all protocols will be synced.
+   */
+  protocols: string[]
+}
+export interface SyncEngine {
+  /**
+   * The agent that the SyncEngine is attached to.
+   */
+  agent: Web5PlatformAgent;
+  /**
+   * Register an identity to be managed by the SyncEngine for syncing.
+   * The options can define specific protocols that should only be synced, or a delegate DID that should be used to sign the sync messages.
+   */
+  registerIdentity(params: { did: string, options?: SyncIdentityOptions }): Promise<void>;
+  /**
+   * Unregister an identity from the SyncEngine, this will stop syncing messages for this identity.
+   */
+  unregisterIdentity(did: string): Promise<void>;
+  /**
+   * Get the Sync Options for a specific identity.
+   */
+  getIdentityOptions(did: string): Promise<SyncIdentityOptions | undefined>;
+  /**
+   * Update the Sync Options for a specific identity, replaces the existing options.
+   */
+  updateIdentityOptions(params: { did: string, options: SyncIdentityOptions }): Promise<void>;
+  /**
+   * Preforms a one-shot sync operation. If no direction is provided, it will perform both push and pull.
+   * @param direction which direction you'd like to perform the sync operation.
+   *
+   * @throws {Error} if a sync is already in progress or the sync operation fails.
+   */
+  sync(direction?: 'push' | 'pull'): Promise<void>;
+  /**
+   * Starts a periodic sync that runs at an interval. Subsequent calls to startSync will update the interval.
+   *
+   * @param params { interval: string } the interval at which the sync operation should be performed. ex: '30s', '1m', '10m'
+   */
+  startSync(params: { interval: string }): Promise<void>;
+  /**
+   * Stops the periodic sync operation, will complete the current sync operation if one is already in progress.
+   *
+   * @param timeout the maximum amount of time, in milliseconds, to wait for the current sync operation to complete. Default is 2000 (2 seconds).
+   * @throws {Error} if the sync operation fails to stop before the timeout.
+   */
+  stopSync(timeout?: number): Promise<void>;
+}

package/src/types/vc.ts

@@ -0,0 +1,7 @@
+/**
+ * Verifiable Credential Types
+ */
+
+export type ProcessVcRequest = { /** empty */ }
+export type SendVcRequest = { /** empty */ }
+export type VcResponse = { /** empty */ }