typebox 1.0.31 → 1.0.33

package/build/cjs/system/locale/zh_Hant.js

@@ -0,0 +1,44 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-coverage-ignore-start
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zh_Hant = zh_Hant;
+/** Chinese (Traditional) - ISO 639-1 language code 'zh' with script code 'Hant' for Traditional Chinese. */
+function zh_Hant(error) {
+    switch (error.keyword) {
+        case 'additionalProperties': return '不得有額外屬性';
+        case 'anyOf': return '必須匹配 anyOf 中的一個模式';
+        case 'boolean': return '模式為假';
+        case 'const': return '必須等於常數';
+        case 'contains': return '必須至少包含 1 個有效項目';
+        case 'dependencies': return `當屬性 ${error.params.property} 存在時，必須具有屬性 ${error.params.dependencies.join(', ')}`;
+        case 'dependentRequired': return `當屬性 ${error.params.property} 存在時，必須具有屬性 ${error.params.dependencies.join(', ')}`;
+        case 'enum': return '必須等於允許值中的一個';
+        case 'exclusiveMaximum': return `必須 ${error.params.comparison} ${error.params.limit}`;
+        case 'exclusiveMinimum': return `必須 ${error.params.comparison} ${error.params.limit}`;
+        case 'format': return `必須匹配格式 "${error.params.format}"`;
+        case 'if': return `必須匹配 "${error.params.failingKeyword}" 模式`;
+        case 'maxItems': return `不得多於 ${error.params.limit} 個項目`;
+        case 'maxLength': return `不得多於 ${error.params.limit} 個字元`;
+        case 'maxProperties': return `不得多於 ${error.params.limit} 個屬性`;
+        case 'maximum': return `必須 ${error.params.comparison} ${error.params.limit}`;
+        case 'minItems': return `不得少於 ${error.params.limit} 個項目`;
+        case 'minLength': return `不得少於 ${error.params.limit} 個字元`;
+        case 'minProperties': return `不得少於 ${error.params.limit} 個屬性`;
+        case 'minimum': return `必須 ${error.params.comparison} ${error.params.limit}`;
+        case 'multipleOf': return `必須是 ${error.params.multipleOf} 的倍數`;
+        case 'not': return '不得有效';
+        case 'oneOf': return '必須精確匹配 oneOf 中的一個模式';
+        case 'pattern': return `必須匹配模式 "${error.params.pattern}"`;
+        case 'propertyNames': return `屬性名稱 ${error.params.propertyNames.join(', ')} 無效`;
+        case 'required': return `必須具有必需屬性 ${error.params.requiredProperties.join(', ')}`;
+        case 'type': return typeof error.params.type === 'string' ? `必須是 ${error.params.type}` : `必須是 ${error.params.type.join(' 或 ')} 之一`;
+        case 'unevaluatedItems': return '不得有未評估的項目';
+        case 'unevaluatedProperties': return '不得有未評估的屬性';
+        case 'uniqueItems': return `不得有重複項目`;
+        case '~guard': return `必須與檢查函數匹配`;
+        case '~refine': return error.params.message;
+        default: return '發生未知驗證錯誤';
+    }
+}
+// deno-coverage-ignore-stop

package/build/cjs/system/memory/assign.js

@@ -0,0 +1,13 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assign = Assign;
+const metrics_1 = require("./metrics");
+/**
+ * Performs an Object assign using the Left and Right object types. We track this operation as it
+ * creates a new GC handle per assignment.
+ */
+function Assign(left, right) {
+    metrics_1.Metrics.assign += 1;
+    return { ...left, ...right };
+}

package/build/cjs/system/memory/clone.js

