@classytic/primitives 0.5.0 → 0.7.0

package/dist/payment-allocation-status.mjs

@@ -0,0 +1,39 @@
+//#region src/money/payment-allocation-status.ts
+/**
+* Allocation + reconciliation status enums for payment legs.
+*
+* Two orthogonal dimensions sit on every PaymentAllocation row (or
+* equivalent in any package that settles money against an invoice /
+* order / claim):
+*
+*   1. **Allocation status** — has this payment been *applied* against
+*      the obligation(s) it's meant to settle? (`unallocated`,
+*      `partial`, `allocated`, `over_allocated`)
+*   2. **Reconciliation status** — has this allocation been *matched*
+*      to a bank statement line / processor settlement record?
+*      (`unreconciled`, `matched`, `manual`, `disputed`)
+*
+* Both are needed because a payment can be allocated (the AR ledger
+* thinks it's done) without being reconciled (the bank statement
+* hasn't been imported / matched yet), and vice versa.
+*
+* Zero runtime, zero deps.
+*/
+const PAYMENT_ALLOCATION_STATUS = {
+	UNALLOCATED: "unallocated",
+	PARTIAL: "partial",
+	ALLOCATED: "allocated",
+	OVER_ALLOCATED: "over_allocated"
+};
+const RECONCILIATION_STATUS = {
+	UNRECONCILED: "unreconciled",
+	MATCHED: "matched",
+	MANUAL: "manual",
+	DISPUTED: "disputed"
+};
+const ALLOCATION_VALUES = new Set(Object.values(PAYMENT_ALLOCATION_STATUS));
+const RECONCILIATION_VALUES = new Set(Object.values(RECONCILIATION_STATUS));
+const isPaymentAllocationStatus = (value) => typeof value === "string" && ALLOCATION_VALUES.has(value);
+const isReconciliationStatus = (value) => typeof value === "string" && RECONCILIATION_VALUES.has(value);
+//#endregion
+export { PAYMENT_ALLOCATION_STATUS, RECONCILIATION_STATUS, isPaymentAllocationStatus, isReconciliationStatus };

package/dist/payment-events.d.mts

