@futdevpro/fsm-dynamo 1.20.88 → 1.20.93

package/build-esm/_enums/environment-flag.enum.js

@@ -0,0 +1,26 @@
+/**
+ * Flags representing the runtime environment of the application.
+ *
+ * @example
+ * ```ts
+ * if (flag === DyFM_EnvironmentFlag.dev) {
+ *   console.log('Development environment');
+ * }
+ * ```
+ */
+export var DyFM_EnvironmentFlag;
+(function (DyFM_EnvironmentFlag) {
+    DyFM_EnvironmentFlag["local"] = "local";
+    DyFM_EnvironmentFlag["dev"] = "dev";
+    DyFM_EnvironmentFlag["test"] = "test";
+    DyFM_EnvironmentFlag["prod"] = "prod";
+})(DyFM_EnvironmentFlag || (DyFM_EnvironmentFlag = {}));
+/**
+ * Every available environment flag collected into an array.
+ *
+ * @example
+ * ```ts
+ * console.log(DyFM_allEnvironmentFlags);
+ * ```
+ */
+export const DyFM_allEnvironmentFlags = Object.values(DyFM_EnvironmentFlag);

package/build-esm/_enums/error-level.enum.js

@@ -0,0 +1,35 @@
+/**
+ * Severity levels used for logging and error handling.
+ *
+ * @example
+ * ```ts
+ * if (err.level === DyFM_ErrorLevel.warning) {
+ *   console.warn('Handle warning');
+ * }
+ * ```
+ */
+export var DyFM_ErrorLevel;
+(function (DyFM_ErrorLevel) {
+    DyFM_ErrorLevel["user"] = "user";
+    DyFM_ErrorLevel["debug"] = "debug";
+    DyFM_ErrorLevel["info"] = "info";
+    DyFM_ErrorLevel["known"] = "known";
+    DyFM_ErrorLevel["warning"] = "warning";
+    DyFM_ErrorLevel["error"] = "error";
+    DyFM_ErrorLevel["serious"] = "serious";
+    DyFM_ErrorLevel["critical"] = "critical";
+    DyFM_ErrorLevel["fatal"] = "fatal";
+    /**
+     * Sister-rendszer / downstream dependency NEM elerheto. Az Overseer-szintu
+     * project-statuses watcher rogziti, vagy barmely host-app a generic HTTP/net
+     * down-detection-bol. SEM a sajat-szerver bug-ja, sem a generic application
+     * error — onmaga es a remediation-flow is mas (recheck, alert, NEM redeploy).
+     */
+    DyFM_ErrorLevel["systemUnreachable"] = "system-unreachable";
+    /**
+     * Build / pipeline-job sikertelen befejezes. Overseer-szinten a BuildResult
+     * `status: failed` hookja kuldi. NEM application error a kovetkez-szerver-en
+     * — a kategoria megengedi a "Failures" tab szuresere a generic errors-bol.
+     */
+    DyFM_ErrorLevel["buildFailure"] = "build-failure";
+})(DyFM_ErrorLevel || (DyFM_ErrorLevel = {}));

package/build-esm/_enums/error-status.enum.js

@@ -0,0 +1,28 @@
+/**
+ * Lifecycle status of a persisted error record (`DyFM_Errors`).
+ *
+ * Drives the error-tracking / fix-attempt / auto-reactivation flow:
+ * - `active` — open error, not yet claimed fixed (default for every new record).
+ * - `investigating` — someone is actively working on it (optional intermediate;
+ *   set manually, not auto-transitioned).
+ * - `fixed` — a fix was claimed (`recordFixAttempt` / `resolveError`); the record
+ *   is KEPT (never deleted) so a later recurrence can be detected.
+ * - `regressed` — a NEW occurrence arrived carrying a version `>=` the last
+ *   claimed-fix version → the fix did not hold → auto-reactivated by `recordError`.
+ *   Treated as "active again" on the dashboard, but distinguishable from a
+ *   never-fixed `active` so the next investigator knows a prior hypothesis failed.
+ *
+ * @example
+ * ```ts
+ * if (errorRecord.status === DyFM_ErrorStatus.regressed) {
+ *   // a shipped fix did not hold — re-investigate, do not trust "fixed in vN"
+ * }
+ * ```
+ */
+export var DyFM_ErrorStatus;
+(function (DyFM_ErrorStatus) {
+    DyFM_ErrorStatus["active"] = "active";
+    DyFM_ErrorStatus["investigating"] = "investigating";
+    DyFM_ErrorStatus["fixed"] = "fixed";
+    DyFM_ErrorStatus["regressed"] = "regressed";
+})(DyFM_ErrorStatus || (DyFM_ErrorStatus = {}));