@@ -0,0 +1,66 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clone = Clone;
+const index_1 = require("../../guard/index");
+const metrics_1 = require("./metrics");
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+function IsGuard(value) {
+    return index_1.Guard.IsObject(value) && index_1.Guard.HasPropertyKey(value, '~guard');
+}
+function FromGuard(value) {
+    return value; // non-clonable
+}
+// ------------------------------------------------------------------
+// Array
+// ------------------------------------------------------------------
+function FromArray(value) {
+    return value.map((value) => FromValue(value));
+}
+// ------------------------------------------------------------------
+// Object
+// ------------------------------------------------------------------
+function FromObject(value) {
+    const result = {};
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const key of Object.keys(descriptors)) {
+        const descriptor = descriptors[key];
+        if (index_1.Guard.HasPropertyKey(descriptor, 'value')) {
+            Object.defineProperty(result, key, { ...descriptor, value: FromValue(descriptor.value) });
+        }
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+function FromRegExp(value) {
+    return new RegExp(value.source, value.flags);
+}
+// ------------------------------------------------------------------
+// RegExp
+// ------------------------------------------------------------------
+function FromUnknown(value) {
+    return value;
+}
+// ------------------------------------------------------------------
+// Value
+// ------------------------------------------------------------------
+function FromValue(value) {
+    return (value instanceof RegExp ? FromRegExp(value) :
+        IsGuard(value) ? FromGuard(value) :
+            index_1.Guard.IsArray(value) ? FromArray(value) :
+                index_1.Guard.IsObject(value) ? FromObject(value) :
+                    FromUnknown(value));
+}
+/**
+ * Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
+ * properties from the source value. This is to ensure cloned types retain discriminable
+ * hidden properties.
+ */
+function Clone(value) {
+    metrics_1.Metrics.clone += 1;
+    return FromValue(value);
+}

package/build/cjs/system/memory/create.js

@@ -0,0 +1,26 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Create = Create;
+const index_1 = require("../settings/index");
+const metrics_1 = require("./metrics");
+function Merge(left, right, configuration = {}) {
+    const descriptor = { configurable: true, writable: true, enumerable: true, ...configuration };
+    for (const key of Object.keys(right)) {
+        Object.defineProperty(left, key, { ...descriptor, value: right[key] });
+    }
+    return left;
+}
+/**
+ * Creates an object with hidden, enumerable, and optional property sets. This function
+ * ensures types are instantiated according to configuration rules for enumerable and
+ * non-enumerable properties.
+ */
+function Create(hidden, enumerable, options = {}) {
+    metrics_1.Metrics.create += 1;
+    const settings = index_1.Settings.Get();
+    const withHidden = Merge({}, hidden, { enumerable: settings.enumerableKind });
+    const withEnumerable = Merge(withHidden, enumerable);
+    const withOptions = Merge(withEnumerable, options);
+    return settings.immutableTypes ? Object.freeze(withOptions) : withOptions;
+}

package/build/cjs/system/memory/discard.js

@@ -0,0 +1,19 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Discard = Discard;
+const metrics_1 = require("./metrics");
+const clone_1 = require("./clone");
+/** Discards multiple property keys from the given object value */
+function Discard(value, propertyKeys) {
+    metrics_1.Metrics.discard += 1;
+    const result = {};
+    const descriptors = Object.getOwnPropertyDescriptors((0, clone_1.Clone)(value));
+    const keysToDiscard = new Set(propertyKeys);
+    for (const key of Object.keys(descriptors)) {
+        if (keysToDiscard.has(key))
+            continue;
+        Object.defineProperty(result, key, descriptors[key]);
+    }
+    return result;
+}

package/build/cjs/system/memory/index.d.ts

@@ -0,0 +1 @@
+export * as Memory from './memory';

package/build/cjs/system/memory/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+exports.Memory = require("./memory");

package/build/cjs/system/memory/memory.d.ts

@@ -0,0 +1,6 @@
+export * from './assign';
+export * from './clone';
+export * from './create';
+export * from './discard';
+export * from './metrics';
+export * from './update';

package/build/cjs/system/memory/memory.js

@@ -0,0 +1,23 @@
+"use strict";
+// deno-fmt-ignore-file
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assign"), exports);
+__exportStar(require("./clone"), exports);
+__exportStar(require("./create"), exports);
+__exportStar(require("./discard"), exports);
+__exportStar(require("./metrics"), exports);
+__exportStar(require("./update"), exports);

package/build/cjs/system/memory/metrics.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Metrics = void 0;
+/** TypeBox instantiation metrics */
+exports.Metrics = {
+    assign: 0,
+    create: 0,
+    clone: 0,
+    discard: 0,
+    update: 0
+};

package/build/cjs/system/memory/update.js

@@ -0,0 +1,35 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Update = Update;
+const index_1 = require("../settings/index");
+const metrics_1 = require("./metrics");
+const clone_1 = require("./clone");
+/**
+ * Updates a value with new properties while preserving property enumerability. Use this function to modify
+ * existing types without altering their configuration.
+ */
+function Update(current, hidden, enumerable) {
+    metrics_1.Metrics.update += 1;
+    const settings = index_1.Settings.Get();
+    const result = (0, clone_1.Clone)(current);
+    // hidden
+    for (const key of Object.keys(hidden)) {
+        Object.defineProperty(result, key, {
+            configurable: true,
+            writable: true,
+            enumerable: settings.enumerableKind,
+            value: hidden[key]
+        });
+    }
+    // enumerable
+    for (const key of Object.keys(enumerable)) {
+        Object.defineProperty(result, key, {
+            configurable: true,
+            enumerable: true,
+            writable: true,
+            value: enumerable[key]
+        });
+    }
+    return result;
+}

package/build/cjs/system/settings/index.d.ts

@@ -0,0 +1 @@
+export * as Settings from './settings';

package/build/cjs/system/settings/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = void 0;
+exports.Settings = require("./settings");

package/build/cjs/system/settings/settings.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reset = Reset;
+exports.Set = Set;
+exports.Get = Get;
+const index_1 = require("../../guard/index");
+// Internal mutable state
+const settings = {
+    immutableTypes: false,
+    maxErrors: 8,
+    useEval: true,
+    exactOptionalPropertyTypes: false,
+    enumerableKind: false
+};
+/** Resets system settings to defaults */
+function Reset() {
+    settings.immutableTypes = false;
+    settings.maxErrors = 8;
+    settings.useEval = true;
+    settings.exactOptionalPropertyTypes = false;
+    settings.enumerableKind = false;
+}
+/** Sets system settings */
+function Set(options) {
+    for (const key of index_1.Guard.Keys(options)) {
+        const value = options[key];
+        if (value !== undefined) {
+            Object.defineProperty(settings, key, { value });
+        }
+    }
+}
+/** Gets current system settings */
+function Get() {
+    return settings;
+}

package/build/cjs/system/system.d.ts

@@ -0,0 +1,6 @@
+export * from './arguments/index';
+export * from './environment/index';
+export * from './hashing/index';
+export * from './locale/index';
+export * from './settings/index';
+export * from './memory/index';

package/build/cjs/system/system.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./arguments/index"), exports);
+__exportStar(require("./environment/index"), exports);
+__exportStar(require("./hashing/index"), exports);
+__exportStar(require("./locale/index"), exports);
+__exportStar(require("./settings/index"), exports);
+__exportStar(require("./memory/index"), exports);

package/build/cjs/system/unreachable/index.d.ts

@@ -0,0 +1 @@
+export * from './unreachable';

package/build/cjs/system/unreachable/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./unreachable"), exports);

package/build/cjs/system/unreachable/unreachable.js

@@ -0,0 +1,9 @@
+"use strict";
+// deno-coverage-ignore-start - unreachable by definition
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unreachable = Unreachable;
+/** Used for unreachable logic */
+function Unreachable() {
+    throw new Error('Unreachable');
+}
+// deno-coverage-ignore-stop

package/build/cjs/type/action/_optional.d.ts

@@ -0,0 +1,19 @@
+import { type TSchema } from '../types/schema';
+/** Represents a operation to apply Optional to a property */
+export interface TOptionalAddAction<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'OptionalAddAction';
+    type: Type;
+}
+/** Creates an OptionalAddAction. */
+export declare function OptionalAddAction<Type extends TSchema>(type: Type): TOptionalAddAction<Type>;
+/** Returns true if this value is a OptionalAddAction. */
+export declare function IsOptionalAddAction(value: unknown): value is TOptionalAddAction;
+/** Represents a operation to remove Optional from a property */
+export interface TOptionalRemoveAction<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'OptionalRemoveAction';
+    type: Type;
+}
+/** Creates a OptionalRemoveAction. */
+export declare function OptionalRemoveAction<Type extends TSchema>(type: Type): TOptionalRemoveAction<Type>;
+/** Returns true if this value is a OptionalRemoveAction. */
+export declare function IsOptionalRemoveAction(value: unknown): value is TOptionalRemoveAction;

