typebox 1.0.31 → 1.0.33

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

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

package/build/cjs/type/action/exclude.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 Exclude action. */
+export type TExcludeDeferred<Left extends TSchema, Right extends TSchema> = (TDeferred<'Exclude', [Left, Right]>);
+/** Creates a deferred Exclude action. */
+export declare function ExcludeDeferred<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExcludeDeferred<Left, Right>;
+/** Applies a Exclude action using the given types */
+export type TExclude<Left extends TSchema, Right extends TSchema> = (TInstantiate<{}, TExcludeDeferred<Left, Right>>);
+/** Applies a Exclude action using the given types */
+export declare function Exclude<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExclude<Left, Right>;

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

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

package/build/cjs/type/action/extract.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 Extract action. */
+export type TExtractDeferred<Left extends TSchema, Right extends TSchema> = (TDeferred<'Extract', [Left, Right]>);
+/** Creates a deferred Extract action. */
+export declare function ExtractDeferred<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExtractDeferred<Left, Right>;
+/** Applies an Extract action using the given types. */
+export type TExtract<Left extends TSchema, Right extends TSchema> = (TInstantiate<{}, TExtractDeferred<Left, Right>>);
+/** Applies an Extract action using the given types. */
+export declare function Extract<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExtract<Left, Right>;

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

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

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

@@ -0,0 +1,26 @@
+export * from './_optional';
+export * from './_readonly';
+export * from './awaited';
+export * from './capitalize';
+export * from './conditional';
+export * from './constructor-parameters';
+export * from './evaluate';
+export * from './exclude';
+export * from './extract';
+export * from './indexed';
+export * from './instance-type';
+export * from './interface';
+export * from './keyof';
+export * from './lowercase';
+export * from './mapped';
+export * from './module';
+export * from './non-nullable';
+export * from './omit';
+export * from './options';
+export * from './parameters';
+export * from './partial';
+export * from './pick';
+export * from './required';
+export * from './return-type';
+export * from './uncapitalize';
+export * from './uppercase';

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