package/build-esm/_enums/http/http-call-type.enum.js

@@ -0,0 +1,42 @@
+/**
+ * Basic HTTP request methods.
+ *
+ * @example
+ * ```ts
+ * const method: DyFM_HttpCallType = DyFM_HttpCallType.get;
+ * ```
+ */
+export var DyFM_HttpCallType;
+(function (DyFM_HttpCallType) {
+    DyFM_HttpCallType["get"] = "get";
+    DyFM_HttpCallType["post"] = "post";
+    DyFM_HttpCallType["put"] = "put";
+    DyFM_HttpCallType["patch"] = "patch";
+    DyFM_HttpCallType["delete"] = "delete";
+    DyFM_HttpCallType["head"] = "head";
+    DyFM_HttpCallType["options"] = "options";
+    DyFM_HttpCallType["purge"] = "purge";
+    DyFM_HttpCallType["link"] = "link";
+    DyFM_HttpCallType["unlink"] = "unlink";
+})(DyFM_HttpCallType || (DyFM_HttpCallType = {}));
+/**
+ * Basic HTTP encoding types.
+ *
+ * @example
+ * ```ts
+ * const type: DyFM_HttpEncodeType = DyFM_HttpEncodeType.ascii;
+ * ```
+ */
+export var DyFM_HttpEncodeType;
+(function (DyFM_HttpEncodeType) {
+    DyFM_HttpEncodeType["ascii"] = "ascii";
+    DyFM_HttpEncodeType["ansi"] = "ansi";
+    DyFM_HttpEncodeType["binary"] = "binary";
+    DyFM_HttpEncodeType["base64"] = "base64";
+    DyFM_HttpEncodeType["base64url"] = "base64url";
+    DyFM_HttpEncodeType["hex"] = "hex";
+    DyFM_HttpEncodeType["latin1"] = "latin1";
+    DyFM_HttpEncodeType["ucs2"] = "ucs2";
+    DyFM_HttpEncodeType["utf8"] = "utf8";
+    DyFM_HttpEncodeType["utf16le"] = "utf16le";
+})(DyFM_HttpEncodeType || (DyFM_HttpEncodeType = {}));

package/build-esm/_enums/http/http-event-type.enum.js

@@ -0,0 +1,39 @@
+/**
+ * Type enumeration for the different kinds of `HttpEvent`.
+ *
+ * @publicApi
+ *
+ * @example
+ * ```ts
+ * const event: DyFM_HttpEventType = DyFM_HttpEventType.sent;
+ * ```
+ */
+export var DyFM_HttpEventType;
+(function (DyFM_HttpEventType) {
+    /**
+     * The request was sent out over the wire.
+     */
+    DyFM_HttpEventType[DyFM_HttpEventType["sent"] = 0] = "sent";
+    /**
+     * An upload progress event was received.
+     *
+     * Note: The `FetchBackend` doesn't support progress report on uploads.
+     */
+    DyFM_HttpEventType[DyFM_HttpEventType["uploadProgress"] = 1] = "uploadProgress";
+    /**
+     * The response status code and headers were received.
+     */
+    DyFM_HttpEventType[DyFM_HttpEventType["responseHeader"] = 2] = "responseHeader";
+    /**
+     * A download progress event was received.
+     */
+    DyFM_HttpEventType[DyFM_HttpEventType["downloadProgress"] = 3] = "downloadProgress";
+    /**
+     * The full response including the body was received.
+     */
+    DyFM_HttpEventType[DyFM_HttpEventType["response"] = 4] = "response";
+    /**
+     * A custom event from an interceptor or a backend.
+     */
+    DyFM_HttpEventType[DyFM_HttpEventType["user"] = 5] = "user";
+})(DyFM_HttpEventType || (DyFM_HttpEventType = {}));

