@open-captable-protocol/canton 0.2.150 → 0.2.152

package/dist/errors/OcpContractError.d.ts

@@ -0,0 +1,52 @@
+import { type OcpErrorCode } from './codes';
+import { OcpError } from './OcpError';
+export interface OcpContractErrorOptions {
+    /** The contract ID involved in the error */
+    contractId?: string;
+    /** The DAML template ID */
+    templateId?: string;
+    /** The choice being exercised when the error occurred */
+    choice?: string;
+    /** The original error that caused this error */
+    cause?: Error;
+    /** Specific contract error code (defaults to CHOICE_FAILED) */
+    code?: OcpErrorCode;
+}
+/**
+ * Errors from Canton/DAML contract interactions.
+ *
+ * Thrown when contract operations fail, such as exercising a choice,
+ * fetching contract data, or when expected results are not found in
+ * transaction trees.
+ *
+ * @example
+ * ```typescript
+ * throw new OcpContractError('UpdateCapTable result not found in transaction tree', {
+ *   contractId: capTableContractId,
+ *   choice: 'UpdateCapTable',
+ *   code: OcpErrorCodes.RESULT_NOT_FOUND,
+ * });
+ * ```
+ *
+ * @example Catching contract errors
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.capTable.update(...).execute();
+ * } catch (error) {
+ *   if (error instanceof OcpContractError) {
+ *     console.error(`Contract error on ${error.choice}: ${error.message}`);
+ *     console.error(`Contract ID: ${error.contractId}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class OcpContractError extends OcpError {
+    /** The contract ID involved in the error */
+    readonly contractId?: string;
+    /** The DAML template ID */
+    readonly templateId?: string;
+    /** The choice being exercised when the error occurred */
+    readonly choice?: string;
+    constructor(message: string, options?: OcpContractErrorOptions);
+}
+//# sourceMappingURL=OcpContractError.d.ts.map

package/dist/errors/OcpContractError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpContractError.d.ts","sourceRoot":"","sources":["../../src/errors/OcpContractError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,MAAM,WAAW,uBAAuB;IACtC,4CAA4C;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,+DAA+D;IAC/D,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B,2BAA2B;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAE7B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,uBAAuB;CAQ/D"}

package/dist/errors/OcpContractError.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcpContractError = void 0;
+const codes_1 = require("./codes");
+const OcpError_1 = require("./OcpError");
+/**
+ * Errors from Canton/DAML contract interactions.
+ *
+ * Thrown when contract operations fail, such as exercising a choice,
+ * fetching contract data, or when expected results are not found in
+ * transaction trees.
+ *
+ * @example
+ * ```typescript
+ * throw new OcpContractError('UpdateCapTable result not found in transaction tree', {
+ *   contractId: capTableContractId,
+ *   choice: 'UpdateCapTable',
+ *   code: OcpErrorCodes.RESULT_NOT_FOUND,
+ * });
+ * ```
+ *
+ * @example Catching contract errors
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.capTable.update(...).execute();
+ * } catch (error) {
+ *   if (error instanceof OcpContractError) {
+ *     console.error(`Contract error on ${error.choice}: ${error.message}`);
+ *     console.error(`Contract ID: ${error.contractId}`);
+ *   }
+ * }
+ * ```
+ */
+class OcpContractError extends OcpError_1.OcpError {
+    constructor(message, options) {
+        const code = options?.code ?? codes_1.OcpErrorCodes.CHOICE_FAILED;
+        super(message, code, options?.cause);
+        this.name = 'OcpContractError';
+        this.contractId = options?.contractId;
+        this.templateId = options?.templateId;
+        this.choice = options?.choice;
+    }
+}
+exports.OcpContractError = OcpContractError;
+//# sourceMappingURL=OcpContractError.js.map

package/dist/errors/OcpContractError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpContractError.js","sourceRoot":"","sources":["../../src/errors/OcpContractError.ts"],"names":[],"mappings":";;;AAAA,mCAA2D;AAC3D,yCAAsC;AAetC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAa,gBAAiB,SAAQ,mBAAQ;IAU5C,YAAY,OAAe,EAAE,OAAiC;QAC5D,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,qBAAa,CAAC,aAAa,CAAC;QAC1D,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;QAC/B,IAAI,CAAC,UAAU,GAAG,OAAO,EAAE,UAAU,CAAC;QACtC,IAAI,CAAC,UAAU,GAAG,OAAO,EAAE,UAAU,CAAC;QACtC,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,CAAC;IAChC,CAAC;CACF;AAlBD,4CAkBC"}

