@classytic/primitives 0.1.0

package/dist/events.d.mts

@@ -0,0 +1,240 @@
+//#region src/events.d.ts
+/**
+ * Domain event transport primitives.
+ *
+ * These shapes MIRROR `@classytic/arc`'s event types verbatim. Arc owns the
+ * contract — primitives tracks. Keep this file bit-identical to
+ * `packages/reference-only/arc/src/events/EventTransport.ts` for `EventMeta`,
+ * `DomainEvent`, `EventTransport`, `DeadLetteredEvent`, and
+ * `PublishManyResult`. Helpers (`createEvent`, `createChildEvent`) are
+ * allowed to be more defensive (e.g. fall back when `crypto.randomUUID` is
+ * unavailable) but their signatures must match arc.
+ *
+ * Packages declare these from primitives (instead of importing arc) so they
+ * remain runtime-independent of arc while still plugging into any arc
+ * `EventTransport` without adapters. See PACKAGE_RULES.md §11.
+ */
+/**
+ * Event metadata.
+ *
+ * Mirrored from arc v2.9. Any consumer using `@classytic/arc`'s `EventMeta`
+ * type gets a structural match with primitives' `EventMeta` and vice-versa.
+ */
+interface EventMeta {
+  /** Unique event identifier — UUID v4 recommended. */
+  id: string;
+  /** Emit timestamp. */
+  timestamp: Date;
+  /**
+   * Schema version for this event type. Default: `1`.
+   *
+   * Use when the payload shape evolves so handlers can branch on version
+   * during migration windows (`if (event.meta.schemaVersion === 2) ...`).
+   * Bump ONLY when the payload contract changes in a breaking way.
+   */
+  schemaVersion?: number;
+  /**
+   * Correlation ID — stays stable across an entire causal chain so a single
+   * user action can be traced through every downstream event. Spans service
+   * boundaries. Generated at the edge (HTTP request, CLI invocation) and
+   * inherited by every child event.
+   *
+   * Distinct from {@link causationId}: **correlation groups, causation chains.**
+   */
+  correlationId?: string;
+  /**
+   * Causation ID — the `meta.id` of the direct parent event that caused
+   * this one. Forms a linked-list of cause-and-effect within a correlation.
+   *
+   * Use {@link createChildEvent} to populate this automatically so handlers
+   * can't forget to propagate causality.
+   */
+  causationId?: string;
+  /**
+   * Partition key hint for ordered transports (Kafka, Kinesis, Redis Streams
+   * consumer groups). Events with the same partitionKey are guaranteed to be
+   * delivered in publish order by transports that honour it.
+   *
+   * Defaults to `resourceId` if unset. Transports that don't support ordering
+   * (in-memory, simple pub/sub) ignore this field.
+   */
+  partitionKey?: string;
+  /** Source resource name — e.g. 'order', 'transaction'. */
+  resource?: string;
+  /** Resource identifier — typically the document's public id. */
+  resourceId?: string;
+  /** User who triggered the event. */
+  userId?: string;
+  /** Organization / tenant scope. */
+  organizationId?: string;
+  /**
+   * Originating service or package (e.g. `'commerce'`, `'billing'`, `'arc-core'`).
+   *
+   * In a multi-service deployment, consumers route / log / alert by `source`
+   * without parsing `type` prefixes. Arc itself never populates this — hosts
+   * set it once per emitter. Inherited by {@link createChildEvent} so
+   * downstream events carry the same source unless overridden.
+   */
+  source?: string;
+  /**
+   * Idempotency key — stable hint that this event represents a specific
+   * operation exactly once. Consumers dedupe with
+   * `if (processed.has(meta.idempotencyKey)) return`.
+   *
+   * Survives every transport (Memory / Pub-Sub / Streams / Kafka) because
+   * it's part of the event, not a transport-side option. Distinct from
+   * `meta.id` (which is fresh per emit — a retry would produce a new id).
+   *
+   * Typical sources: HTTP `Idempotency-Key` header, outbox `dedupeKey`, or
+   * `{aggregate.type}:{aggregate.id}:{action}`. Inherited by child events.
+   */
+  idempotencyKey?: string;
+  /**
+   * DDD aggregate marker — the aggregate that owns this event's invariant.
+   *
+   * Use when routing events by aggregate, doing event-sourcing replay, or
+   * enforcing consistency boundaries. Distinct from `resource` / `resourceId`
+   * (HTTP-origin entity) because an event emitted *by* one REST resource can
+   * *belong to* a different aggregate (e.g. `POST /orders/:id/ship` emits
+   * `shipment.dispatched` owned by a shipment aggregate).
+   *
+   * Downstream packages narrow `aggregate.type` to their own string union via
+   * interface extension:
+   *
+   * ```ts
+   * type CartAggregateType = 'cart' | 'cart-item';
+   * interface CartEventMeta extends EventMeta {
+   *   aggregate?: { type: CartAggregateType; id: string };
+   * }
+   * ```
+   *
+   * Not inherited by {@link createChildEvent} — child events typically belong
+   * to a different aggregate than their parent.
+   */
+  aggregate?: {
+    type: string;
+    id: string;
+  };
+}
+interface DomainEvent<T = unknown> {
+  /** Dotted / colon-separated event name — e.g. 'order:placed'. */
+  type: string;
+  payload: T;
+  meta: EventMeta;
+}
+type EventHandler<T = unknown> = (event: DomainEvent<T>) => void | Promise<void>;
+/**
+ * A permanently-failed event routed to a dead-letter sink after retries
+ * have been exhausted. Mirrors the shape a caller would log, alert on, or
+ * replay from once the upstream issue is fixed.
+ */
+interface DeadLetteredEvent<T = unknown> {
+  /** The original event. */
+  event: DomainEvent<T>;
+  /** Serialised failure reason (message + optional machine code + stack). */
+  error: {
+    message: string;
+    code?: string;
+    stack?: string;
+  };
+  /** How many delivery attempts were made before giving up. */
+  attempts: number;
+  /** First failure timestamp. */
+  firstFailedAt: Date;
+  /** Last failure timestamp (immediately before dead-lettering). */
+  lastFailedAt: Date;
+  /** Optional handler / subscriber name that last failed (for debug). */
+  handlerName?: string;
+}
+/**
+ * Minimal logger interface for event transports. Compatible with `console`,
+ * `pino`, `fastify.log`, and any custom logger. Mirrors arc's `EventLogger`.
+ */
+interface EventLogger {
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Per-event publish outcome keyed by `meta.id`. `null` entry = success,
+ * `Error` = failure for that specific event. Matches arc's `publishMany`
+ * return contract.
+ */
+type PublishManyResult = ReadonlyMap<string, Error | null>;
+/**
+ * Transport contract. Any object matching this shape — arc's
+ * `MemoryEventTransport`, a Redis-backed transport, a Kafka publisher, or an
+ * in-process bus — can be passed into a Classytic package as
+ * `config.eventTransport`.
+ */
+interface EventTransport {
+  readonly name: string;
+  publish(event: DomainEvent): Promise<void>;
+  /**
+   * Publish a batch of events in one round-trip (optional). Arc v2.8.1+
+   * transports implement this; outbox relays auto-detect it for higher
+   * throughput. Consumers must fall back to per-event `publish()` when
+   * absent.
+   */
+  publishMany?(events: readonly DomainEvent[]): Promise<PublishManyResult>;
+  /**
+   * Subscribe to a glob pattern — exact match, `*`, or `resource.*`. Returns
+   * an unsubscribe function.
+   */
+  subscribe(pattern: string, handler: EventHandler): Promise<() => void>;
+  /**
+   * Route a permanently-failed event to the transport's dead-letter sink
+   * (Kafka DLQ topic, SQS DLQ, Redis Stream `PEL` timeout handler, etc.).
+   *
+   * Called by outbox relays after exhausting retries. Transports that don't
+   * have a native DLQ can omit this — callers treat an absent `deadLetter`
+   * as "log and drop".
+   */
+  deadLetter?(dlq: DeadLetteredEvent): Promise<void>;
+  close?(): Promise<void>;
+}
+/**
+ * Build a {@link DomainEvent} with auto-filled `id` + `timestamp`. All other
+ * `EventMeta` fields are caller-controlled and override the defaults if
+ * supplied (same semantics as arc's `createEvent`).
+ */
+declare function createEvent<T>(type: string, payload: T, meta?: Partial<EventMeta>): DomainEvent<T>;
+/**
+ * Create a child event that chains causation from a parent event.
+ *
+ * Rules (mirrored from arc v2.9):
+ *  - `causationId` is set to the parent's `id` (direct cause)
+ *  - `correlationId` is inherited from the parent if set, else falls back
+ *    to the parent's `id` (root correlation)
+ *  - `userId` / `organizationId` / `source` / `idempotencyKey` are inherited
+ *    when set on the parent so the whole chain stays scoped to the
+ *    originating principal, tenant, emitter, and logical operation
+ *  - `aggregate` is NOT inherited — child events typically belong to a
+ *    different aggregate than their parent
+ *
+ * Caller-supplied `meta` wins over inherited fields — pass `{ userId: newActor }`
+ * to override when a subsystem acts on behalf of a different principal.
+ *
+ * @example
+ * const orderPlaced = createEvent('order.placed', { orderId: 'o1' }, {
+ *   correlationId: req.id, userId: user.id,
+ * });
+ *
+ * const reserved = createChildEvent(orderPlaced, 'inventory.reserved', {
+ *   orderId: 'o1', skus: ['sku-1', 'sku-2'],
+ * });
+ * // reserved.meta.causationId   === orderPlaced.meta.id
+ * // reserved.meta.correlationId === orderPlaced.meta.correlationId
+ * // reserved.meta.userId        === user.id   (inherited)
+ */
+declare function createChildEvent<T>(parent: DomainEvent, type: string, payload: T, meta?: Partial<EventMeta>): DomainEvent<T>;
+/**
+ * Match an event name against a glob pattern. Implements the same rules as
+ * arc's `MemoryEventTransport`:
+ *   - `*` matches anything
+ *   - `prefix.*` matches anything starting with `prefix.`
+ *   - `prefix:*` matches anything starting with `prefix:` (Classytic convention)
+ *   - exact match otherwise
+ */
+declare function matchEventPattern(pattern: string, type: string): boolean;
+//#endregion
+export { DeadLetteredEvent, DomainEvent, EventHandler, EventLogger, EventMeta, EventTransport, PublishManyResult, createChildEvent, createEvent, matchEventPattern };

package/dist/events.mjs

@@ -0,0 +1,90 @@
+//#region src/events.ts
+/**
+* Build a {@link DomainEvent} with auto-filled `id` + `timestamp`. All other
+* `EventMeta` fields are caller-controlled and override the defaults if
+* supplied (same semantics as arc's `createEvent`).
+*/
+function createEvent(type, payload, meta) {
+	return {
+		type,
+		payload,
+		meta: {
+			id: randomEventId(),
+			timestamp: /* @__PURE__ */ new Date(),
+			...meta
+		}
+	};
+}
+/**
+* Create a child event that chains causation from a parent event.
+*
+* Rules (mirrored from arc v2.9):
+*  - `causationId` is set to the parent's `id` (direct cause)
+*  - `correlationId` is inherited from the parent if set, else falls back
+*    to the parent's `id` (root correlation)
+*  - `userId` / `organizationId` / `source` / `idempotencyKey` are inherited
+*    when set on the parent so the whole chain stays scoped to the
+*    originating principal, tenant, emitter, and logical operation
+*  - `aggregate` is NOT inherited — child events typically belong to a
+*    different aggregate than their parent
+*
+* Caller-supplied `meta` wins over inherited fields — pass `{ userId: newActor }`
+* to override when a subsystem acts on behalf of a different principal.
+*
+* @example
+* const orderPlaced = createEvent('order.placed', { orderId: 'o1' }, {
+*   correlationId: req.id, userId: user.id,
+* });
+*
+* const reserved = createChildEvent(orderPlaced, 'inventory.reserved', {
+*   orderId: 'o1', skus: ['sku-1', 'sku-2'],
+* });
+* // reserved.meta.causationId   === orderPlaced.meta.id
+* // reserved.meta.correlationId === orderPlaced.meta.correlationId
+* // reserved.meta.userId        === user.id   (inherited)
+*/
+function createChildEvent(parent, type, payload, meta) {
+	const inherited = {
+		correlationId: parent.meta.correlationId ?? parent.meta.id,
+		causationId: parent.meta.id
+	};
+	if (parent.meta.userId !== void 0) inherited.userId = parent.meta.userId;
+	if (parent.meta.organizationId !== void 0) inherited.organizationId = parent.meta.organizationId;
+	if (parent.meta.source !== void 0) inherited.source = parent.meta.source;
+	if (parent.meta.idempotencyKey !== void 0) inherited.idempotencyKey = parent.meta.idempotencyKey;
+	return {
+		type,
+		payload,
+		meta: {
+			id: randomEventId(),
+			timestamp: /* @__PURE__ */ new Date(),
+			...inherited,
+			...meta
+		}
+	};
+}
+/**
+* Match an event name against a glob pattern. Implements the same rules as
+* arc's `MemoryEventTransport`:
+*   - `*` matches anything
+*   - `prefix.*` matches anything starting with `prefix.`
+*   - `prefix:*` matches anything starting with `prefix:` (Classytic convention)
+*   - exact match otherwise
+*/
+function matchEventPattern(pattern, type) {
+	if (pattern === "*") return true;
+	if (pattern.endsWith(".*")) return type.startsWith(pattern.slice(0, -1));
+	if (pattern.endsWith(":*")) return type.startsWith(pattern.slice(0, -1));
+	return pattern === type;
+}
+/** Minimal UUID-v4-style identifier. Uses `crypto.randomUUID` when available. */
+function randomEventId() {
+	const g = globalThis;
+	if (g.crypto?.randomUUID) return g.crypto.randomUUID();
+	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+		const r = Math.random() * 16 | 0;
+		return (c === "x" ? r : r & 3 | 8).toString(16);
+	});
+}
+//#endregion
+export { createChildEvent, createEvent, matchEventPattern };

