@cullet/erp-core 1.0.0

package/dist/validation-error.d.ts

@@ -0,0 +1,686 @@
+import { t as ValidationField } from "./validation-field.js";
+
+//#region src/core/errors/types.d.ts
+type ErrorSeverity = "low" | "medium" | "high" | "critical";
+type JsonSafePrimitive = string | number | boolean | null;
+type JsonSafeValue = JsonSafePrimitive | JsonSafeValue[] | {
+  [key: string]: JsonSafeValue;
+};
+type JsonSafeRecord = Record<string, JsonSafeValue>;
+/**
+ * Options accepted by the AppError constructor.
+ * Subclasses can extend or pick from this type.
+ */
+type AppErrorOptions = {
+  /** Original error or exception that caused this error. */
+  cause?: unknown;
+  /** Arbitrary key-value metadata (will be sanitized to JSON-safe values). */
+  metadata?: Record<string, unknown>;
+  /** Error category/type for grouping (e.g., "authentication", "validation"). */
+  type?: string;
+  /** severity level for alerting/logging prioritization. */
+  severity?: ErrorSeverity;
+  /**
+   * Identifies a single execution "story" in the system. All operations
+   * related to the same logical flow must share the same correlationId.
+   */
+  correlationId?: string;
+  /**
+   * Identifies a specific technical request attempt (each retry may produce
+   * a new requestId), even when the correlationId stays the same.
+   */
+  requestId?: string;
+  /**
+   * Identifies a unique business intent (idempotency key); stays the same
+   * across technical retries and multiple requests that represent the same intent.
+   */
+  commandId?: string;
+  /** ISO timestamp of when the error was created (defaults to now). */
+  createdAtIso?: string;
+  /** Safe message that can be exposed to end users (no internal details). */
+  publicMessage?: string;
+};
+//#endregion
+//#region src/core/errors/error-codes.d.ts
+declare const ErrorCodes: {
+  readonly authentication: {
+    readonly missingToken: "sec.authn.missing_token";
+    readonly invalidToken: "sec.authn.invalid_token";
+    readonly expiredToken: "sec.authn.expired_token";
+    readonly invalidCredentials: "sec.authn.invalid_credentials";
+  };
+  readonly authorization: {
+    readonly forbidden: "sec.authz.forbidden";
+    readonly policyDenied: "sec.authz.policy_denied";
+    readonly missingCapability: "sec.authz.missing_capability";
+    readonly outOfScope: "sec.authz.out_of_scope";
+  };
+  readonly businessRuleViolation: "business_rule_violation";
+  readonly conflict: {
+    readonly alreadyExists: "conf.already_exists";
+    readonly duplicate: "conf.duplicate";
+    readonly uniqueViolation: "conf.unique_violation";
+  };
+  readonly idempotency: {
+    readonly keyMissing: "idemp.key_missing";
+    readonly inProgress: "idemp.in_progress";
+    readonly payloadMismatch: "idemp.payload_mismatch";
+    readonly replayNotSupported: "idemp.replay_not_supported";
+  };
+  readonly integration: {
+    readonly timeout: "int.timeout";
+    readonly unreachable: "int.unreachable";
+    readonly badResponse: "int.bad_response";
+  };
+  readonly legacyIncompatible: "legacy_incompatible";
+  readonly notFound: "not_found";
+  readonly serialization: {
+    readonly deserializePrefix: "ser.des";
+    readonly serializePrefix: "ser.ser";
+  };
+  readonly temporal: {
+    readonly expired: "tmp.expired";
+    readonly notYetValid: "tmp.not_yet_valid";
+  };
+  readonly unexpected: "unexpected";
+  readonly validation: "validation_error";
+};
+type SerializationCodeDirection = "deserialize" | "serialize";
+declare function serializationErrorCode(direction: SerializationCodeDirection, category: string): string;
+//#endregion
+//#region src/core/errors/utils/json-safe.d.ts
+/**
+ * Ensures metadata is JSON-serializable.
+ *
+ * **Allowed:** string, number, boolean, null, arrays, and plain objects.
+ *
+ * **Converted to placeholder:** Date, BigInt, class instances, functions,
+ * symbols, undefined.
+ *
+ * @throws {TypeError} If `input` is not a plain object at the root level.
+ */
+declare function assertJsonSafeMetadata(input: unknown): JsonSafeRecord;
+//#endregion
+//#region src/core/errors/app-error.d.ts
+declare abstract class AppError extends Error {
+  readonly code: string;
+  readonly cause?: unknown;
+  readonly metadata?: JsonSafeRecord;
+  readonly type?: string;
+  readonly severity?: ErrorSeverity;
+  readonly createdAtIso: string;
+  readonly publicMessage?: string;
+  /**
+   * Identifies a single execution "story" in the system. All operations
+   * related to the same logical flow must share the same correlationId.
+   */
+  readonly correlationId?: string;
+  /**
+   * Identifies a specific technical request attempt (each retry may produce
+   * a new requestId), even when the correlationId stays the same.
+   */
+  readonly requestId?: string;
+  /**
+   * Marks the business intent / idempotency key; stays the same across
+   * technical retries and multiple requests that represent the same intent.
+   */
+  readonly commandId?: string;
+  protected constructor(message: string, code: string, options?: AppErrorOptions);
+  /**
+   * Returns a JSON-safe representation of the error.
+   * Does NOT include `cause` by default (to avoid leaking internal details).
+   */
+  toJSON(): Record<string, unknown>;
+}
+//#endregion
+//#region src/core/errors/authentication-error.d.ts
+type AuthenticationErrorReason = "missing_token" | "malformed_token" | "invalid_token" | "expired_token" | "revoked_token" | "invalid_credentials" | "session_not_found" | "session_expired" | "unknown";
+type AuthenticationErrorMetadata = {
+  reason: AuthenticationErrorReason;
+  authScheme?: "bearer" | "cookie" | "basic" | "unknown";
+  tokenLocation?: "header" | "cookie" | "query" | "unknown";
+  expiresAtIso?: string;
+  correlationId?: string;
+  requestId?: string;
+  details?: string;
+};
+type AuthenticationErrorFactoryOptions = Omit<AuthenticationErrorMetadata, "reason"> & Omit<AppErrorOptions, "metadata">;
+declare class AuthenticationError extends AppError {
+  readonly reason: AuthenticationErrorReason;
+  private constructor();
+  static missingToken(options?: AuthenticationErrorFactoryOptions): AuthenticationError;
+  static invalidToken(options?: AuthenticationErrorFactoryOptions & {
+    cause?: unknown;
+  }): AuthenticationError;
+  static expiredToken(options?: AuthenticationErrorFactoryOptions & {
+    sessionId?: string;
+  }): AuthenticationError;
+  static invalidCredentials(options?: Pick<AuthenticationErrorFactoryOptions, "correlationId" | "requestId" | "type" | "severity" | "createdAtIso" | "publicMessage">): AuthenticationError;
+}
+//#endregion
+//#region src/core/errors/authorization-error.d.ts
+type AuthorizationErrorReason = "forbidden" | "missing_role" | "missing_capability" | "out_of_scope" | "outside_time_window" | "policy_denied" | "unknown";
+type AuthorizationRequirement = {
+  role?: string;
+  capability?: string;
+  scope?: string;
+};
+type AuthorizationErrorMetadata = {
+  reason: AuthorizationErrorReason;
+  /** Stable action you evaluated (not an HTTP route — a "business action") */
+  action: string;
+  /** Resource identification (without leaking the full payload) */
+  resource?: {
+    type: string;
+    id?: string;
+  };
+  /** Optional: actor (do not include sensitive data) */
+  actor?: {
+    userId: string;
+    role?: string;
+  };
+  /** Optional: expected requirement */
+  required?: AuthorizationRequirement;
+  /** Optional: policy (when you already have PolicyEvaluation or similar) */
+  policyId?: string;
+  policyVersion?: number;
+  evaluatedAtIso?: string;
+  decision?: "allow" | "deny";
+  reasonCode?: string;
+  /** Optional: additional non-sensitive info */
+  details?: string;
+};
+/**
+ * Options for AuthorizationError factory methods.
+ * Combines metadata fields (except 'reason') with common AppError options.
+ */
+type AuthorizationErrorFactoryOptions = Omit<AuthorizationErrorMetadata, "reason"> & Omit<AppErrorOptions, "metadata">;
+declare class AuthorizationError extends AppError {
+  readonly reason: AuthorizationErrorReason;
+  private constructor();
+  static forbidden(input: AuthorizationErrorFactoryOptions): AuthorizationError;
+  static policyDenied(input: AuthorizationErrorFactoryOptions & {
+    policyId: string;
+    policyVersion: number;
+    evaluatedAtIso: string;
+  }): AuthorizationError;
+  static missingCapability(input: AuthorizationErrorFactoryOptions & {
+    required: AuthorizationRequirement;
+  }): AuthorizationError;
+  static outOfScope(input: AuthorizationErrorFactoryOptions & {
+    required?: AuthorizationRequirement;
+  }): AuthorizationError;
+}
+//#endregion
+//#region src/core/errors/business-rule-violation-error.d.ts
+declare class BusinessRuleViolationError extends AppError {
+  constructor(rule: string, message: string, detail?: Record<string, unknown>, options?: AppErrorOptions);
+}
+//#endregion
+//#region src/core/errors/conflict-error.d.ts
+/**
+ * Conflict kinds we want to distinguish semantically.
+ */
+type ConflictKind = "already_exists" | "duplicate" | "unique_violation";
+/**
+ * Metadata attached to conflicts without exposing sensitive values.
+ */
+type ConflictErrorMetadata = {
+  kind: ConflictKind;
+  entity: string;
+  operation?: string;
+  field?: string;
+  constraintName?: string;
+  existingId?: string;
+  valueHash?: string;
+  valuePreview?: string;
+  detectedAtIso?: string;
+  correlationId?: string;
+  requestId?: string;
+  commandId?: string;
+  hint?: string;
+};
+type UniqueConstraintViolation = {
+  kind: "unique_violation";
+  constraintName?: string;
+  table?: string;
+  columns?: string[];
+};
+declare abstract class ConflictError extends AppError {
+  readonly kind: ConflictKind;
+  protected constructor(params: {
+    message: string;
+    code: string;
+    kind: ConflictKind;
+    metadata: Omit<ConflictErrorMetadata, "kind">;
+    cause?: unknown;
+  } & AppErrorOptions);
+}
+declare class AlreadyExistsError extends ConflictError {
+  private constructor();
+  static detected(input: {
+    entity: string;
+    operation?: string;
+    field?: string;
+    existingId?: string;
+    valueHash?: string;
+    valuePreview?: string;
+    detectedAtIso?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    hint?: string;
+    cause?: unknown;
+  }): AlreadyExistsError;
+}
+declare class DuplicateError extends ConflictError {
+  private constructor();
+  static detected(input: {
+    entity: string;
+    operation?: string;
+    field?: string;
+    constraintName?: string;
+    existingId?: string;
+    valueHash?: string;
+    valuePreview?: string;
+    detectedAtIso?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    hint?: string;
+    cause?: unknown;
+  }): DuplicateError;
+}
+declare class UniqueConstraintViolationError extends ConflictError {
+  private constructor();
+  static detected(input: {
+    entity: string;
+    operation?: string;
+    constraintName?: string;
+    table?: string;
+    columns?: string[];
+    detectedAtIso?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    cause?: unknown;
+  }): UniqueConstraintViolationError;
+}
+declare function translateUniqueViolationToDuplicate(input: {
+  entity: string;
+  operation?: string;
+  violation: UniqueConstraintViolation;
+  field?: string;
+  ctx?: {
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    nowIso?: string;
+  };
+  cause?: unknown;
+}): DuplicateError;
+//#endregion
+//#region src/core/shared/hashing.d.ts
+declare function sha256Hex(value: string): string;
+declare function stableStringify(value: unknown): string;
+declare function payloadHash(value: unknown): string;
+//#endregion
+//#region src/core/errors/idempotency-error.d.ts
+type IdempotencyFailureKind = "key_missing" | "in_progress" | "payload_mismatch" | "replay_not_supported" | "unknown";
+type IdempotencyErrorMetadata = {
+  kind: IdempotencyFailureKind;
+  operation: string;
+  scope?: string;
+  entity?: string;
+  keyHash?: string;
+  keyPreview?: string;
+  incomingPayloadHash?: string;
+  existingPayloadHash?: string;
+  idempotencyRecordId?: string;
+  correlationId?: string;
+  requestId?: string;
+  commandId?: string;
+  detectedAtIso?: string;
+  hint?: string;
+  details?: string;
+};
+type IdempotencyErrorConstructorInput = {
+  message: string;
+  code: string;
+  kind: IdempotencyFailureKind;
+  metadata: Omit<IdempotencyErrorMetadata, "kind">;
+  cause?: unknown;
+};
+declare abstract class IdempotencyError extends AppError {
+  readonly kind: IdempotencyFailureKind;
+  protected constructor(input: IdempotencyErrorConstructorInput);
+  static keyMissing(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyKeyMissingError;
+  static inProgress(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    key?: string;
+    keyHash?: string;
+    keyPreview?: string;
+    idempotencyRecordId?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyInProgressError;
+  static payloadMismatch(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    key?: string;
+    keyHash?: string;
+    keyPreview?: string;
+    incomingPayloadHash?: string;
+    existingPayloadHash?: string;
+    idempotencyRecordId?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyPayloadMismatchError;
+  static replayNotSupported(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    key?: string;
+    keyHash?: string;
+    keyPreview?: string;
+    idempotencyRecordId?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyReplayNotSupportedError;
+}
+declare class IdempotencyKeyMissingError extends IdempotencyError {
+  private constructor();
+  static detected(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyKeyMissingError;
+}
+declare class IdempotencyInProgressError extends IdempotencyError {
+  private constructor();
+  static detected(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    key?: string;
+    keyHash?: string;
+    keyPreview?: string;
+    idempotencyRecordId?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyInProgressError;
+}
+declare class IdempotencyPayloadMismatchError extends IdempotencyError {
+  private constructor();
+  static detected(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    key?: string;
+    keyHash?: string;
+    keyPreview?: string;
+    incomingPayloadHash?: string;
+    existingPayloadHash?: string;
+    idempotencyRecordId?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyPayloadMismatchError;
+}
+declare class IdempotencyReplayNotSupportedError extends IdempotencyError {
+  private constructor();
+  static detected(input: {
+    operation: string;
+    scope?: string;
+    entity?: string;
+    key?: string;
+    keyHash?: string;
+    keyPreview?: string;
+    idempotencyRecordId?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    detectedAtIso?: string;
+    hint?: string;
+    details?: string;
+    cause?: unknown;
+  }): IdempotencyReplayNotSupportedError;
+}
+//#endregion
+//#region src/core/errors/integration-error.d.ts
+type IntegrationErrorReason = "timeout" | "unreachable" | "bad_response" | "unknown";
+type IntegrationErrorMetadata = {
+  reason: IntegrationErrorReason;
+  provider: string;
+  operation: string;
+  startedAtIso: string;
+  durationMs: number;
+  detectedAtIso?: string;
+  correlationId?: string;
+  requestId?: string;
+  commandId?: string;
+  details?: string;
+  statusCode?: number;
+  responseCode?: string;
+};
+declare class IntegrationError extends AppError {
+  readonly reason: IntegrationErrorReason;
+  private constructor();
+  static timeout(options: IntegrationErrorTimeoutOptions): IntegrationError;
+  static unreachable(options: IntegrationErrorEndpointOptions): IntegrationError;
+  static badResponse(options: IntegrationErrorEndpointOptions): IntegrationError;
+}
+type IntegrationErrorBaseOptions = {
+  provider: string;
+  operation: string;
+  startedAtIso: string;
+  durationMs: number;
+  detectedAtIso?: string;
+  correlationId?: string;
+  requestId?: string;
+  commandId?: string;
+  details?: string;
+  statusCode?: number;
+  responseCode?: string;
+  cause?: unknown;
+  type?: string;
+  severity?: ErrorSeverity;
+  createdAtIso?: string;
+  publicMessage?: string;
+};
+type IntegrationErrorTimeoutOptions = IntegrationErrorBaseOptions;
+type IntegrationErrorEndpointOptions = IntegrationErrorBaseOptions;
+//#endregion
+//#region src/core/errors/legacy-incompatible-error.d.ts
+declare class LegacyIncompatibleError extends AppError {
+  constructor(message: string, context?: Record<string, unknown>, options?: AppErrorOptions);
+}
+//#endregion
+//#region src/core/errors/not-found-error.d.ts
+declare class NotFoundError extends AppError {
+  constructor(resource: string, criteria?: Record<string, unknown>, options?: AppErrorOptions);
+}
+//#endregion
+//#region src/core/errors/serialization-error.d.ts
+type SerializationDirection = "serialize" | "deserialize";
+type SerializationFailureCategory = "invalid_json" | "invalid_shape" | "missing_field" | "unexpected_field" | "invalid_type" | "schema_version_missing" | "schema_version_unsupported" | "mapping_not_implemented" | "contract_mismatch" | "parse_failed" | "stringify_failed" | "unknown";
+type SerializationBoundary = "http_in" | "http_out" | "graphql_in" | "graphql_out" | "dto_to_domain" | "domain_to_dto" | "persistence_to_domain" | "domain_to_persistence" | "event_in" | "event_out" | "projection" | "unknown";
+/**
+ * Metadata shared by serialization/deserialization failures. Payload previews must be sanitized.
+ */
+type SerializationErrorMetadata = {
+  direction: SerializationDirection;
+  category: SerializationFailureCategory;
+  boundary: SerializationBoundary;
+  contract: string;
+  schemaVersion?: number | string;
+  path?: string;
+  payloadPreview?: string;
+  correlationId?: string;
+  requestId?: string;
+  commandId?: string;
+  hint?: string;
+  details?: string;
+};
+type SerializationErrorOptions = Omit<AppErrorOptions, "metadata"> & {
+  message: string;
+  code: string;
+  metadata: Omit<SerializationErrorMetadata, "direction" | "category">;
+  direction: SerializationDirection;
+  category: SerializationFailureCategory;
+};
+declare abstract class SerializationError extends AppError {
+  readonly direction: SerializationDirection;
+  readonly category: SerializationFailureCategory;
+  readonly boundary: SerializationBoundary;
+  readonly contract: string;
+  protected constructor(input: SerializationErrorOptions);
+}
+declare class SerializationInError extends SerializationError {
+  private constructor();
+  static failure(category: SerializationFailureCategory, metadata: Omit<SerializationErrorMetadata, "direction" | "category"> & {
+    cause?: unknown;
+  }): SerializationInError;
+}
+declare class SerializationOutError extends SerializationError {
+  private constructor();
+  static failure(category: SerializationFailureCategory, metadata: Omit<SerializationErrorMetadata, "direction" | "category"> & {
+    cause?: unknown;
+  }): SerializationOutError;
+}
+declare class SerializationCodes {
+  static code(direction: SerializationDirection, category: SerializationFailureCategory): string;
+}
+declare class SerializationMessages {
+  static message(direction: SerializationDirection, category: SerializationFailureCategory): string;
+}
+declare function safePreview(value: unknown, limit?: number): string | undefined;
+//#endregion
+//#region src/core/errors/temporal-error.d.ts
+type TemporalKind = "expired" | "not_yet_valid";
+type TemporalPrecision = "EXACT" | "ESTIMATED" | "UNKNOWN" | "APPROXIMATE";
+type TemporalErrorMetadata = {
+  resourceType: string;
+  resourceId?: string;
+  operation?: string;
+  validFromIso?: string | null;
+  validUntilIso?: string | null;
+  evaluatedAtIso: string;
+  policyId?: string;
+  precision?: TemporalPrecision;
+  hint?: string;
+  details?: string;
+  correlationId?: string;
+  requestId?: string;
+  commandId?: string;
+};
+type TemporalErrorOptions = {
+  message: string;
+  code: string;
+  kind: TemporalKind;
+  metadata: TemporalErrorMetadata;
+} & AppErrorOptions;
+declare abstract class TemporalError extends AppError {
+  readonly kind: TemporalKind;
+  readonly resourceType: string;
+  readonly evaluatedAtIso: string;
+  protected constructor(input: TemporalErrorOptions);
+}
+type TemporalCreationInput = TemporalErrorMetadata & Partial<Omit<AppErrorOptions, "metadata">> & {
+  cause?: unknown;
+};
+declare class ExpiredError extends TemporalError {
+  private constructor();
+  static detected(input: TemporalCreationInput): ExpiredError;
+}
+declare class NotYetValidError extends TemporalError {
+  private constructor();
+  static detected(input: TemporalCreationInput): NotYetValidError;
+}
+declare function evaluateTemporalWindow(input: {
+  validFromIso?: string | null;
+  validUntilIso?: string | null;
+  evaluatedAtIso: string;
+}): {
+  expired: boolean;
+  notYetValid: boolean;
+} | null;
+//#endregion
+//#region src/core/errors/unexpected-error.d.ts
+declare class UnexpectedError extends AppError {
+  constructor(message?: string, cause?: unknown, options?: Omit<AppErrorOptions, "cause">);
+}
+//#endregion
+//#region src/core/exceptions/validation-code.d.ts
+declare class ValidationCode {
+  readonly value: string;
+  private constructor();
+  static of(value: string): ValidationCode;
+  static readonly BLANK: ValidationCode;
+  static readonly REQUIRED: ValidationCode;
+  static readonly INVALID_FORMAT: ValidationCode;
+  static readonly INVALID_CHARACTERS: ValidationCode;
+  static readonly INVALID_LENGTH: ValidationCode;
+  static readonly TOO_SHORT: ValidationCode;
+  static readonly TOO_LONG: ValidationCode;
+  static readonly OUT_OF_RANGE: ValidationCode;
+  static readonly INVALID_CHECKSUM: ValidationCode;
+  static readonly INVALID_CHECKING_DIGIT: ValidationCode;
+  static readonly ALREADY_EXISTS: ValidationCode;
+  static readonly NOT_FOUND: ValidationCode;
+  static readonly NOT_ALLOWED: ValidationCode;
+  static readonly UNEXPECTED: ValidationCode;
+}
+//#endregion
+//#region src/core/errors/validation-error.d.ts
+declare class ValidationError extends AppError {
+  constructor(field: ValidationField, code: ValidationCode, message: string, options?: AppErrorOptions);
+}
+//#endregion
+export { ErrorCodes as $, IdempotencyPayloadMismatchError as A, UniqueConstraintViolation as B, IntegrationErrorMetadata as C, IdempotencyFailureKind as D, IdempotencyErrorMetadata as E, AlreadyExistsError as F, AuthorizationErrorMetadata as G, translateUniqueViolationToDuplicate as H, ConflictError as I, AuthenticationError as J, AuthorizationErrorReason as K, ConflictErrorMetadata as L, payloadHash as M, sha256Hex as N, IdempotencyInProgressError as O, stableStringify as P, assertJsonSafeMetadata as Q, ConflictKind as R, IntegrationError as S, IdempotencyError as T, BusinessRuleViolationError as U, UniqueConstraintViolationError as V, AuthorizationError as W, AuthenticationErrorReason as X, AuthenticationErrorMetadata as Y, AppError as Z, SerializationMessages as _, TemporalError as a, JsonSafeValue as at, NotFoundError as b, TemporalPrecision as c, SerializationCodes as d, serializationErrorCode as et, SerializationDirection as f, SerializationInError as g, SerializationFailureCategory as h, NotYetValidError as i, JsonSafeRecord as it, IdempotencyReplayNotSupportedError as j, IdempotencyKeyMissingError as k, evaluateTemporalWindow as l, SerializationErrorMetadata as m, UnexpectedError as n, ErrorSeverity as nt, TemporalErrorMetadata as o, SerializationError as p, AuthorizationRequirement as q, ExpiredError as r, JsonSafePrimitive as rt, TemporalKind as s, ValidationError as t, AppErrorOptions as tt, SerializationBoundary as u, SerializationOutError as v, IntegrationErrorReason as w, LegacyIncompatibleError as x, safePreview as y, DuplicateError as z };
+//# sourceMappingURL=validation-error.d.ts.map