package/dist/errors/OcpError.d.ts

@@ -0,0 +1,27 @@
+import type { OcpErrorCode } from './codes';
+/**
+ * Base error class for all OCP SDK errors.
+ *
+ * Provides structured error information including an error code and optional cause.
+ * All OCP-specific errors extend this class, allowing consumers to catch all SDK
+ * errors with a single `catch (error instanceof OcpError)` check.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.issuer.createIssuer(params);
+ * } catch (error) {
+ *   if (error instanceof OcpError) {
+ *     console.error(`OCP Error [${error.code}]: ${error.message}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class OcpError extends Error {
+    /** Error code for programmatic handling */
+    readonly code: OcpErrorCode;
+    /** The original error that caused this error, if any */
+    readonly cause?: Error;
+    constructor(message: string, code: OcpErrorCode, cause?: Error);
+}
+//# sourceMappingURL=OcpError.d.ts.map

package/dist/errors/OcpError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpError.d.ts","sourceRoot":"","sources":["../../src/errors/OcpError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,QAAS,SAAQ,KAAK;IACjC,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAE5B,wDAAwD;IACxD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;gBAEX,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,KAAK;CAS/D"}

package/dist/errors/OcpError.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcpError = void 0;
+/**
+ * Base error class for all OCP SDK errors.
+ *
+ * Provides structured error information including an error code and optional cause.
+ * All OCP-specific errors extend this class, allowing consumers to catch all SDK
+ * errors with a single `catch (error instanceof OcpError)` check.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.issuer.createIssuer(params);
+ * } catch (error) {
+ *   if (error instanceof OcpError) {
+ *     console.error(`OCP Error [${error.code}]: ${error.message}`);
+ *   }
+ * }
+ * ```
+ */
+class OcpError extends Error {
+    constructor(message, code, cause) {
+        super(message);
+        this.name = 'OcpError';
+        this.code = code;
+        this.cause = cause;
+        // Maintain proper stack trace in V8 environments (Node.js, Chrome)
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.OcpError = OcpError;
+//# sourceMappingURL=OcpError.js.map

package/dist/errors/OcpError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpError.js","sourceRoot":"","sources":["../../src/errors/OcpError.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAa,QAAS,SAAQ,KAAK;IAOjC,YAAY,OAAe,EAAE,IAAkB,EAAE,KAAa;QAC5D,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,mEAAmE;QACnE,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAhBD,4BAgBC"}

package/dist/errors/OcpNetworkError.d.ts

@@ -0,0 +1,49 @@
+import { type OcpErrorCode } from './codes';
+import { OcpError } from './OcpError';
+export interface OcpNetworkErrorOptions {
+    /** The endpoint that was being accessed */
+    endpoint?: string;
+    /** The HTTP status code, if applicable */
+    statusCode?: number;
+    /** The original error that caused this error */
+    cause?: Error;
+    /** Specific network error code (defaults to CONNECTION_FAILED) */
+    code?: OcpErrorCode;
+}
+/**
+ * Network or connectivity errors.
+ *
+ * Thrown when network operations fail, such as connection failures,
+ * timeouts, or rate limiting.
+ *
+ * @example
+ * ```typescript
+ * throw new OcpNetworkError('Failed to connect to Canton JSON API', {
+ *   endpoint: 'http://localhost:3975',
+ *   code: OcpErrorCodes.CONNECTION_FAILED,
+ *   cause: originalError,
+ * });
+ * ```
+ *
+ * @example Catching network errors
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.issuer.getIssuerAsOcf(params);
+ * } catch (error) {
+ *   if (error instanceof OcpNetworkError) {
+ *     console.error(`Network error: ${error.message}`);
+ *     if (error.statusCode === 503) {
+ *       console.error('Service unavailable - retry later');
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class OcpNetworkError extends OcpError {
+    /** The endpoint that was being accessed */
+    readonly endpoint?: string;
+    /** The HTTP status code, if applicable */
+    readonly statusCode?: number;
+    constructor(message: string, options?: OcpNetworkErrorOptions);
+}
+//# sourceMappingURL=OcpNetworkError.d.ts.map

package/dist/errors/OcpNetworkError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpNetworkError.d.ts","sourceRoot":"","sources":["../../src/errors/OcpNetworkError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,MAAM,WAAW,sBAAsB;IACrC,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gDAAgD;IAChD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,kEAAkE;IAClE,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,eAAgB,SAAQ,QAAQ;IAC3C,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B,0CAA0C;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;gBAEjB,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;CAO9D"}

package/dist/errors/OcpNetworkError.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcpNetworkError = void 0;
+const codes_1 = require("./codes");
+const OcpError_1 = require("./OcpError");
+/**
+ * Network or connectivity errors.
+ *
+ * Thrown when network operations fail, such as connection failures,
+ * timeouts, or rate limiting.
+ *
+ * @example
+ * ```typescript
+ * throw new OcpNetworkError('Failed to connect to Canton JSON API', {
+ *   endpoint: 'http://localhost:3975',
+ *   code: OcpErrorCodes.CONNECTION_FAILED,
+ *   cause: originalError,
+ * });
+ * ```
+ *
+ * @example Catching network errors
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.issuer.getIssuerAsOcf(params);
+ * } catch (error) {
+ *   if (error instanceof OcpNetworkError) {
+ *     console.error(`Network error: ${error.message}`);
+ *     if (error.statusCode === 503) {
+ *       console.error('Service unavailable - retry later');
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class OcpNetworkError extends OcpError_1.OcpError {
+    constructor(message, options) {
+        const code = options?.code ?? codes_1.OcpErrorCodes.CONNECTION_FAILED;
+        super(message, code, options?.cause);
+        this.name = 'OcpNetworkError';
+        this.endpoint = options?.endpoint;
+        this.statusCode = options?.statusCode;
+    }
+}
+exports.OcpNetworkError = OcpNetworkError;
+//# sourceMappingURL=OcpNetworkError.js.map

package/dist/errors/OcpNetworkError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpNetworkError.js","sourceRoot":"","sources":["../../src/errors/OcpNetworkError.ts"],"names":[],"mappings":";;;AAAA,mCAA2D;AAC3D,yCAAsC;AAatC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,eAAgB,SAAQ,mBAAQ;IAO3C,YAAY,OAAe,EAAE,OAAgC;QAC3D,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,qBAAa,CAAC,iBAAiB,CAAC;QAC9D,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,QAAQ,GAAG,OAAO,EAAE,QAAQ,CAAC;QAClC,IAAI,CAAC,UAAU,GAAG,OAAO,EAAE,UAAU,CAAC;IACxC,CAAC;CACF;AAdD,0CAcC"}

package/dist/errors/OcpParseError.d.ts

@@ -0,0 +1,41 @@
+import { type OcpErrorCode } from './codes';
+import { OcpError } from './OcpError';
+export interface OcpParseErrorOptions {
+    /** Description of the data source being parsed */
+    source?: string;
+    /** The original error that caused this error */
+    cause?: Error;
+    /** Specific parse error code (defaults to INVALID_RESPONSE) */
+    code?: OcpErrorCode;
+}
+/**
+ * Errors from parsing or transforming data.
+ *
+ * Thrown when data cannot be parsed or transformed, such as invalid
+ * DAML responses, unknown enum values, or schema mismatches.
+ *
+ * @example
+ * ```typescript
+ * throw new OcpParseError('Unknown DAML stakeholder type: InvalidType', {
+ *   source: 'stakeholder.stakeholder_type',
+ *   code: OcpErrorCodes.UNKNOWN_ENUM_VALUE,
+ * });
+ * ```
+ *
+ * @example Catching parse errors
+ * ```typescript
+ * try {
+ *   const result = await ocp.OpenCapTable.stakeholder.getStakeholderAsOcf(params);
+ * } catch (error) {
+ *   if (error instanceof OcpParseError) {
+ *     console.error(`Parse error in ${error.source}: ${error.message}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class OcpParseError extends OcpError {
+    /** Description of the data source being parsed */
+    readonly source?: string;
+    constructor(message: string, options?: OcpParseErrorOptions);
+}
+//# sourceMappingURL=OcpParseError.d.ts.map