package/build-esm/_enums/http/http-response-type.enum.js

@@ -0,0 +1,18 @@
+/**
+ * Expected payload type of an HTTP response.
+ *
+ * @example
+ * ```ts
+ * const responseType = DyFM_HttpResponseType.json;
+ * ```
+ */
+export var DyFM_HttpResponseType;
+(function (DyFM_HttpResponseType) {
+    DyFM_HttpResponseType["arraybuffer"] = "arraybuffer";
+    DyFM_HttpResponseType["blob"] = "blob";
+    DyFM_HttpResponseType["document"] = "document";
+    DyFM_HttpResponseType["json"] = "json";
+    DyFM_HttpResponseType["text"] = "text";
+    DyFM_HttpResponseType["stream"] = "stream";
+    DyFM_HttpResponseType["formData"] = "formData";
+})(DyFM_HttpResponseType || (DyFM_HttpResponseType = {}));

package/build-esm/_enums/log-style.enum.js

@@ -0,0 +1,38 @@
+/**
+ * ANSI escape codes for console styling.
+ *
+ * @example
+ * ```ts
+ * console.log(DyFM_LogStyle.green + 'OK' + DyFM_LogStyle.reset);
+ * ```
+ */
+export var DyFM_LogStyle;
+(function (DyFM_LogStyle) {
+    DyFM_LogStyle["reset"] = "\u001B[0m";
+    /** (bold) */
+    DyFM_LogStyle["bold"] = "\u001B[1m";
+    DyFM_LogStyle["dim"] = "\u001B[2m";
+    DyFM_LogStyle["underline"] = "\u001B[4m";
+    DyFM_LogStyle["blink"] = "\u001B[5m";
+    DyFM_LogStyle["reverse"] = "\u001B[7m";
+    DyFM_LogStyle["hidden"] = "\u001B[8m";
+    DyFM_LogStyle["black"] = "\u001B[30m";
+    DyFM_LogStyle["red"] = "\u001B[31m";
+    DyFM_LogStyle["green"] = "\u001B[32m";
+    DyFM_LogStyle["orange"] = "\u001B[38;5;208m";
+    DyFM_LogStyle["brightOrange"] = "\u001B[38;5;214m";
+    DyFM_LogStyle["yellow"] = "\u001B[33m";
+    DyFM_LogStyle["blue"] = "\u001B[34m";
+    DyFM_LogStyle["magenta"] = "\u001B[35m";
+    DyFM_LogStyle["cyan"] = "\u001B[36m";
+    DyFM_LogStyle["white"] = "\u001B[37m";
+    DyFM_LogStyle["BgBlack"] = "\u001B[40m";
+    DyFM_LogStyle["BgRed"] = "\u001B[41m";
+    DyFM_LogStyle["BgGreen"] = "\u001B[42m";
+    DyFM_LogStyle["BgYellow"] = "\u001B[43m";
+    DyFM_LogStyle["BgBlue"] = "\u001B[44m";
+    DyFM_LogStyle["BgMagenta"] = "\u001B[45m";
+    DyFM_LogStyle["BgCyan"] = "\u001B[46m";
+    DyFM_LogStyle["BgWhite"] = "\u001B[47m";
+})(DyFM_LogStyle || (DyFM_LogStyle = {}));
+export const DyFM_allLogStyles = Object.values(DyFM_LogStyle);

package/build-esm/_enums/operation-auth.type-enum.js

@@ -0,0 +1,19 @@
+/**
+ * How the caller of an operation authenticated.
+ *
+ * @example
+ * ```ts
+ * if (ctx.authKind === DyFM_OperationAuth_Type.apiKey) {
+ *   // scope checks apply
+ * }
+ * ```
+ */
+export var DyFM_OperationAuth_Type;
+(function (DyFM_OperationAuth_Type) {
+    /** Anonymous call: no authenticated identity. */
+    DyFM_OperationAuth_Type["none"] = "none";
+    /** Authenticated with a user (session/JWT) token. */
+    DyFM_OperationAuth_Type["token"] = "token";
+    /** Authenticated with an API key; `apiKeyScopes` may restrict what it can call. */
+    DyFM_OperationAuth_Type["apiKey"] = "api-key";
+})(DyFM_OperationAuth_Type || (DyFM_OperationAuth_Type = {}));

