typebox 0.0.1 → 1.0.0-rc

package/build/type/action/_readonly.mjs

@@ -0,0 +1,40 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../system/memory/index.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from '../types/schema.mjs';
+// ------------------------------------------------------------------
+// Action
+// ------------------------------------------------------------------
+/** Creates a ReadonlyAddAction. */
+export function ReadonlyAddAction(type) {
+    return Memory.Create({ ['~kind']: 'ReadonlyAddAction' }, { type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if this value is a ReadonlyAddAction. */
+export function IsReadonlyAddAction(value) {
+    return Guard.IsObject(value)
+        && Guard.HasPropertyKey(value, '~kind')
+        && Guard.HasPropertyKey(value, 'type')
+        && Guard.IsEqual(value['~kind'], 'ReadonlyAddAction')
+        && IsSchema(value.type);
+}
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a ReadonlyRemoveAction. */
+export function ReadonlyRemoveAction(type) {
+    return Memory.Create({ ['~kind']: 'ReadonlyRemoveAction' }, { type }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if this value is a ReadonlyRemoveAction. */
+export function IsReadonlyRemoveAction(value) {
+    return Guard.IsObject(value)
+        && Guard.HasPropertyKey(value, '~kind')
+        && Guard.HasPropertyKey(value, 'type')
+        && Guard.IsEqual(value['~kind'], 'ReadonlyRemoveAction')
+        && IsSchema(value.type);
+}

package/build/type/action/awaited.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/awaited.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Awaited action. */
+export function AwaitedDeferred(type, options = {}) {
+    return Deferred('Awaited', [type], options);
+}
+/** Applies an Awaited action to a type. */
+export function Awaited(type, options = {}) {
+    return Instantiate({}, AwaitedDeferred(type, options));
+}

package/build/type/action/capitalize.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/capitalize.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Capitalize action. */
+export function CapitalizeDeferred(type, options = {}) {
+    return Deferred('Capitalize', [type], options);
+}
+/** Applies a Capitalize action to the given type. */
+export function Capitalize(type, options = {}) {
+    return Instantiate({}, CapitalizeDeferred(type, options));
+}

package/build/type/action/conditional.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/conditional.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Conditional action. */
+export function ConditionalDeferred(left, right, true_, false_, options = {}) {
+    return Deferred('Conditional', [left, right, true_, false_], options);
+}
+/** Applies a Conditional action to the given types. */
+export function Conditional(left, right, true_, false_, options = {}) {
+    return Instantiate({}, ConditionalDeferred(left, right, true_, false_, options));
+}

package/build/type/action/constructor-parameters.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/constructor-parameters.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ConstructorParameters action. */
+export function ConstructorParametersDeferred(type, options = {}) {
+    return Deferred('ConstructorParameters', [type], options);
+}
+/** Applies a ConstructorParameters action to a type. */
+export function ConstructorParameters(type, options = {}) {
+    return Instantiate({}, ConstructorParametersDeferred(type, options));
+}

package/build/type/action/evaluate.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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>;

package/build/type/action/evaluate.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Evaluate action. */
+export function EvaluateDeferred(type, options = {}) {
+    return Deferred('Evaluate', [type], options);
+}
+/** Applies an Evaluate action to a type. */
+export function Evaluate(type, options = {}) {
+    return Instantiate({}, EvaluateDeferred(type, options));
+}

package/build/type/action/exclude.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/exclude.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Exclude action. */
+export function ExcludeDeferred(left, right, options = {}) {
+    return Deferred('Exclude', [left, right], options);
+}
+/** Applies a Exclude action using the given types */
+export function Exclude(left, right, options = {}) {
+    return Instantiate({}, ExcludeDeferred(left, right, options));
+}

package/build/type/action/extract.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/extract.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Extract action. */
+export function ExtractDeferred(left, right, options = {}) {
+    return Deferred('Extract', [left, right], options);
+}
+/** Applies an Extract action using the given types. */
+export function Extract(left, right, options = {}) {
+    return Instantiate({}, ExtractDeferred(left, right, options));
+}

package/build/type/action/index.d.mts

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

package/build/type/action/index.mjs

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

package/build/type/action/indexed.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/indexed.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { KeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Index action. */
+export function IndexDeferred(type, indexer, options = {}) {
+    return Deferred('Index', [type, indexer], options);
+}
+/** Applies a Index action using the given types. */
+export function Index(type, indexer_or_keys, options = {}) {
+    const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
+    return Instantiate({}, IndexDeferred(type, indexer, options));
+}

package/build/type/action/instance-type.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/instance-type.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred InstanceType action. */
+export function InstanceTypeDeferred(type, options = {}) {
+    return Deferred('InstanceType', [type], options);
+}
+/** Applies a InstanceType action to the given type. */
+export function InstanceType(type, options = {}) {
+    return Instantiate({}, InstanceTypeDeferred(type, options));
+}

package/build/type/action/interface.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/interface.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from '../types/schema.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Interface action. */
+export function InterfaceDeferred(heritage, properties, options = {}) {
+    return Deferred('Interface', [heritage, properties], options);
+}
+/** Returns true if this value is a deferred Interface action. */
+export function IsInterfaceDeferred(value) {
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, 'action')
+        && Guard.IsEqual(value.action, 'Interface');
+}
+/** Creates an Interface using the given heritage and properties. */
+export function Interface(heritage, properties, options = {}) {
+    return Instantiate({}, InterfaceDeferred(heritage, properties, options));
+}

package/build/type/action/keyof.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/keyof.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred KeyOf action. */
+export function KeyOfDeferred(type, options = {}) {
+    return Deferred('KeyOf', [type], options);
+}
+/** Applies a KeyOf action to the given type. */
+export function KeyOf(type, options = {}) {
+    return Instantiate({}, KeyOfDeferred(type, options));
+}

package/build/type/action/lowercase.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/lowercase.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Lowercase action. */
+export function LowercaseDeferred(type, options = {}) {
+    return Deferred('Lowercase', [type], options);
+}
+/** Applies a Lowercase action to the given type. */
+export function Lowercase(type, options = {}) {
+    return Instantiate({}, LowercaseDeferred(type, options));
+}

package/build/type/action/mapped.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TIdentifier } from '../types/identifier.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/mapped.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Mapped action. */
+export function MappedDeferred(identifier, key, as, property, options = {}) {
+    return Deferred('Mapped', [identifier, key, as, property], options);
+}
+/** Applies a Mapped action using the given types. */
+export function Mapped(identifier, key, as, property, options = {}) {
+    return Instantiate({}, MappedDeferred(identifier, key, as, property, options));
+}

package/build/type/action/module.d.mts

@@ -0,0 +1,12 @@
+import { type TSchemaOptions } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/module.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Module action. */
+export function ModuleDeferred(context, options = {}) {
+    return Deferred('Module', [context], options);
+}
+/** Applies a Module transformation action to the embedded property types. */
+export function Module(context, options = {}) {
+    return Instantiate({}, ModuleDeferred(context, options));
+}

package/build/type/action/non-nullable.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/non-nullable.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred NonNullable action. */
+export function NonNullableDeferred(type, options = {}) {
+    return Deferred('NonNullable', [type], options);
+}
+/** Applies a NonNullable action to the given type. */
+export function NonNullable(type, options = {}) {
+    return Instantiate({}, NonNullableDeferred(type, options));
+}

package/build/type/action/omit.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/omit.mjs

@@ -0,0 +1,14 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { KeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Omit action. */
+export function OmitDeferred(type, indexer, options = {}) {
+    return Deferred('Omit', [type, indexer], options);
+}
+/** Applies a Omit action using the given types. */
+export function Omit(type, indexer_or_keys, options = {}) {
+    const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
+    return Instantiate({}, OmitDeferred(type, indexer, options));
+}

package/build/type/action/options.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/options.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Options action. */
+export function OptionsDeferred(type, options) {
+    return Deferred('Options', [type, options], {});
+}
+/** Applies an Options action to the given type. */
+export function Options(type, options) {
+    return Instantiate({}, OptionsDeferred(type, options));
+}

package/build/type/action/parameters.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/parameters.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Parameters action. */
+export function ParametersDeferred(type, options = {}) {
+    return Deferred('Parameters', [type], options);
+}
+/** Applies a Parameters action to the given type. */
+export function Parameters(type, options = {}) {
+    return Instantiate({}, ParametersDeferred(type, options));
+}

package/build/type/action/partial.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** 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/type/action/partial.mjs

@@ -0,0 +1,11 @@
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Partial action. */
+export function PartialDeferred(type, options = {}) {
+    return Deferred('Partial', [type], options);
+}
+/** Applies a Partial action to the given type. */
+export function Partial(type, options = {}) {
+    return Instantiate({}, PartialDeferred(type, options));
+}