package/dist/errors/OcpParseError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpParseError.d.ts","sourceRoot":"","sources":["../../src/errors/OcpParseError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,+DAA+D;IAC/D,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,aAAc,SAAQ,QAAQ;IACzC,kDAAkD;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB;CAM5D"}

package/dist/errors/OcpParseError.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcpParseError = void 0;
+const codes_1 = require("./codes");
+const OcpError_1 = require("./OcpError");
+/**
+ * Errors from parsing or transforming data.
+ *
+ * Thrown when data cannot be parsed or transformed, such as invalid
+ * DAML responses, unknown enum values, or schema mismatches.
+ *
+ * @example
+ * ```typescript
+ * throw new OcpParseError('Unknown DAML stakeholder type: InvalidType', {
+ *   source: 'stakeholder.stakeholder_type',
+ *   code: OcpErrorCodes.UNKNOWN_ENUM_VALUE,
+ * });
+ * ```
+ *
+ * @example Catching parse errors
+ * ```typescript
+ * try {
+ *   const result = await ocp.OpenCapTable.stakeholder.getStakeholderAsOcf(params);
+ * } catch (error) {
+ *   if (error instanceof OcpParseError) {
+ *     console.error(`Parse error in ${error.source}: ${error.message}`);
+ *   }
+ * }
+ * ```
+ */
+class OcpParseError extends OcpError_1.OcpError {
+    constructor(message, options) {
+        const code = options?.code ?? codes_1.OcpErrorCodes.INVALID_RESPONSE;
+        super(message, code, options?.cause);
+        this.name = 'OcpParseError';
+        this.source = options?.source;
+    }
+}
+exports.OcpParseError = OcpParseError;
+//# sourceMappingURL=OcpParseError.js.map