package/dist/hold.d.mts

@@ -0,0 +1,89 @@
+//#region src/hold.d.ts
+/**
+ * Hold reason value object + collection helpers.
+ *
+ * A `HoldReason` records that a domain document is blocked from progressing
+ * until the hold is resolved. The primitive is *pure data + pure helpers* —
+ * no FSM, no persistence, no events. Hosts embed `HoldReason[]` on their
+ * documents and use the helpers to add / resolve / query.
+ *
+ * Consumers: `@classytic/order` (fraud, manual, payment, credit, inventory
+ * holds), `@classytic/flow` (quality hold, customs hold), `@classytic/revenue`
+ * (chargeback hold).
+ *
+ * @example
+ * import { addHold, resolveHold, activeHolds, isOnHold } from '@classytic/primitives/hold';
+ *
+ * let holds = addHold([], {
+ *   code: 'credit_check_failed',
+ *   note: 'customer exceeds $50k limit',
+ *   actor: { id: 'system', kind: 'system' },
+ * });
+ * isOnHold(holds); // true
+ * holds = resolveHold(holds, holds[0].id, { actor: { id: 'user_42', kind: 'user' }, note: 'override approved' });
+ * isOnHold(holds); // false
+ */
+type HoldActorKind = 'user' | 'system' | 'service';
+interface HoldActor {
+  readonly id: string;
+  readonly kind: HoldActorKind;
+  readonly name?: string;
+}
+interface HoldReason {
+  /**
+   * Unique identifier within the collection — used to resolve a specific hold
+   * when multiple are active. Generated by {@link addHold} if caller omits it.
+   */
+  readonly id: string;
+  /** Domain-defined stable code, e.g. `fraud_review`, `customs_detention`. */
+  readonly code: string;
+  readonly note?: string;
+  readonly actor: HoldActor;
+  readonly createdAt: Date;
+  readonly resolvedAt?: Date;
+  readonly resolvedBy?: HoldActor;
+  readonly resolutionNote?: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+type HoldErrorCode = 'UNKNOWN_HOLD_ID' | 'ALREADY_RESOLVED' | 'INVALID_CODE' | 'DUPLICATE_HOLD_ID';
+declare class HoldError extends Error {
+  readonly name = "HoldError";
+  readonly code: HoldErrorCode;
+  constructor(code: HoldErrorCode, message: string);
+}
+interface AddHoldInput {
+  readonly id?: string;
+  readonly code: string;
+  readonly note?: string;
+  readonly actor: HoldActor;
+  readonly createdAt?: Date;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}
+interface ResolveHoldInput {
+  readonly actor: HoldActor;
+  readonly note?: string;
+  readonly resolvedAt?: Date;
+}
+/**
+ * Add a new hold to the collection. Returns a new array — original is not
+ * mutated. `id` is generated if omitted (stable format: `hold_{epochMs}_{rand}`).
+ */
+declare function addHold(holds: readonly HoldReason[], input: AddHoldInput): readonly HoldReason[];
+/**
+ * Resolve a specific hold by id. Throws if the id is unknown or the hold is
+ * already resolved.
+ */
+declare function resolveHold(holds: readonly HoldReason[], id: string, input: ResolveHoldInput): readonly HoldReason[];
+/** All holds that have not yet been resolved. */
+declare function activeHolds(holds: readonly HoldReason[]): readonly HoldReason[];
+/** True if at least one active (unresolved) hold exists. */
+declare function isOnHold(holds: readonly HoldReason[]): boolean;
+/**
+ * True if at least one active hold matches the given code. Useful for checking
+ * for a specific class of hold (e.g., "is this order on a fraud hold?").
+ */
+declare function hasActiveHoldOfCode(holds: readonly HoldReason[], code: string): boolean;
+/** All resolved holds — useful for audit timelines. */
+declare function resolvedHolds(holds: readonly HoldReason[]): readonly HoldReason[];
+//#endregion
+export { AddHoldInput, HoldActor, HoldActorKind, HoldError, HoldErrorCode, HoldReason, ResolveHoldInput, activeHolds, addHold, hasActiveHoldOfCode, isOnHold, resolveHold, resolvedHolds };

package/dist/hold.mjs

@@ -0,0 +1,69 @@
+//#region src/hold.ts
+var HoldError = class extends Error {
+	name = "HoldError";
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/**
+* Add a new hold to the collection. Returns a new array — original is not
+* mutated. `id` is generated if omitted (stable format: `hold_{epochMs}_{rand}`).
+*/
+function addHold(holds, input) {
+	if (!input.code || input.code.trim() === "") throw new HoldError("INVALID_CODE", "hold code must be a non-empty string");
+	const id = input.id ?? generateHoldId();
+	if (holds.some((h) => h.id === id)) throw new HoldError("DUPLICATE_HOLD_ID", `hold id already present: ${id}`);
+	const hold = {
+		id,
+		code: input.code,
+		...input.note !== void 0 ? { note: input.note } : {},
+		actor: input.actor,
+		createdAt: input.createdAt ?? /* @__PURE__ */ new Date(),
+		...input.metadata !== void 0 ? { metadata: input.metadata } : {}
+	};
+	return [...holds, hold];
+}
+/**
+* Resolve a specific hold by id. Throws if the id is unknown or the hold is
+* already resolved.
+*/
+function resolveHold(holds, id, input) {
+	const index = holds.findIndex((h) => h.id === id);
+	if (index === -1) throw new HoldError("UNKNOWN_HOLD_ID", `no hold with id ${id}`);
+	const hold = holds[index];
+	if (!hold) throw new HoldError("UNKNOWN_HOLD_ID", `no hold with id ${id}`);
+	if (hold.resolvedAt !== void 0) throw new HoldError("ALREADY_RESOLVED", `hold ${id} is already resolved`);
+	const resolved = {
+		...hold,
+		resolvedAt: input.resolvedAt ?? /* @__PURE__ */ new Date(),
+		resolvedBy: input.actor,
+		...input.note !== void 0 ? { resolutionNote: input.note } : {}
+	};
+	return holds.map((h, i) => i === index ? resolved : h);
+}
+/** All holds that have not yet been resolved. */
+function activeHolds(holds) {
+	return holds.filter((h) => h.resolvedAt === void 0);
+}
+/** True if at least one active (unresolved) hold exists. */
+function isOnHold(holds) {
+	return holds.some((h) => h.resolvedAt === void 0);
+}
+/**
+* True if at least one active hold matches the given code. Useful for checking
+* for a specific class of hold (e.g., "is this order on a fraud hold?").
+*/
+function hasActiveHoldOfCode(holds, code) {
+	return holds.some((h) => h.resolvedAt === void 0 && h.code === code);
+}
+/** All resolved holds — useful for audit timelines. */
+function resolvedHolds(holds) {
+	return holds.filter((h) => h.resolvedAt !== void 0);
+}
+function generateHoldId() {
+	return `hold_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+}
+//#endregion
+export { HoldError, activeHolds, addHold, hasActiveHoldOfCode, isOnHold, resolveHold, resolvedHolds };

package/dist/money.d.mts

@@ -0,0 +1,78 @@
+import { CurrencyCode } from "./currency.mjs";
+
+//#region src/money.d.ts
+/**
+ * A monetary amount stored as an integer in the currency's minor unit.
+ *
+ * Examples:
+ *  - `{ amount: 19_99,   currency: 'USD' }` — 19.99 USD (2 decimals)
+ *  - `{ amount: 1_500,   currency: 'JPY' }` — 1500 JPY (0 decimals)
+ *  - `{ amount: 500_000, currency: 'KWD' }` — 500.000 KWD (3 decimals)
+ *
+ * Storing as integers avoids IEEE 754 rounding across arithmetic. Never store
+ * `Money.amount` as a float.
+ */
+interface Money {
+  readonly amount: number;
+  readonly currency: CurrencyCode | string;
+}
+declare class CurrencyMismatchError extends Error {
+  readonly name = "CurrencyMismatchError";
+  readonly left: string;
+  readonly right: string;
+  constructor(left: string, right: string);
+}
+/**
+ * Construct {@link Money} from an integer minor-unit amount.
+ *
+ * @throws TypeError if `amount` is not a finite integer.
+ */
+declare function money(amount: number, currency: string): Money;
+/**
+ * Construct {@link Money} from a major-unit number (e.g. dollars, taka) by
+ * scaling to the currency's minor unit and rounding half-away-from-zero.
+ *
+ * Uses `toPrecision(15)` to strip the trailing-bit noise that appears in
+ * multiply-then-round (e.g. `0.1 + 0.2 = 0.30000000000000004`). This is
+ * enough for the vast majority of decimals encountered in real-world pricing.
+ *
+ * **Precision caveat.** A handful of decimals cannot be represented exactly
+ * in IEEE 754 and will round to the IEEE-closest integer rather than the
+ * mathematically-expected one — e.g. `1.005` is stored as `1.00499999…` and
+ * rounds to `100` minor units, not `101`. If you need decimal-exact rounding,
+ * construct money from a string or use integer minor units directly via
+ * {@link money}.
+ *
+ * @example
+ * fromMajor(19.99, 'USD')      // { amount: 1999, currency: 'USD' }
+ * fromMajor(0.1 + 0.2, 'USD')  // { amount: 30,   currency: 'USD' }
+ * fromMajor(1500,  'JPY')      // { amount: 1500, currency: 'JPY' }
+ */
+declare function fromMajor(major: number, currency: string): Money;
+/** Convert {@link Money} back to its major-unit floating-point representation. */
+declare function toMajor(m: Money): number;
+declare function addMoney(a: Money, b: Money): Money;
+declare function subtractMoney(a: Money, b: Money): Money;
+/**
+ * Multiply money by a scalar. The result is rounded to an integer number of
+ * minor units using half-away-from-zero rounding.
+ */
+declare function multiplyMoney(m: Money, scalar: number): Money;
+/** Sum a list of {@link Money}. Returns zero in the given currency for empty input. */
+declare function sumMoney(values: readonly Money[], currency: string): Money;
+/** Strict equality (amount and currency both match). */
+declare function equalsMoney(a: Money, b: Money): boolean;
+/**
+ * Ordering predicate. Returns -1, 0, or 1. Throws on currency mismatch — use
+ * {@link equalsMoney} for a total equality check across currencies.
+ */
+declare function compareMoney(a: Money, b: Money): -1 | 0 | 1;
+declare function isZeroMoney(m: Money): boolean;
+declare function isPositiveMoney(m: Money): boolean;
+declare function isNegativeMoney(m: Money): boolean;
+declare function negateMoney(m: Money): Money;
+declare function absMoney(m: Money): Money;
+/** Structural type guard. */
+declare function isMoney(value: unknown): value is Money;
+//#endregion
+export { CurrencyMismatchError, Money, absMoney, addMoney, compareMoney, equalsMoney, fromMajor, isMoney, isNegativeMoney, isPositiveMoney, isZeroMoney, money, multiplyMoney, negateMoney, subtractMoney, sumMoney, toMajor };