@@ -0,0 +1,42 @@
+"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("./_optional"), exports);
+__exportStar(require("./_readonly"), exports);
+__exportStar(require("./awaited"), exports);
+__exportStar(require("./capitalize"), exports);
+__exportStar(require("./conditional"), exports);
+__exportStar(require("./constructor-parameters"), exports);
+__exportStar(require("./evaluate"), exports);
+__exportStar(require("./exclude"), exports);
+__exportStar(require("./extract"), exports);
+__exportStar(require("./indexed"), exports);
+__exportStar(require("./instance-type"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./keyof"), exports);
+__exportStar(require("./lowercase"), exports);
+__exportStar(require("./mapped"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./non-nullable"), exports);
+__exportStar(require("./omit"), exports);
+__exportStar(require("./options"), exports);
+__exportStar(require("./parameters"), exports);
+__exportStar(require("./partial"), exports);
+__exportStar(require("./pick"), exports);
+__exportStar(require("./required"), exports);
+__exportStar(require("./return-type"), exports);
+__exportStar(require("./uncapitalize"), exports);
+__exportStar(require("./uppercase"), exports);

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Index action. */
+export type TIndexDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Index', [Type, Indexer]>);
+/** Creates a deferred Index action. */
+export declare function IndexDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndexDeferred<Type, Indexer>;
+/** Applies a Index action using the given types. */
+export type TIndex<Type extends TSchema, Indexer extends TSchema> = (TInstantiate<{}, TIndexDeferred<Type, Indexer>>);
+/** Applies a Index action using the given types. */
+export declare function Index<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: [...Indexer], options?: TSchemaOptions): TIndex<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Index action using the given types. */
+export declare function Index<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndex<Type, Indexer>;

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

@@ -0,0 +1,18 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexDeferred = IndexDeferred;
+exports.Index = Index;
+const index_1 = require("../../guard/index");
+const deferred_1 = require("../types/deferred");
+const keys_to_indexer_1 = require("../engine/helpers/keys-to-indexer");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Index action. */
+function IndexDeferred(type, indexer, options = {}) {
+    return (0, deferred_1.Deferred)('Index', [type, indexer], options);
+}
+/** Applies a Index action using the given types. */
+function Index(type, indexer_or_keys, options = {}) {
+    const indexer = index_1.Guard.IsArray(indexer_or_keys) ? (0, keys_to_indexer_1.KeysToIndexer)(indexer_or_keys) : indexer_or_keys;
+    return (0, instantiate_1.Instantiate)({}, IndexDeferred(type, indexer, options));
+}

package/build/cjs/type/action/instance-type.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 InstanceType action. */
+export type TInstanceTypeDeferred<Type extends TSchema> = (TDeferred<'InstanceType', [Type]>);
+/** Creates a deferred InstanceType action. */
+export declare function InstanceTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TInstanceTypeDeferred<Type>;
+/** Applies a InstanceType action to the given type. */
+export type TInstanceType<Type extends TSchema> = (TInstantiate<{}, TInstanceTypeDeferred<Type>>);
+/** Applies a InstanceType action to the given type. */
+export declare function InstanceType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TInstanceType<Type>;

package/build/cjs/type/action/instance-type.js

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Interface action. */
+export type TInterfaceDeferred<Heritage extends TSchema[] = TSchema[], Properties extends TProperties = TProperties> = (TDeferred<'Interface', [Heritage, Properties]>);
+/** Creates a deferred Interface action. */
+export declare function InterfaceDeferred<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options?: TSchemaOptions): TInterfaceDeferred<Heritage, Properties>;
+/** Returns true if this value is a deferred Interface action. */
+export declare function IsInterfaceDeferred(value: unknown): value is TInterfaceDeferred;
+/** Creates an Interface using the given heritage and properties. */
+export type TInterface<Heritage extends TSchema[], Properties extends TProperties> = (TInstantiate<{}, TInterfaceDeferred<Heritage, Properties>>);
+/** Creates an Interface using the given heritage and properties. */
+export declare function Interface<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options?: TSchemaOptions): TInterface<Heritage, Properties>;

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

@@ -0,0 +1,24 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceDeferred = InterfaceDeferred;
+exports.IsInterfaceDeferred = IsInterfaceDeferred;
+exports.Interface = Interface;
+const index_1 = require("../../guard/index");
+const schema_1 = require("../types/schema");
+const deferred_1 = require("../types/deferred");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Interface action. */
+function InterfaceDeferred(heritage, properties, options = {}) {
+    return (0, deferred_1.Deferred)('Interface', [heritage, properties], options);
+}
+/** Returns true if this value is a deferred Interface action. */
+function IsInterfaceDeferred(value) {
+    return (0, schema_1.IsSchema)(value)
+        && index_1.Guard.HasPropertyKey(value, 'action')
+        && index_1.Guard.IsEqual(value.action, 'Interface');
+}
+/** Creates an Interface using the given heritage and properties. */
+function Interface(heritage, properties, options = {}) {
+    return (0, instantiate_1.Instantiate)({}, InterfaceDeferred(heritage, properties, options));
+}

package/build/cjs/type/action/keyof.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 KeyOf action. */
+export type TKeyOfDeferred<Type extends TSchema> = (TDeferred<'KeyOf', [Type]>);
+/** Creates a deferred KeyOf action. */
+export declare function KeyOfDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOfDeferred<Type>;
+/** Applies a KeyOf action to the given type. */
+export type TKeyOf<Type extends TSchema> = (TInstantiate<{}, TKeyOfDeferred<Type>>);
+/** Applies a KeyOf action to the given type. */
+export declare function KeyOf<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOf<Type>;

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

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

package/build/cjs/type/action/lowercase.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 Lowercase action. */
+export type TLowercaseDeferred<Type extends TSchema> = (TDeferred<'Lowercase', [Type]>);
+/** Creates a deferred Lowercase action. */
+export declare function LowercaseDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TLowercaseDeferred<Type>;
+/** Applies a Lowercase action to the given type. */
+export type TLowercase<Type extends TSchema> = (TInstantiate<{}, TLowercaseDeferred<Type>>);
+/** Applies a Lowercase action to the given type. */
+export declare function Lowercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TLowercase<Type>;

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

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

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TIdentifier } from '../types/identifier';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Mapped action. */
+export type TMappedDeferred<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Key, As, Property]>);
+/** Creates a deferred Mapped action. */
+export declare function MappedDeferred<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, key: Key, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Key, As, Property>;
+/** Applies a Mapped action using the given types. */
+export type TMapped<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema> = (TInstantiate<{}, TMappedDeferred<Identifier, Key, As, Property>>);
+/** Applies a Mapped action using the given types. */
+export declare function Mapped<Identifier extends TIdentifier, Key extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, key: Key, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Key, As, Property>;

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

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

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