package/dist/errors/OcpParseError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpParseError.js","sourceRoot":"","sources":["../../src/errors/OcpParseError.ts"],"names":[],"mappings":";;;AAAA,mCAA2D;AAC3D,yCAAsC;AAWtC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAa,aAAc,SAAQ,mBAAQ;IAIzC,YAAY,OAAe,EAAE,OAA8B;QACzD,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,qBAAa,CAAC,gBAAgB,CAAC;QAC7D,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,OAAO,EAAE,MAAM,CAAC;IAChC,CAAC;CACF;AAVD,sCAUC"}

package/dist/errors/OcpValidationError.d.ts

@@ -0,0 +1,49 @@
+import { type OcpErrorCode } from './codes';
+import { OcpError } from './OcpError';
+export interface OcpValidationErrorOptions {
+    /** The expected type for this field */
+    expectedType?: string;
+    /** The actual value received */
+    receivedValue?: unknown;
+    /** Specific validation error code (defaults to REQUIRED_FIELD_MISSING) */
+    code?: OcpErrorCode;
+}
+/**
+ * Validation errors for invalid input data.
+ *
+ * Thrown when input data fails validation before being sent to DAML contracts.
+ * Includes the field path where validation failed and optionally the expected
+ * type and received value.
+ *
+ * @example
+ * ```typescript
+ * if (!data.id) {
+ *   throw new OcpValidationError('stakeholder.id', 'Required field is missing or empty', {
+ *     expectedType: 'string',
+ *     receivedValue: data.id,
+ *   });
+ * }
+ * ```
+ *
+ * @example Catching validation errors
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.capTable.update(...).create('stakeholder', data).execute();
+ * } catch (error) {
+ *   if (error instanceof OcpValidationError) {
+ *     console.error(`Validation failed at '${error.fieldPath}': ${error.message}`);
+ *     console.error(`Expected: ${error.expectedType}, Got: ${error.receivedValue}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class OcpValidationError extends OcpError {
+    /** The dot-separated path to the field that failed validation */
+    readonly fieldPath: string;
+    /** The expected type for this field, if applicable */
+    readonly expectedType?: string;
+    /** The actual value that was received */
+    readonly receivedValue?: unknown;
+    constructor(fieldPath: string, message: string, options?: OcpValidationErrorOptions);
+}
+//# sourceMappingURL=OcpValidationError.d.ts.map