package/build-esm/_enums/operation-if-match.type-enum.js

@@ -0,0 +1,17 @@
+/**
+ * Optimistic-concurrency mode of an operation (`guardrails.ifMatch`).
+ *
+ * @example
+ * ```ts
+ * const guardrails: DyFM_Operation_Guardrails = { ifMatch: DyFM_OperationIfMatch_Type.required };
+ * ```
+ */
+export var DyFM_OperationIfMatch_Type;
+(function (DyFM_OperationIfMatch_Type) {
+    /** A call without `ifMatch` is rejected with 428 before running. */
+    DyFM_OperationIfMatch_Type["required"] = "required";
+    /** Checked only when the caller sends `ifMatch`. */
+    DyFM_OperationIfMatch_Type["optional"] = "optional";
+    /** Never checked. */
+    DyFM_OperationIfMatch_Type["none"] = "none";
+})(DyFM_OperationIfMatch_Type || (DyFM_OperationIfMatch_Type = {}));

package/build-esm/_enums/operation-patch-field.type-enum.js

@@ -0,0 +1,40 @@
+/**
+ * Declared value type of a patch field (`guardrails.patchWhitelist`).
+ *
+ * # Why a patch field may carry a type at all
+ *
+ * A whitelist made of plain names answers only ONE question: *may this field be changed?* It can not
+ * answer the second one: *is this value usable?* That gap is not theoretical — it was measured on a live
+ * system (HP-DOPL, 2026-09-18): the `create` path of a task rejected an invalid due date with a coded
+ * error, while the `update` path accepted the very same value, because its patch guard only compared
+ * field NAMES. A typo therefore became stored data through the modify route.
+ *
+ * Declaring the type closes that gap at the same place where the field is already declared, so the two
+ * routes can not drift apart again.
+ *
+ * @example
+ * ```ts
+ * const guardrails: DyFM_Operation_Guardrails = {
+ *   patchWhitelist: [ 'title', { field: 'dueDate', type: DyFM_OperationPatchField_Type.date } ],
+ * };
+ * ```
+ */
+export var DyFM_OperationPatchField_Type;
+(function (DyFM_OperationPatchField_Type) {
+    /** Any string value. */
+    DyFM_OperationPatchField_Type["string"] = "string";
+    /** A finite number (`NaN` and `Infinity` are rejected). */
+    DyFM_OperationPatchField_Type["number"] = "number";
+    /** A boolean value. */
+    DyFM_OperationPatchField_Type["boolean"] = "boolean";
+    /**
+     * A value that yields a valid date. Accepted inputs: an ISO-like string, a millisecond number, or a
+     * `Date` instance — the check is deliberately the SAME as the one a create path performs, so the two
+     * routes stay interchangeable.
+     */
+    DyFM_OperationPatchField_Type["date"] = "date";
+    /** A plain object (an array is rejected). */
+    DyFM_OperationPatchField_Type["object"] = "object";
+    /** An array of any element type. */
+    DyFM_OperationPatchField_Type["array"] = "array";
+})(DyFM_OperationPatchField_Type || (DyFM_OperationPatchField_Type = {}));

package/build-esm/_enums/server-connection-status.enum.js

@@ -0,0 +1,5 @@
+export var DyFM_ServerConnection_Status;
+(function (DyFM_ServerConnection_Status) {
+    DyFM_ServerConnection_Status["accessible"] = "accessible";
+    DyFM_ServerConnection_Status["unaccessible"] = "unaccessible";
+})(DyFM_ServerConnection_Status || (DyFM_ServerConnection_Status = {}));

package/build-esm/_enums/time/day-of-week.enum.js