@@ -0,0 +1,141 @@
+import { Money } from "./money.mjs";
+import { PaymentMethodKind } from "./payment-method-kind.mjs";
+
+//#region src/events/payment-events.d.ts
+/**
+ * Canonical event-name constants. Packages SHOULD publish events
+ * keyed by these strings so consumers can subscribe by type without
+ * importing per-package catalogues.
+ */
+declare const PAYMENT_EVENT_TYPE: {
+  readonly INITIATED: "payment.initiated";
+  readonly SUCCEEDED: "payment.succeeded";
+  readonly FAILED: "payment.failed";
+  readonly REFUNDED: "payment.refunded";
+  readonly REVERSED: "payment.reversed";
+  readonly RECONCILED: "payment.reconciled";
+};
+type PaymentEventType = (typeof PAYMENT_EVENT_TYPE)[keyof typeof PAYMENT_EVENT_TYPE];
+/**
+ * A payment attempt has been started against a provider — intent
+ * created, checkout session opened, manual record drafted. The
+ * obligation is NOT settled yet; consumers should treat this as
+ * "money in flight" not "money received".
+ */
+interface PaymentInitiatedPayload {
+  /** Stable payment identifier owned by the emitting package. */
+  paymentId: string;
+  /**
+   * Provider's reference for this attempt — Stripe payment intent id,
+   * bKash sessionId, internal sequence number for manual entries.
+   */
+  providerRef?: string;
+  /** Provider name — `'stripe'`, `'bkash'`, `'manual'`, host-defined. */
+  providerCode: string;
+  amount: Money;
+  methodKind: PaymentMethodKind;
+  /**
+   * Host-specific method code from the host's PaymentMethod registry
+   * (e.g. `'bkash'`, `'stripe_card'`). Optional because not every host
+   * runs a registry; when absent, `methodKind` is the only classifier.
+   */
+  methodCode?: string;
+  occurredAt: Date;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * A payment has cleared — funds are confirmed received by the merchant
+ * (gateway success, manual confirmation, bank credit). This is the
+ * trigger for AR settlement, invoice paymentStatus updates, and
+ * downstream fulfilment unlocks.
+ */
+interface PaymentSucceededPayload {
+  paymentId: string;
+  providerRef?: string;
+  providerCode: string;
+  amount: Money;
+  methodKind: PaymentMethodKind;
+  methodCode?: string;
+  occurredAt: Date;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * A payment attempt failed before clearing — card declined, wallet
+ * timeout, manual rejection. The obligation remains unsettled;
+ * consumers may retry, prompt the customer, or mark the invoice
+ * overdue.
+ */
+interface PaymentFailedPayload {
+  paymentId: string;
+  providerRef?: string;
+  providerCode: string;
+  amount: Money;
+  methodKind: PaymentMethodKind;
+  methodCode?: string;
+  /** Human-readable reason from the provider or operator. */
+  reason: string;
+  /** Machine code for failure classification — e.g. `'card_declined'`. */
+  reasonCode?: string;
+  occurredAt: Date;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * A previously-succeeded payment has been refunded — partial or full.
+ * Distinct from {@link PaymentReversedPayload}: a refund returns money
+ * to the customer (post-settlement); a reversal undoes the settlement
+ * itself (pre- or post-clearing, often due to operator error).
+ */
+interface PaymentRefundedPayload {
+  paymentId: string;
+  /** Refund identifier (separate from `paymentId`). */
+  refundId: string;
+  providerRef?: string;
+  providerCode: string;
+  /** Amount refunded in this event — may be less than the original payment. */
+  refundedAmount: Money;
+  /** `true` if this refund returns less than the original payment total. */
+  isPartial: boolean;
+  reason?: string;
+  occurredAt: Date;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * A payment has been reversed — the settlement is being unwound,
+ * typically because of operator error, duplicate capture, or
+ * pre-clearing cancellation. Allocations referencing this payment
+ * MUST be unwound by consumers; AR balance restores to pre-payment
+ * state.
+ */
+interface PaymentReversedPayload {
+  paymentId: string;
+  providerRef?: string;
+  providerCode: string;
+  reason: string;
+  occurredAt: Date;
+  metadata?: Record<string, unknown>;
+}
+/**
+ * An allocation (the row that ties a payment to an obligation — invoice,
+ * order, claim) has been reconciled against a bank-statement line or
+ * processor settlement record. Triggers GL posting in country-aware
+ * ledger bridges and closes the audit loop.
+ */
+interface PaymentReconciledPayload {
+  /** Allocation identifier — NOT the payment id (a payment can have many). */
+  allocationId: string;
+  paymentId: string;
+  /**
+   * External reference of the matched record — typically a
+   * `BankTransaction.externalId`, processor settlement id, or
+   * operator-supplied note.
+   */
+  externalRef: string;
+  reconciledAt: Date;
+  /** Actor id who confirmed the match (operator) or `'system'` for auto-match. */
+  reconciledBy: string;
+  metadata?: Record<string, unknown>;
+}
+/** Union of all payment event payload types — convenient for exhaustive switches. */
+type PaymentEventPayload = PaymentInitiatedPayload | PaymentSucceededPayload | PaymentFailedPayload | PaymentRefundedPayload | PaymentReversedPayload | PaymentReconciledPayload;
+//#endregion
+export { PAYMENT_EVENT_TYPE, PaymentEventPayload, PaymentEventType, PaymentFailedPayload, PaymentInitiatedPayload, PaymentReconciledPayload, PaymentRefundedPayload, PaymentReversedPayload, PaymentSucceededPayload };

package/dist/payment-events.mjs

@@ -0,0 +1,16 @@
+//#region src/events/payment-events.ts
+/**
+* Canonical event-name constants. Packages SHOULD publish events
+* keyed by these strings so consumers can subscribe by type without
+* importing per-package catalogues.
+*/
+const PAYMENT_EVENT_TYPE = {
+	INITIATED: "payment.initiated",
+	SUCCEEDED: "payment.succeeded",
+	FAILED: "payment.failed",
+	REFUNDED: "payment.refunded",
+	REVERSED: "payment.reversed",
+	RECONCILED: "payment.reconciled"
+};
+//#endregion
+export { PAYMENT_EVENT_TYPE };

package/dist/payment-gateway.d.mts

@@ -1,6 +1,6 @@
 import { Money } from "./money.mjs";
 
-//#region src/payment-gateway.d.ts
+//#region src/money/payment-gateway.d.ts
 /**
  * Static capability declaration — providers expose this so the engine
  * can branch on what's supported (e.g. skip the refund button for

package/dist/payment-method-kind.d.mts

@@ -0,0 +1,36 @@
+//#region src/money/payment-method-kind.d.ts
+/**
+ * Canonical payment method kinds — the universal vocabulary every
+ * payment-aware package speaks (`@classytic/invoice`, `@classytic/revenue`,
+ * `@classytic/order`, future POS / AP / subscription packages, …).
+ *
+ * **Kind vs code.** A `PaymentMethodKind` is the universal category
+ * (every payment system on earth has these). A `methodCode` is the
+ * host-specific string registered in a host's `PaymentMethod` registry
+ * (`'bkash'`, `'nagad'`, `'stripe_card'`, `'cash_register_3'`). Packages
+ * speak `kind`; hosts speak `code`. The pair lets UIs branch on kind
+ * (show wallet form vs card form vs cash form) while the host owns the
+ * concrete method catalogue.
+ *
+ * Zero runtime, zero deps. Mirror this exactly anywhere a payment leg's
+ * "what kind of payment was this" needs to be typed.
+ */
+declare const PAYMENT_METHOD_KIND: {
+  /** Credit / debit card — Visa, Mastercard, Amex, RuPay, UnionPay, … */readonly CARD: "card"; /** Direct bank transfer — ACH, SEPA, IMPS, NEFT, RTGS, wire, … */
+  readonly BANK_TRANSFER: "bank_transfer"; /** Digital wallet — bKash, Nagad, PayPal, Apple Pay, Google Pay, Alipay, … */
+  readonly WALLET: "wallet"; /** Physical cash. */
+  readonly CASH: "cash"; /** Paper cheque. */
+  readonly CHEQUE: "cheque"; /** Cryptocurrency settlement. */
+  readonly CRYPTO: "cryptocurrency";
+  /**
+   * Operator-recorded settlement that doesn't fit any other kind — e.g.
+   * an offline bank deposit confirmed by phone, an in-kind exchange, a
+   * manual write-off. Always-valid escape hatch.
+   */
+  readonly MANUAL: "manual"; /** Unknown or vendor-specific kind — last resort. Prefer a specific kind. */
+  readonly OTHER: "other";
+};
+type PaymentMethodKind = (typeof PAYMENT_METHOD_KIND)[keyof typeof PAYMENT_METHOD_KIND];
+declare const isPaymentMethodKind: (value: unknown) => value is PaymentMethodKind;
+//#endregion
+export { PAYMENT_METHOD_KIND, PaymentMethodKind, isPaymentMethodKind };

package/dist/payment-method-kind.mjs

@@ -0,0 +1,31 @@
+//#region src/money/payment-method-kind.ts
+/**
+* Canonical payment method kinds — the universal vocabulary every
+* payment-aware package speaks (`@classytic/invoice`, `@classytic/revenue`,
+* `@classytic/order`, future POS / AP / subscription packages, …).
+*
+* **Kind vs code.** A `PaymentMethodKind` is the universal category
+* (every payment system on earth has these). A `methodCode` is the
+* host-specific string registered in a host's `PaymentMethod` registry
+* (`'bkash'`, `'nagad'`, `'stripe_card'`, `'cash_register_3'`). Packages
+* speak `kind`; hosts speak `code`. The pair lets UIs branch on kind
+* (show wallet form vs card form vs cash form) while the host owns the
+* concrete method catalogue.
+*
+* Zero runtime, zero deps. Mirror this exactly anywhere a payment leg's
+* "what kind of payment was this" needs to be typed.
+*/
+const PAYMENT_METHOD_KIND = {
+	CARD: "card",
+	BANK_TRANSFER: "bank_transfer",
+	WALLET: "wallet",
+	CASH: "cash",
+	CHEQUE: "cheque",
+	CRYPTO: "cryptocurrency",
+	MANUAL: "manual",
+	OTHER: "other"
+};
+const KIND_VALUES = new Set(Object.values(PAYMENT_METHOD_KIND));
+const isPaymentMethodKind = (value) => typeof value === "string" && KIND_VALUES.has(value);
+//#endregion
+export { PAYMENT_METHOD_KIND, isPaymentMethodKind };

package/dist/period.d.mts

@@ -1,4 +1,4 @@
-//#region src/period.d.ts
+//#region src/scheduling/period.d.ts
 /**
  * A closed date range `[start, end]`. Both endpoints inclusive — consumers
  * decide whether to treat them as `[start, end)` at the query layer.

package/dist/period.mjs

@@ -1,4 +1,4 @@
-//#region src/period.ts
+//#region src/scheduling/period.ts
 function isDateRange(value) {
 	return typeof value === "object" && value !== null && value.start instanceof Date && value.end instanceof Date;
 }

package/dist/person.d.mts

@@ -1,4 +1,4 @@
-//#region src/person.d.ts
+//#region src/identity/person.d.ts
 /**
  * Structured person name. Handles the parts most locales need; domains that
  * require more (per-locale honorifics, patronymics) extend from here.

package/dist/person.mjs

@@ -1,4 +1,4 @@
-//#region src/person.ts
+//#region src/identity/person.ts
 function formatFullName(name) {
 	return [
 		name.prefix,

package/dist/phone.d.mts

@@ -0,0 +1,47 @@
+import { Result } from "./result.mjs";
+
+//#region src/identity/phone.d.ts
+type PhoneErrorCode = 'EMPTY' | 'MISSING_PLUS' | 'NOT_E164' | 'TOO_SHORT' | 'TOO_LONG';
+declare class PhoneError extends Error {
+  readonly name = "PhoneError";
+  readonly code: PhoneErrorCode;
+  constructor(code: PhoneErrorCode, message: string);
+}
+/**
+ * Parsed phone number. Stored E.164 (always begins with `+`, digits only after).
+ * `callingCode` is the 1–3 digit country dial code (`'1'` US, `'44'` UK,
+ * `'880'` BD, etc.) — useful for routing without re-parsing.
+ *
+ * Construction goes through `parsePhone()` (never assemble by hand) so the
+ * invariants are guaranteed by the parser.
+ */
+interface PhoneNumber {
+  readonly e164: string;
+  readonly callingCode: string;
+  /** The national-number portion (digits after the calling code). */
+  readonly nationalNumber: string;
+}
+/**
+ * Parse free-form phone input into a normalized `PhoneNumber`. Accepts:
+ *   - `'+14155550182'`           → e164 unchanged
+ *   - `'+1 (415) 555-0182'`     → strips spaces / punctuation
+ *   - `'+1.415.555.0182'`        → strips dots
+ *
+ * Rejects anything without a leading `+` — we don't guess the country.
+ * If the host knows the user's region, prepend the code before calling.
+ */
+declare function parsePhone(input: string): Result<PhoneNumber, PhoneError>;
+/** Convenience: returns the E.164 string. Useful when piping to a transport. */
+declare function formatPhone(phone: PhoneNumber): string;
+/**
+ * Best-effort national-format render: groups the national number into 3-digit
+ * blocks. Not locale-aware — for display polish, hosts should format per
+ * region. Useful as a default in admin UIs.
+ *
+ * @example formatNational(parsePhone('+14155550182').value!) → '+1 415 555 0182'
+ */
+declare function formatNational(phone: PhoneNumber): string;
+/** Type guard. */
+declare function isPhoneNumber(value: unknown): value is PhoneNumber;
+//#endregion
+export { PhoneError, PhoneErrorCode, PhoneNumber, formatNational, formatPhone, isPhoneNumber, parsePhone };

package/dist/phone.mjs

@@ -0,0 +1,310 @@
+import { err, ok } from "./result.mjs";
+//#region src/identity/phone.ts
+/**
+* Phone number value object.
+*
+* `PersonName` and `Address` are typed; phones have been a plain `string` in
+* `ContactInfo` so far. This primitive closes that gap with a tiny,
+* zero-dependency wrapper that:
+*   1. Normalizes E.164 input (strips formatting, keeps the leading `+`).
+*   2. Captures the country calling code as a discrete field for routing /
+*      regional analytics.
+*   3. Surfaces parse failures via `Result<PhoneNumber, PhoneError>` so
+*      callers don't deal with thrown errors at value-object construction.
+*
+* Deliberately NOT a full libphonenumber dep — that ships ~500 KB of metadata
+* and is per-locale. We accept E.164 input and validate format; deeper
+* validation (region-of-issue, mobile-vs-landline) is the host's call to
+* layer on top. This keeps `@classytic/primitives` zero-dep and tree-shakeable.
+*
+* @example
+*   import { parsePhone, formatPhone, type PhoneNumber } from '@classytic/primitives/phone';
+*
+*   const parsed = parsePhone('+1 (415) 555-0182');
+*   if (parsed.ok) {
+*     formatPhone(parsed.value); // '+14155550182'
+*     parsed.value.callingCode;  // '1'
+*   }
+*/
+var PhoneError = class extends Error {
+	name = "PhoneError";
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/**
+* E.164 country calling codes by length. We accept 1–3 digits and let the
+* longest-prefix-match decide. Source: ITU-T E.164 assignments (snapshot —
+* stable across decades).
+*
+* Kept inline (not exported) because it's an implementation detail of the
+* parser. Length is the only thing we actually need for the split.
+*/
+const E164_PREFIXES_3 = new Set([
+	"210",
+	"211",
+	"212",
+	"213",
+	"216",
+	"218",
+	"220",
+	"221",
+	"222",
+	"223",
+	"224",
+	"225",
+	"226",
+	"227",
+	"228",
+	"229",
+	"230",
+	"231",
+	"232",
+	"233",
+	"234",
+	"235",
+	"236",
+	"237",
+	"238",
+	"239",
+	"240",
+	"241",
+	"242",
+	"243",
+	"244",
+	"245",
+	"246",
+	"247",
+	"248",
+	"249",
+	"250",
+	"251",
+	"252",
+	"253",
+	"254",
+	"255",
+	"256",
+	"257",
+	"258",
+	"260",
+	"261",
+	"262",
+	"263",
+	"264",
+	"265",
+	"266",
+	"267",
+	"268",
+	"269",
+	"290",
+	"291",
+	"297",
+	"298",
+	"299",
+	"350",
+	"351",
+	"352",
+	"353",
+	"354",
+	"355",
+	"356",
+	"357",
+	"358",
+	"359",
+	"370",
+	"371",
+	"372",
+	"373",
+	"374",
+	"375",
+	"376",
+	"377",
+	"378",
+	"379",
+	"380",
+	"381",
+	"382",
+	"383",
+	"385",
+	"386",
+	"387",
+	"389",
+	"420",
+	"421",
+	"423",
+	"500",
+	"501",
+	"502",
+	"503",
+	"504",
+	"505",
+	"506",
+	"507",
+	"508",
+	"509",
+	"590",
+	"591",
+	"592",
+	"593",
+	"594",
+	"595",
+	"596",
+	"597",
+	"598",
+	"599",
+	"670",
+	"672",
+	"673",
+	"674",
+	"675",
+	"676",
+	"677",
+	"678",
+	"679",
+	"680",
+	"681",
+	"682",
+	"683",
+	"685",
+	"686",
+	"687",
+	"688",
+	"689",
+	"690",
+	"691",
+	"692",
+	"800",
+	"808",
+	"850",
+	"852",
+	"853",
+	"855",
+	"856",
+	"870",
+	"878",
+	"880",
+	"881",
+	"882",
+	"883",
+	"886",
+	"888",
+	"960",
+	"961",
+	"962",
+	"963",
+	"964",
+	"965",
+	"966",
+	"967",
+	"968",
+	"970",
+	"971",
+	"972",
+	"973",
+	"974",
+	"975",
+	"976",
+	"977",
+	"979",
+	"992",
+	"993",
+	"994",
+	"995",
+	"996",
+	"998"
+]);
+const E164_PREFIXES_2 = new Set([
+	"20",
+	"27",
+	"30",
+	"31",
+	"32",
+	"33",
+	"34",
+	"36",
+	"39",
+	"40",
+	"41",
+	"43",
+	"44",
+	"45",
+	"46",
+	"47",
+	"48",
+	"49",
+	"51",
+	"52",
+	"53",
+	"54",
+	"55",
+	"56",
+	"57",
+	"58",
+	"60",
+	"61",
+	"62",
+	"63",
+	"64",
+	"65",
+	"66",
+	"81",
+	"82",
+	"84",
+	"86",
+	"90",
+	"91",
+	"92",
+	"93",
+	"94",
+	"95",
+	"98"
+]);
+const E164_PREFIXES_1 = new Set(["1", "7"]);
+/**
+* Parse free-form phone input into a normalized `PhoneNumber`. Accepts:
+*   - `'+14155550182'`           → e164 unchanged
+*   - `'+1 (415) 555-0182'`     → strips spaces / punctuation
+*   - `'+1.415.555.0182'`        → strips dots
+*
+* Rejects anything without a leading `+` — we don't guess the country.
+* If the host knows the user's region, prepend the code before calling.
+*/
+function parsePhone(input) {
+	if (typeof input !== "string" || input.trim().length === 0) return err(new PhoneError("EMPTY", "phone input is empty"));
+	const trimmed = input.trim();
+	if (!trimmed.startsWith("+")) return err(new PhoneError("MISSING_PLUS", `phone must be E.164 (start with '+'): got ${JSON.stringify(input)}`));
+	const digits = trimmed.slice(1).replace(/[^0-9]/g, "");
+	if (digits.length === 0) return err(new PhoneError("NOT_E164", "phone has no digits"));
+	if (digits.length > 15) return err(new PhoneError("TOO_LONG", `phone exceeds E.164 15-digit limit: ${digits.length} digits`));
+	if (digits.length < 7) return err(new PhoneError("TOO_SHORT", `phone too short to be E.164: ${digits.length} digits`));
+	const callingCode = E164_PREFIXES_3.has(digits.slice(0, 3)) ? digits.slice(0, 3) : E164_PREFIXES_2.has(digits.slice(0, 2)) ? digits.slice(0, 2) : E164_PREFIXES_1.has(digits.slice(0, 1)) ? digits.slice(0, 1) : null;
+	if (callingCode === null) return err(new PhoneError("NOT_E164", `unrecognized country calling code in ${JSON.stringify(input)}`));
+	return ok({
+		e164: `+${digits}`,
+		callingCode,
+		nationalNumber: digits.slice(callingCode.length)
+	});
+}
+/** Convenience: returns the E.164 string. Useful when piping to a transport. */
+function formatPhone(phone) {
+	return phone.e164;
+}
+/**
+* Best-effort national-format render: groups the national number into 3-digit
+* blocks. Not locale-aware — for display polish, hosts should format per
+* region. Useful as a default in admin UIs.
+*
+* @example formatNational(parsePhone('+14155550182').value!) → '+1 415 555 0182'
+*/
+function formatNational(phone) {
+	const groups = phone.nationalNumber.match(/.{1,3}/g) ?? [];
+	return `+${phone.callingCode} ${groups.join(" ")}`.trim();
+}
+/** Type guard. */
+function isPhoneNumber(value) {
+	return typeof value === "object" && value !== null && typeof value.e164 === "string" && typeof value.callingCode === "string" && typeof value.nationalNumber === "string" && value.e164.startsWith("+");
+}
+//#endregion
+export { PhoneError, formatNational, formatPhone, isPhoneNumber, parsePhone };

package/dist/reference.d.mts

@@ -1,4 +1,4 @@
-//#region src/reference.d.ts
+//#region src/composition/reference.d.ts
 /**
  * Minimal structural type for any ID object with a `.toString()` method. Does
  * NOT depend on `mongoose` — `Types.ObjectId` satisfies this shape

package/dist/reference.mjs

@@ -1,4 +1,4 @@
-//#region src/reference.ts
+//#region src/composition/reference.ts
 /** Coerce any {@link IdLike} to its canonical string form. */
 function idToString(id) {
 	return typeof id === "string" ? id : id.toString();

package/dist/result.d.mts

@@ -1,4 +1,4 @@
-//#region src/result.d.ts
+//#region src/composition/result.d.ts
 /**
  * A discriminated-union result type — an alternative to throwing for expected
  * domain failures. Zero-cost: use it where failure is a first-class outcome

package/dist/result.mjs

@@ -1,4 +1,4 @@
-//#region src/result.ts
+//#region src/composition/result.ts
 function ok(value) {
 	return {
 		ok: true,