package/dist/errors/OcpValidationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpValidationError.d.ts","sourceRoot":"","sources":["../../src/errors/OcpValidationError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC,MAAM,WAAW,yBAAyB;IACxC,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,kBAAmB,SAAQ,QAAQ;IAC9C,iEAAiE;IACjE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAE3B,sDAAsD;IACtD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAE/B,yCAAyC;IACzC,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;gBAErB,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,yBAAyB;CAQpF"}

package/dist/errors/OcpValidationError.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcpValidationError = void 0;
+const codes_1 = require("./codes");
+const OcpError_1 = require("./OcpError");
+/**
+ * Validation errors for invalid input data.
+ *
+ * Thrown when input data fails validation before being sent to DAML contracts.
+ * Includes the field path where validation failed and optionally the expected
+ * type and received value.
+ *
+ * @example
+ * ```typescript
+ * if (!data.id) {
+ *   throw new OcpValidationError('stakeholder.id', 'Required field is missing or empty', {
+ *     expectedType: 'string',
+ *     receivedValue: data.id,
+ *   });
+ * }
+ * ```
+ *
+ * @example Catching validation errors
+ * ```typescript
+ * try {
+ *   await ocp.OpenCapTable.capTable.update(...).create('stakeholder', data).execute();
+ * } catch (error) {
+ *   if (error instanceof OcpValidationError) {
+ *     console.error(`Validation failed at '${error.fieldPath}': ${error.message}`);
+ *     console.error(`Expected: ${error.expectedType}, Got: ${error.receivedValue}`);
+ *   }
+ * }
+ * ```
+ */
+class OcpValidationError extends OcpError_1.OcpError {
+    constructor(fieldPath, message, options) {
+        const code = options?.code ?? codes_1.OcpErrorCodes.REQUIRED_FIELD_MISSING;
+        super(`Validation error at '${fieldPath}': ${message}`, code);
+        this.name = 'OcpValidationError';
+        this.fieldPath = fieldPath;
+        this.expectedType = options?.expectedType;
+        this.receivedValue = options?.receivedValue;
+    }
+}
+exports.OcpValidationError = OcpValidationError;
+//# sourceMappingURL=OcpValidationError.js.map

package/dist/errors/OcpValidationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OcpValidationError.js","sourceRoot":"","sources":["../../src/errors/OcpValidationError.ts"],"names":[],"mappings":";;;AAAA,mCAA2D;AAC3D,yCAAsC;AAWtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAa,kBAAmB,SAAQ,mBAAQ;IAU9C,YAAY,SAAiB,EAAE,OAAe,EAAE,OAAmC;QACjF,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,qBAAa,CAAC,sBAAsB,CAAC;QACnE,KAAK,CAAC,wBAAwB,SAAS,MAAM,OAAO,EAAE,EAAE,IAAI,CAAC,CAAC;QAC9D,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,YAAY,GAAG,OAAO,EAAE,YAAY,CAAC;QAC1C,IAAI,CAAC,aAAa,GAAG,OAAO,EAAE,aAAa,CAAC;IAC9C,CAAC;CACF;AAlBD,gDAkBC"}

package/dist/errors/codes.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Error codes for OCP SDK errors.
+ *
+ * These codes allow programmatic handling of specific error conditions.
+ */
+export declare const OcpErrorCodes: {
+    readonly REQUIRED_FIELD_MISSING: "REQUIRED_FIELD_MISSING";
+    readonly INVALID_TYPE: "INVALID_TYPE";
+    readonly INVALID_FORMAT: "INVALID_FORMAT";
+    readonly OUT_OF_RANGE: "OUT_OF_RANGE";
+    readonly CONTRACT_NOT_FOUND: "CONTRACT_NOT_FOUND";
+    readonly CHOICE_FAILED: "CHOICE_FAILED";
+    readonly AUTHORIZATION_FAILED: "AUTHORIZATION_FAILED";
+    readonly RESULT_NOT_FOUND: "RESULT_NOT_FOUND";
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly INVALID_RESPONSE: "INVALID_RESPONSE";
+    readonly SCHEMA_MISMATCH: "SCHEMA_MISMATCH";
+    readonly UNKNOWN_ENUM_VALUE: "UNKNOWN_ENUM_VALUE";
+};
+export type OcpErrorCode = (typeof OcpErrorCodes)[keyof typeof OcpErrorCodes];
+//# sourceMappingURL=codes.d.ts.map