package/build/cjs/type/action/_optional.js

@@ -0,0 +1,46 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalAddAction = OptionalAddAction;
+exports.IsOptionalAddAction = IsOptionalAddAction;
+exports.OptionalRemoveAction = OptionalRemoveAction;
+exports.IsOptionalRemoveAction = IsOptionalRemoveAction;
+const index_1 = require("../../system/memory/index");
+const index_2 = require("../../guard/index");
+const schema_1 = require("../types/schema");
+// ------------------------------------------------------------------
+// Action
+// ------------------------------------------------------------------
+/** Creates an OptionalAddAction. */
+function OptionalAddAction(type) {
+    return index_1.Memory.Create({ ['~kind']: 'OptionalAddAction' }, { type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if this value is a OptionalAddAction. */
+function IsOptionalAddAction(value) {
+    return index_2.Guard.IsObject(value)
+        && index_2.Guard.HasPropertyKey(value, '~kind')
+        && index_2.Guard.HasPropertyKey(value, 'type')
+        && index_2.Guard.IsEqual(value['~kind'], 'OptionalAddAction')
+        && (0, schema_1.IsSchema)(value.type);
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a OptionalRemoveAction. */
+function OptionalRemoveAction(type) {
+    return index_1.Memory.Create({ ['~kind']: 'OptionalRemoveAction' }, { type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if this value is a OptionalRemoveAction. */
+function IsOptionalRemoveAction(value) {
+    return index_2.Guard.IsObject(value)
+        && index_2.Guard.HasPropertyKey(value, '~kind')
+        && index_2.Guard.HasPropertyKey(value, 'type')
+        && index_2.Guard.IsEqual(value['~kind'], 'OptionalRemoveAction')
+        && (0, schema_1.IsSchema)(value.type);
+}

package/build/cjs/type/action/_readonly.d.ts

@@ -0,0 +1,19 @@
+import { type TSchema } from '../types/schema';
+/** Represents an operation to apply Readonly to a property. */
+export interface TReadonlyAddAction<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'ReadonlyAddAction';
+    type: Type;
+}
+/** Creates a ReadonlyAddAction. */
+export declare function ReadonlyAddAction<Type extends TSchema>(type: Type): TReadonlyAddAction<Type>;
+/** Returns true if this value is a ReadonlyAddAction. */
+export declare function IsReadonlyAddAction(value: unknown): value is TReadonlyAddAction;
+/** Represents an action to remove Readonly from a property. */
+export interface TReadonlyRemoveAction<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'ReadonlyRemoveAction';
+    type: Type;
+}
+/** Creates a ReadonlyRemoveAction. */
+export declare function ReadonlyRemoveAction<Type extends TSchema>(type: Type): TReadonlyRemoveAction<Type>;
+/** Returns true if this value is a ReadonlyRemoveAction. */
+export declare function IsReadonlyRemoveAction(value: unknown): value is TReadonlyRemoveAction;

package/build/cjs/type/action/_readonly.js

@@ -0,0 +1,46 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyAddAction = ReadonlyAddAction;
+exports.IsReadonlyAddAction = IsReadonlyAddAction;
+exports.ReadonlyRemoveAction = ReadonlyRemoveAction;
+exports.IsReadonlyRemoveAction = IsReadonlyRemoveAction;
+const index_1 = require("../../system/memory/index");
+const index_2 = require("../../guard/index");
+const schema_1 = require("../types/schema");
+// ------------------------------------------------------------------
+// Action
+// ------------------------------------------------------------------
+/** Creates a ReadonlyAddAction. */
+function ReadonlyAddAction(type) {
+    return index_1.Memory.Create({ ['~kind']: 'ReadonlyAddAction' }, { type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if this value is a ReadonlyAddAction. */
+function IsReadonlyAddAction(value) {
+    return index_2.Guard.IsObject(value)
+        && index_2.Guard.HasPropertyKey(value, '~kind')
+        && index_2.Guard.HasPropertyKey(value, 'type')
+        && index_2.Guard.IsEqual(value['~kind'], 'ReadonlyAddAction')
+        && (0, schema_1.IsSchema)(value.type);
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a ReadonlyRemoveAction. */
+function ReadonlyRemoveAction(type) {
+    return index_1.Memory.Create({ ['~kind']: 'ReadonlyRemoveAction' }, { type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if this value is a ReadonlyRemoveAction. */
+function IsReadonlyRemoveAction(value) {
+    return index_2.Guard.IsObject(value)
+        && index_2.Guard.HasPropertyKey(value, '~kind')
+        && index_2.Guard.HasPropertyKey(value, 'type')
+        && index_2.Guard.IsEqual(value['~kind'], 'ReadonlyRemoveAction')
+        && (0, schema_1.IsSchema)(value.type);
+}

package/build/cjs/type/action/awaited.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Awaited action. */
+export type TAwaitedDeferred<Type extends TSchema> = (TDeferred<'Awaited', [Type]>);
+/** Creates a deferred Awaited action. */
+export declare function AwaitedDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAwaitedDeferred<Type>;
+/** Applies an Awaited action to a type. */
+export type TAwaited<Type extends TSchema> = (TInstantiate<{}, TAwaitedDeferred<Type>>);
+/** Applies an Awaited action to a type. */
+export declare function Awaited<Type extends TSchema>(type: Type, options?: TSchemaOptions): TAwaited<Type>;

package/build/cjs/type/action/awaited.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwaitedDeferred = AwaitedDeferred;
+exports.Awaited = Awaited;
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Awaited action. */
+function AwaitedDeferred(type, options = {}) {
+    return (0, deferred_1.Deferred)('Awaited', [type], options);
+}
+/** Applies an Awaited action to a type. */
+function Awaited(type, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, AwaitedDeferred(type, options));
+}

package/build/cjs/type/action/capitalize.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Capitalize action. */
+export type TCapitalizeDeferred<Type extends TSchema> = (TDeferred<'Capitalize', [Type]>);
+/** Creates a deferred Capitalize action. */
+export declare function CapitalizeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TCapitalizeDeferred<Type>;
+/** Applies a Capitalize action to the given type. */
+export type TCapitalize<Type extends TSchema> = (TInstantiate<{}, TCapitalizeDeferred<Type>>);
+/** Applies a Capitalize action to the given type. */
+export declare function Capitalize<Type extends TSchema>(type: Type, options?: TSchemaOptions): TCapitalize<Type>;

package/build/cjs/type/action/capitalize.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapitalizeDeferred = CapitalizeDeferred;
+exports.Capitalize = Capitalize;
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Capitalize action. */
+function CapitalizeDeferred(type, options = {}) {
+    return (0, deferred_1.Deferred)('Capitalize', [type], options);
+}
+/** Applies a Capitalize action to the given type. */
+function Capitalize(type, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, CapitalizeDeferred(type, options));
+}

package/build/cjs/type/action/conditional.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Conditional action. */
+export type TConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TDeferred<'Conditional', [Left, Right, True, False]>);
+/** Creates a deferred Conditional action. */
+export declare function ConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditionalDeferred<Left, Right, True, False>;
+/** Applies a Conditional action to the given types. */
+export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TInstantiate<{}, TConditionalDeferred<Left, Right, True, False>>);
+/** Applies a Conditional action to the given types. */
+export declare function Conditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditional<Left, Right, True, False>;

package/build/cjs/type/action/conditional.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalDeferred = ConditionalDeferred;
+exports.Conditional = Conditional;
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Conditional action. */
+function ConditionalDeferred(left, right, true_, false_, options = {}) {
+    return (0, deferred_1.Deferred)('Conditional', [left, right, true_, false_], options);
+}
+/** Applies a Conditional action to the given types. */
+function Conditional(left, right, true_, false_, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, ConditionalDeferred(left, right, true_, false_, options));
+}

package/build/cjs/type/action/constructor-parameters.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred ConstructorParameters action. */
+export type TConstructorParametersDeferred<Type extends TSchema> = (TDeferred<'ConstructorParameters', [Type]>);
+/** Creates a deferred ConstructorParameters action. */
+export declare function ConstructorParametersDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TConstructorParametersDeferred<Type>;
+/** Applies a ConstructorParameters action to a type. */
+export type TConstructorParameters<Type extends TSchema> = (TInstantiate<{}, TConstructorParametersDeferred<Type>>);
+/** Applies a ConstructorParameters action to a type. */
+export declare function ConstructorParameters<Type extends TSchema>(type: Type, options?: TSchemaOptions): TConstructorParameters<Type>;

package/build/cjs/type/action/constructor-parameters.js

@@ -0,0 +1,15 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstructorParametersDeferred = ConstructorParametersDeferred;
+exports.ConstructorParameters = ConstructorParameters;
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred ConstructorParameters action. */
+function ConstructorParametersDeferred(type, options = {}) {
+    return (0, deferred_1.Deferred)('ConstructorParameters', [type], options);
+}
+/** Applies a ConstructorParameters action to a type. */
+function ConstructorParameters(type, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, ConstructorParametersDeferred(type, options));
+}

package/build/cjs/type/action/evaluate.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Evaluate action. */
+export type TEvaluateDeferred<Type extends TSchema> = (TDeferred<'Evaluate', [Type]>);
+/** Creates a deferred Evaluate action. */
+export declare function EvaluateDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TEvaluateDeferred<Type>;
+/** Applies an Evaluate action to a type. */
+export type TEvaluate<Type extends TSchema> = (TInstantiate<{}, TEvaluateDeferred<Type>>);
+/** Applies an Evaluate action to a type. */
+export declare function Evaluate<Type extends TSchema>(type: Type, options?: TSchemaOptions): TEvaluate<Type>;