@@ -0,0 +1,12 @@
+import { type TSchemaOptions } from '../types/schema';
+import { type TProperties } from '../types/properties';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Module action. */
+export type TModuleDeferred<Context extends TProperties> = (TDeferred<'Module', [Context]>);
+/** Creates a deferred Module action. */
+export declare function ModuleDeferred<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModuleDeferred<Context>;
+/** Applies a Module transformation action to the embedded property types. */
+export type TModule<Context extends TProperties> = (TInstantiate<{}, TModuleDeferred<Context>>);
+/** Applies a Module transformation action to the embedded property types. */
+export declare function Module<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModule<Context>;

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

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

package/build/cjs/type/action/non-nullable.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 NonNullable action. */
+export type TNonNullableDeferred<Type extends TSchema> = (TDeferred<'NonNullable', [Type]>);
+/** Creates a deferred NonNullable action. */
+export declare function NonNullableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TNonNullableDeferred<Type>;
+/** Applies a NonNullable action to the given type. */
+export type TNonNullable<Type extends TSchema> = (TInstantiate<{}, TNonNullableDeferred<Type>>);
+/** Applies a NonNullable action to the given type. */
+export declare function NonNullable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TNonNullable<Type>;

package/build/cjs/type/action/non-nullable.js

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Omit action. */
+export type TOmitDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Omit', [Type, Indexer]>);
+/** Creates a deferred Omit action. */
+export declare function OmitDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmitDeferred<Type, Indexer>;
+/** Applies a Omit action using the given types. */
+export type TOmit<Type extends TSchema, Indexer extends TSchema> = (TInstantiate<{}, TOmitDeferred<Type, Indexer>>);
+/** Applies a Omit action using the given types. */
+export declare function Omit<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: [...Indexer], options?: TSchemaOptions): TOmit<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Omit action using the given types. */
+export declare function Omit<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmit<Type, Indexer>;

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

@@ -0,0 +1,18 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitDeferred = OmitDeferred;
+exports.Omit = Omit;
+const index_1 = require("../../guard/index");
+const deferred_1 = require("../types/deferred");
+const keys_to_indexer_1 = require("../engine/helpers/keys-to-indexer");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Omit action. */
+function OmitDeferred(type, indexer, options = {}) {
+    return (0, deferred_1.Deferred)('Omit', [type, indexer], options);
+}
+/** Applies a Omit action using the given types. */
+function Omit(type, indexer_or_keys, options = {}) {
+    const indexer = index_1.Guard.IsArray(indexer_or_keys) ? (0, keys_to_indexer_1.KeysToIndexer)(indexer_or_keys) : indexer_or_keys;
+    return (0, instantiate_1.Instantiate)({}, OmitDeferred(type, indexer, options));
+}

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

@@ -0,0 +1,12 @@
+import { type TSchema } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Options action. */
+export type TOptionsDeferred<Type extends TSchema, Options extends TSchema> = (TDeferred<'Options', [Type, Options]>);
+/** Creates a deferred Options action. */
+export declare function OptionsDeferred<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TOptionsDeferred<Type, Options>;
+export type TOptionsConstruct<Type extends TSchema, Options extends TSchema> = (TInstantiate<{}, TOptionsDeferred<Type, Options>>);
+/** Applies an Options action to the given type. */
+export type TOptions<Type extends TSchema, Options extends TSchema> = (Type & Options);
+/** Applies an Options action to the given type. */
+export declare function Options<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TOptionsConstruct<Type, Options>;

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

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