package/dist/errors/codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codes.d.ts","sourceRoot":"","sources":["../../src/errors/codes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;CAsBhB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC"}

package/dist/errors/codes.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcpErrorCodes = void 0;
+/**
+ * Error codes for OCP SDK errors.
+ *
+ * These codes allow programmatic handling of specific error conditions.
+ */
+exports.OcpErrorCodes = {
+    // Validation errors
+    REQUIRED_FIELD_MISSING: 'REQUIRED_FIELD_MISSING',
+    INVALID_TYPE: 'INVALID_TYPE',
+    INVALID_FORMAT: 'INVALID_FORMAT',
+    OUT_OF_RANGE: 'OUT_OF_RANGE',
+    // Contract errors
+    CONTRACT_NOT_FOUND: 'CONTRACT_NOT_FOUND',
+    CHOICE_FAILED: 'CHOICE_FAILED',
+    AUTHORIZATION_FAILED: 'AUTHORIZATION_FAILED',
+    RESULT_NOT_FOUND: 'RESULT_NOT_FOUND',
+    // Network errors
+    CONNECTION_FAILED: 'CONNECTION_FAILED',
+    TIMEOUT: 'TIMEOUT',
+    RATE_LIMITED: 'RATE_LIMITED',
+    // Parse errors
+    INVALID_RESPONSE: 'INVALID_RESPONSE',
+    SCHEMA_MISMATCH: 'SCHEMA_MISMATCH',
+    UNKNOWN_ENUM_VALUE: 'UNKNOWN_ENUM_VALUE',
+};
+//# sourceMappingURL=codes.js.map

package/dist/errors/codes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codes.js","sourceRoot":"","sources":["../../src/errors/codes.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACU,QAAA,aAAa,GAAG;IAC3B,oBAAoB;IACpB,sBAAsB,EAAE,wBAAwB;IAChD,YAAY,EAAE,cAAc;IAC5B,cAAc,EAAE,gBAAgB;IAChC,YAAY,EAAE,cAAc;IAE5B,kBAAkB;IAClB,kBAAkB,EAAE,oBAAoB;IACxC,aAAa,EAAE,eAAe;IAC9B,oBAAoB,EAAE,sBAAsB;IAC5C,gBAAgB,EAAE,kBAAkB;IAEpC,iBAAiB;IACjB,iBAAiB,EAAE,mBAAmB;IACtC,OAAO,EAAE,SAAS;IAClB,YAAY,EAAE,cAAc;IAE5B,eAAe;IACf,gBAAgB,EAAE,kBAAkB;IACpC,eAAe,EAAE,iBAAiB;IAClC,kBAAkB,EAAE,oBAAoB;CAChC,CAAC"}