@@ -0,0 +1,47 @@
+/**
+ * Names of the days of the week.
+ *
+ * @example
+ * ```ts
+ * const today = DyFM_DayOfWeek.monday;
+ * ```
+ */
+export var DyFM_DayOfWeek;
+(function (DyFM_DayOfWeek) {
+    DyFM_DayOfWeek["monday"] = "monday";
+    DyFM_DayOfWeek["tuesday"] = "tuesday";
+    DyFM_DayOfWeek["wednesday"] = "wednesday";
+    DyFM_DayOfWeek["thursday"] = "thursday";
+    DyFM_DayOfWeek["friday"] = "friday";
+    DyFM_DayOfWeek["saturday"] = "saturday";
+    DyFM_DayOfWeek["sunday"] = "sunday";
+})(DyFM_DayOfWeek || (DyFM_DayOfWeek = {}));
+/**
+ * Every day of the week in an array.
+ *
+ * @example
+ * ```ts
+ * const daysOfWeek = DyFM_allDaysOfWeek;
+ * console.log(daysOfWeek); // [ 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday' ]
+ * ```
+ */
+export const DyFM_allDaysOfWeek = Object.values(DyFM_DayOfWeek);
+/** In U.S. order starting with Sunday
+ *
+ * @example
+ * ```ts
+ * const daysOfWeek = DyFM_allDaysOfWeekAmericanStyle;
+ * console.log(daysOfWeek); // [ DyFM_DayOfWeek.sunday, DyFM_DayOfWeek.monday, DyFM_DayOfWeek.tuesday, DyFM_DayOfWeek.wednesday, DyFM_DayOfWeek.thursday, DyFM_DayOfWeek.friday, DyFM_DayOfWeek.saturday ]
+ * ```
+ */
+export const DyFM_allDaysOfWeekAmericanStyle = [
+    DyFM_DayOfWeek.sunday,
+    DyFM_DayOfWeek.monday,
+    DyFM_DayOfWeek.tuesday,
+    DyFM_DayOfWeek.wednesday,
+    DyFM_DayOfWeek.thursday,
+    DyFM_DayOfWeek.friday,
+    DyFM_DayOfWeek.saturday,
+];
+/** Same as `DyFM_allDaysOfWeekAmericanStyle`. */
+export const DyFM_allDaysOfWeekStupid = DyFM_allDaysOfWeekAmericanStyle;

package/build-esm/_enums/time/month.enum.js

@@ -0,0 +1,23 @@
+/**
+ * Enumeration of calendar months.
+ *
+ * @example
+ * ```ts
+ * const month = DyFM_Month.january;
+ * ```
+ */
+export var DyFM_Month;
+(function (DyFM_Month) {
+    DyFM_Month["january"] = "january";
+    DyFM_Month["february"] = "february";
+    DyFM_Month["march"] = "march";
+    DyFM_Month["april"] = "april";
+    DyFM_Month["may"] = "may";
+    DyFM_Month["june"] = "june";
+    DyFM_Month["july"] = "july";
+    DyFM_Month["august"] = "august";
+    DyFM_Month["september"] = "september";
+    DyFM_Month["october"] = "october";
+    DyFM_Month["november"] = "november";
+    DyFM_Month["december"] = "december";
+})(DyFM_Month || (DyFM_Month = {}));

package/build-esm/_enums/time/relative-date.enum.js

@@ -0,0 +1,19 @@
+/**
+ * Human readable identifiers for relative date ranges.
+ *
+ * @example
+ * ```ts
+ * if (range === DyFM_RelativeDate.lastWeek) {
+ *   // ...
+ * }
+ * ```
+ */
+export var DyFM_RelativeDate;
+(function (DyFM_RelativeDate) {
+    DyFM_RelativeDate["lastDay"] = "lastDay";
+    DyFM_RelativeDate["lastWeek"] = "lastWeek";
+    DyFM_RelativeDate["lastMonth"] = "lastMonth";
+    DyFM_RelativeDate["lastYear"] = "lastYear";
+    DyFM_RelativeDate["last10Years"] = "last10Years";
+    DyFM_RelativeDate["allTime"] = "allTime";
+})(DyFM_RelativeDate || (DyFM_RelativeDate = {}));