package/build/cjs/type/action/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 Parameters action. */
+export type TParametersDeferred<Type extends TSchema> = (TDeferred<'Parameters', [Type]>);
+/** Creates a deferred Parameters action. */
+export declare function ParametersDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TParametersDeferred<Type>;
+/** Applies a Parameters action to the given type. */
+export type TParameters<Type extends TSchema> = (TInstantiate<{}, TParametersDeferred<Type>>);
+/** Applies a Parameters action to the given type. */
+export declare function Parameters<Type extends TSchema>(type: Type, options?: TSchemaOptions): TParameters<Type>;

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

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

package/build/cjs/type/action/partial.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 Partial action. */
+export type TPartialDeferred<Type extends TSchema> = (TDeferred<'Partial', [Type]>);
+/** Creates a deferred Partial action. */
+export declare function PartialDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"Partial", [Type]>;
+/** Applies a Partial action to the given type. */
+export type TPartial<Type extends TSchema> = (TInstantiate<{}, TPartialDeferred<Type>>);
+/** Applies a Partial action to the given type. */
+export declare function Partial<Type extends TSchema>(type: Type, options?: TSchemaOptions): TPartial<Type>;

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

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

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

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema';
+import { type TDeferred } from '../types/deferred';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer';
+import { type TInstantiate } from '../engine/instantiate';
+/** Creates a deferred Pick action. */
+export type TPickDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Pick', [Type, Indexer]>);
+/** Creates a deferred Pick action. */
+export declare function PickDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPickDeferred<Type, Indexer>;
+/** Applies a Pick action using the given types. */
+export type TPick<Type extends TSchema, Indexer extends TSchema> = (TInstantiate<{}, TPickDeferred<Type, Indexer>>);
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: [...Indexer], options?: TSchemaOptions): TPick<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPick<Type, Indexer>;

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

@@ -0,0 +1,18 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickDeferred = PickDeferred;
+exports.Pick = Pick;
+const index_1 = require("../../guard/index");
+const deferred_1 = require("../types/deferred");
+const keys_to_indexer_1 = require("../engine/helpers/keys-to-indexer");
+const instantiate_1 = require("../engine/instantiate");
+/** Creates a deferred Pick action. */
+function PickDeferred(type, indexer, options = {}) {
+    return (0, deferred_1.Deferred)('Pick', [type, indexer], options);
+}
+/** Applies a Pick action using the given types. */
+function Pick(type, indexer_or_keys, options = {}) {
+    const indexer = index_1.Guard.IsArray(indexer_or_keys) ? (0, keys_to_indexer_1.KeysToIndexer)(indexer_or_keys) : indexer_or_keys;
+    return (0, instantiate_1.Instantiate)({}, PickDeferred(type, indexer, options));
+}

package/build/cjs/type/action/required.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 Required action. */
+export type TRequiredDeferred<Type extends TSchema> = (TDeferred<'Required', [Type]>);
+/** Creates a deferred Required action. */
+export declare function RequiredDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"Required", [Type]>;
+/** Applies a Required action to the given type. */
+export type TRequired<Type extends TSchema> = (TInstantiate<{}, TRequiredDeferred<Type>>);
+/** Applies a Required action to the given type. */
+export declare function Required<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRequired<Type>;

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

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

package/build/cjs/type/action/return-type.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 ReturnType action. */
+export type TReturnTypeDeferred<Type extends TSchema> = (TDeferred<'ReturnType', [Type]>);
+/** Creates a deferred ReturnType action. */
+export declare function ReturnTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnTypeDeferred<Type>;
+/** Applies a ReturnType action to the given type. */
+export type TReturnType<Type extends TSchema> = (TInstantiate<{}, TReturnTypeDeferred<Type>>);
+/** Applies a ReturnType action to the given type. */
+export declare function ReturnType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnType<Type>;