package/dist/errors/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Structured error types for the OCP SDK.
+ *
+ * This module provides a hierarchy of error types for different failure modes,
+ * enabling better error handling, debugging, and developer experience.
+ *
+ * @example Error handling
+ * ```typescript
+ * import {
+ *   OcpError,
+ *   OcpValidationError,
+ *   OcpContractError,
+ *   OcpNetworkError,
+ *   OcpParseError,
+ *   OcpErrorCodes,
+ * } from '@open-captable-protocol/canton';
+ *
+ * try {
+ *   await ocp.OpenCapTable.capTable.update(params).create('stakeholder', data).execute();
+ * } catch (error) {
+ *   if (error instanceof OcpValidationError) {
+ *     // Handle validation errors (invalid input)
+ *     console.error(`Invalid input at ${error.fieldPath}: ${error.message}`);
+ *   } else if (error instanceof OcpContractError) {
+ *     // Handle contract errors (DAML/Canton issues)
+ *     console.error(`Contract error on ${error.choice}: ${error.message}`);
+ *   } else if (error instanceof OcpNetworkError) {
+ *     // Handle network errors (connectivity issues)
+ *     console.error(`Network error: ${error.message}`);
+ *   } else if (error instanceof OcpParseError) {
+ *     // Handle parse errors (data transformation issues)
+ *     console.error(`Parse error: ${error.message}`);
+ *   } else if (error instanceof OcpError) {
+ *     // Handle any other OCP errors
+ *     console.error(`OCP Error [${error.code}]: ${error.message}`);
+ *   } else {
+ *     throw error; // Re-throw unknown errors
+ *   }
+ * }
+ * ```
+ */
+export { OcpErrorCodes, type OcpErrorCode } from './codes';
+export { OcpContractError, type OcpContractErrorOptions } from './OcpContractError';
+export { OcpError } from './OcpError';
+export { OcpNetworkError, type OcpNetworkErrorOptions } from './OcpNetworkError';
+export { OcpParseError, type OcpParseErrorOptions } from './OcpParseError';
+export { OcpValidationError, type OcpValidationErrorOptions } from './OcpValidationError';
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAG3D,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,KAAK,yBAAyB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/errors/index.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Structured error types for the OCP SDK.
+ *
+ * This module provides a hierarchy of error types for different failure modes,
+ * enabling better error handling, debugging, and developer experience.
+ *
+ * @example Error handling
+ * ```typescript
+ * import {
+ *   OcpError,
+ *   OcpValidationError,
+ *   OcpContractError,
+ *   OcpNetworkError,
+ *   OcpParseError,
+ *   OcpErrorCodes,
+ * } from '@open-captable-protocol/canton';
+ *
+ * try {
+ *   await ocp.OpenCapTable.capTable.update(params).create('stakeholder', data).execute();
+ * } catch (error) {
+ *   if (error instanceof OcpValidationError) {
+ *     // Handle validation errors (invalid input)
+ *     console.error(`Invalid input at ${error.fieldPath}: ${error.message}`);
+ *   } else if (error instanceof OcpContractError) {
+ *     // Handle contract errors (DAML/Canton issues)
+ *     console.error(`Contract error on ${error.choice}: ${error.message}`);
+ *   } else if (error instanceof OcpNetworkError) {
+ *     // Handle network errors (connectivity issues)
+ *     console.error(`Network error: ${error.message}`);
+ *   } else if (error instanceof OcpParseError) {
+ *     // Handle parse errors (data transformation issues)
+ *     console.error(`Parse error: ${error.message}`);
+ *   } else if (error instanceof OcpError) {
+ *     // Handle any other OCP errors
+ *     console.error(`OCP Error [${error.code}]: ${error.message}`);
+ *   } else {
+ *     throw error; // Re-throw unknown errors
+ *   }
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcpValidationError = exports.OcpParseError = exports.OcpNetworkError = exports.OcpError = exports.OcpContractError = exports.OcpErrorCodes = void 0;
+// Error codes
+var codes_1 = require("./codes");
+Object.defineProperty(exports, "OcpErrorCodes", { enumerable: true, get: function () { return codes_1.OcpErrorCodes; } });
+// Error classes
+var OcpContractError_1 = require("./OcpContractError");
+Object.defineProperty(exports, "OcpContractError", { enumerable: true, get: function () { return OcpContractError_1.OcpContractError; } });
+var OcpError_1 = require("./OcpError");
+Object.defineProperty(exports, "OcpError", { enumerable: true, get: function () { return OcpError_1.OcpError; } });
+var OcpNetworkError_1 = require("./OcpNetworkError");
+Object.defineProperty(exports, "OcpNetworkError", { enumerable: true, get: function () { return OcpNetworkError_1.OcpNetworkError; } });
+var OcpParseError_1 = require("./OcpParseError");
+Object.defineProperty(exports, "OcpParseError", { enumerable: true, get: function () { return OcpParseError_1.OcpParseError; } });
+var OcpValidationError_1 = require("./OcpValidationError");
+Object.defineProperty(exports, "OcpValidationError", { enumerable: true, get: function () { return OcpValidationError_1.OcpValidationError; } });
+//# sourceMappingURL=index.js.map

package/dist/errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;;;AAEH,cAAc;AACd,iCAA2D;AAAlD,sGAAA,aAAa,OAAA;AAEtB,gBAAgB;AAChB,uDAAoF;AAA3E,oHAAA,gBAAgB,OAAA;AACzB,uCAAsC;AAA7B,oGAAA,QAAQ,OAAA;AACjB,qDAAiF;AAAxE,kHAAA,eAAe,OAAA;AACxB,iDAA2E;AAAlE,8GAAA,aAAa,OAAA;AACtB,2DAA0F;AAAjF,wHAAA,kBAAkB,OAAA"}