typebox 1.0.31 → 1.0.33

package/build/cjs/type/types/tuple.d.ts

@@ -0,0 +1,37 @@
+import { type StaticType, type StaticDirection } from './static';
+import { type TSchema, type TTupleOptions } from './schema';
+import { type TArray } from './array';
+import { type TOptional } from './_optional';
+import { type TProperties } from './properties';
+import { type TReadonly } from './_readonly';
+import { type TRest } from './rest';
+type StaticLast<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result extends unknown[]> = (Type extends TRest<infer RestType extends TSchema> ? RestType extends TArray<infer ArrayType extends TSchema> ? [...Result, ...TStaticElement<Stack, Direction, Context, This, ArrayType>[0][]] : [...Result, never] : [...Result, ...TStaticElement<Stack, Direction, Context, This, Type>]);
+type TStaticElement<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, IsReadonly extends boolean = Type extends TReadonly ? true : false, IsOptional extends boolean = Type extends TOptional ? true : false, Inferred extends unknown = StaticType<Stack, Direction, Context, This, Type>, Result extends [unknown?] = ([
+    IsReadonly,
+    IsOptional
+] extends [true, true] ? [Readonly<Inferred>?] : [
+    IsReadonly,
+    IsOptional
+] extends [false, true] ? [Inferred?] : [
+    IsReadonly,
+    IsOptional
+] extends [true, false] ? [Readonly<Inferred>] : [
+    Inferred
+])> = Result;
+export type TStaticElements<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown[] = []> = (Types extends [infer Last extends TSchema] ? StaticLast<Stack, Direction, Context, This, Last, Result> : Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TStaticElements<Stack, Direction, Context, This, Right, [...Result, ...TStaticElement<Stack, Direction, Context, This, Left>]> : Result);
+export type StaticTuple<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Elements extends unknown[] = TStaticElements<Stack, Direction, Context, This, Types>, Result extends unknown[] = Elements> = Result;
+/** Represents a Tuple type. */
+export interface TTuple<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Tuple';
+    type: 'array';
+    additionalItems: false;
+    items: Types;
+    minItems: Types['length'];
+}
+/** Creates a Tuple type. */
+export declare function Tuple<Types extends TSchema[]>(types: [...Types], options?: TTupleOptions): TTuple<Types>;
+/** Returns true if the given value is TTuple. */
+export declare function IsTuple(value: unknown): value is TTuple;
+/** Extracts options from a TTuple. */
+export declare function TupleOptions(type: TTuple): TTupleOptions;
+export {};

package/build/cjs/type/types/tuple.js

@@ -0,0 +1,30 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tuple = Tuple;
+exports.IsTuple = IsTuple;
+exports.TupleOptions = TupleOptions;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Tuple type. */
+function Tuple(types, options = {}) {
+    const [items, minItems, additionalItems] = [types, types.length, false];
+    return index_1.Memory.Create({ ['~kind']: 'Tuple' }, { type: 'array', additionalItems, items, minItems }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TTuple. */
+function IsTuple(value) {
+    return (0, schema_1.IsKind)(value, 'Tuple');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TTuple. */
+function TupleOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'type', 'items', 'minItems', 'additionalItems']);
+}

package/build/cjs/type/types/undefined.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+export type StaticUndefined = undefined;
+/** Represents a Undefined type. */
+export interface TUndefined extends TSchema {
+    '~kind': 'Undefined';
+    type: 'undefined';
+}
+/** Creates a Undefined type. */
+export declare function Undefined(options?: TSchemaOptions): TUndefined;
+/** Returns true if the given value is TUndefined. */
+export declare function IsUndefined(value: unknown): value is TUndefined;

package/build/cjs/type/types/undefined.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Undefined = Undefined;
+exports.IsUndefined = IsUndefined;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Undefined type. */
+function Undefined(options) {
+    return index_1.Memory.Create({ '~kind': 'Undefined' }, { type: 'undefined' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TUndefined. */
+function IsUndefined(value) {
+    return (0, schema_1.IsKind)(value, 'Undefined');
+}

package/build/cjs/type/types/union.d.ts

@@ -0,0 +1,15 @@
+import { type StaticType, type StaticDirection } from './static';
+import { type TSchema, type TSchemaOptions } from './schema';
+import { type TProperties } from './properties';
+export type StaticUnion<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = never> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticUnion<Stack, Direction, Context, This, Right, Result | StaticType<Stack, Direction, Context, This, Left>> : Result);
+/** Represents a logical Union type. */
+export interface TUnion<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Union';
+    anyOf: Types;
+}
+/** Creates a Union type. */
+export declare function Union<Types extends TSchema[]>(anyOf: [...Types], options?: TSchemaOptions): TUnion<Types>;
+/** Returns true if the given value is TUnion. */
+export declare function IsUnion(value: unknown): value is TUnion;
+/** Extracts options from a TUnion. */
+export declare function UnionOptions(type: TUnion): TSchemaOptions;

package/build/cjs/type/types/union.js

@@ -0,0 +1,29 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Union = Union;
+exports.IsUnion = IsUnion;
+exports.UnionOptions = UnionOptions;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Union type. */
+function Union(anyOf, options = {}) {
+    return index_1.Memory.Create({ '~kind': 'Union' }, { anyOf }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TUnion. */
+function IsUnion(value) {
+    return (0, schema_1.IsKind)(value, 'Union');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TUnion. */
+function UnionOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'anyOf']);
+}

package/build/cjs/type/types/unknown.d.ts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+export type StaticUnknown = unknown;
+/** Represents an Unknown type. */
+export interface TUnknown extends TSchema {
+    '~kind': 'Unknown';
+}
+/** Creates an Unknown type. */
+export declare function Unknown(options?: TSchemaOptions): TUnknown;
+/** Returns true if the given value is TUnknown. */
+export declare function IsUnknown(value: unknown): value is TUnknown;

package/build/cjs/type/types/unknown.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unknown = Unknown;
+exports.IsUnknown = IsUnknown;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Unknown type. */
+function Unknown(options) {
+    return index_1.Memory.Create({ ['~kind']: 'Unknown' }, {}, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TUnknown. */
+function IsUnknown(value) {
+    return (0, schema_1.IsKind)(value, 'Unknown');
+}

package/build/cjs/type/types/unsafe.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema } from './schema';
+export type StaticUnsafe<Type extends unknown> = Type;
+/** Represents an Unsafe type. */
+export interface TUnsafe<Type extends unknown = unknown> extends TSchema {
+    '~kind': 'Unsafe';
+    '~hint': Type;
+}
+/** Creates a Unsafe type. */
+export declare function Unsafe<Type extends unknown>(schema: TSchema): TUnsafe<Type>;
+/** Returns true if the given value is TUnsafe. */
+export declare function IsUnsafe(value: unknown): value is TUnsafe;

package/build/cjs/type/types/unsafe.js

@@ -0,0 +1,22 @@
+"use strict";
+// deno-fmt-ignore-file
+// deno-lint-ignore-file 
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Unsafe = Unsafe;
+exports.IsUnsafe = IsUnsafe;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Unsafe type. */
+function Unsafe(schema) {
+    return index_1.Memory.Create({ ['~kind']: 'Unsafe' }, {}, schema);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TUnsafe. */
+function IsUnsafe(value) {
+    return (0, schema_1.IsKind)(value, 'Unsafe');
+}

package/build/cjs/type/types/void.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+export type StaticVoid = void;
+/** Represents a Void type. */
+export interface TVoid extends TSchema {
+    '~kind': 'Void';
+    type: 'void';
+}
+/** Creates a Void type. */
+export declare function Void(options?: TSchemaOptions): TVoid;
+/** Returns true if the given value is TVoid. */
+export declare function IsVoid(value: unknown): value is TVoid;

package/build/cjs/type/types/void.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Void = Void;
+exports.IsVoid = IsVoid;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Void type. */
+function Void(options) {
+    return index_1.Memory.Create({ '~kind': 'Void' }, { type: 'void' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TVoid. */
+function IsVoid(value) {
+    return (0, schema_1.IsKind)(value, 'Void');
+}

package/build/cjs/typebox.d.ts

@@ -0,0 +1,71 @@
+export { Instantiate, type TInstantiate } from './type/engine/instantiate';
+export { Extends, ExtendsResult, type TExtends } from './type/extends/index';
+export { Script, type TScript } from './type/script/index';
+export { Awaited, type AwaitedDeferred, type TAwaited } from './type/action/awaited';
+export { Capitalize, type TCapitalize, type TCapitalizeDeferred } from './type/action/capitalize';
+export { Conditional, type TConditional, type TConditionalDeferred } from './type/action/conditional';
+export { ConstructorParameters, type TConstructorParameters, type TConstructorParametersDeferred } from './type/action/constructor-parameters';
+export { Evaluate, type TEvaluate, type TEvaluateDeferred } from './type/action/evaluate';
+export { Exclude, type TExclude, type TExcludeDeferred } from './type/action/exclude';
+export { Extract, type TExtract, type TExtractDeferred } from './type/action/extract';
+export { Index, type TIndex, type TIndexDeferred } from './type/action/index';
+export { InstanceType, type TInstanceType, type TInstanceTypeDeferred } from './type/action/instance-type';
+export { Interface, type TInterface, type TInterfaceDeferred } from './type/action/interface';
+export { KeyOf, type TKeyOf, type TKeyOfDeferred } from './type/action/keyof';
+export { Lowercase, type TLowercase, type TLowercaseDeferred } from './type/action/lowercase';
+export { Mapped, type TMapped, type TMappedDeferred } from './type/action/mapped';
+export { Module, type TModule, type TModuleDeferred } from './type/action/module';
+export { NonNullable, type TNonNullable, type TNonNullableDeferred } from './type/action/non-nullable';
+export { Omit, type TOmit, type TOmitDeferred } from './type/action/omit';
+export { Options, type TOptions } from './type/action/options';
+export { Parameters, type TParameters, type TParametersDeferred } from './type/action/parameters';
+export { Partial, type TPartial, type TPartialDeferred } from './type/action/partial';
+export { Pick, type TPick, type TPickDeferred } from './type/action/pick';
+export { Required, type TRequired, type TRequiredDeferred } from './type/action/required';
+export { ReturnType, type TReturnType, type TReturnTypeDeferred } from './type/action/return-type';
+export { type TUncapitalize, type TUncapitalizeDeferred, Uncapitalize } from './type/action/uncapitalize';
+export { type TUppercase, type TUppercaseDeferred, Uppercase } from './type/action/uppercase';
+export { Codec, Decode, DecodeBuilder, Encode, EncodeBuilder, IsCodec, type TCodec } from './type/types/_codec';
+export { IsOptional, Optional, type TOptional } from './type/types/_optional';
+export { IsReadonly, Readonly, type TReadonly } from './type/types/_readonly';
+export { IsRefine, Refine, type TRefine, type TRefineCallback, type TRefinement } from './type/types/_refine';
+export { Any, IsAny, type TAny } from './type/types/any';
+export { Array, IsArray, type TArray } from './type/types/array';
+export { AsyncIterator, IsAsyncIterator, type TAsyncIterator } from './type/types/async-iterator';
+export { Base, IsBase } from './type/types/base';
+export { BigInt, IsBigInt, type TBigInt } from './type/types/bigint';
+export { Boolean, IsBoolean, type TBoolean } from './type/types/boolean';
+export { Call, IsCall, type TCall } from './type/types/call';
+export { Constructor, IsConstructor, type TConstructor } from './type/types/constructor';
+export { Cyclic, IsCyclic, type TCyclic } from './type/types/cyclic';
+export { Enum, IsEnum, type TEnum, type TEnumValue } from './type/types/enum';
+export { Function, IsFunction, type TFunction } from './type/types/function';
+export { Generic, IsGeneric, type TGeneric } from './type/types/generic';
+export { Identifier, IsIdentifier, type TIdentifier } from './type/types/identifier';
+export { Infer, IsInfer, type TInfer } from './type/types/infer';
+export { Integer, IsInteger, type TInteger } from './type/types/integer';
+export { Intersect, IsIntersect, type TIntersect } from './type/types/intersect';
+export { IsIterator, Iterator, type TIterator } from './type/types/iterator';
+export { IsLiteral, Literal, type TLiteral, type TLiteralValue } from './type/types/literal';
+export { IsNever, Never, type TNever } from './type/types/never';
+export { IsNull, Null, type TNull } from './type/types/null';
+export { IsNumber, Number, type TNumber } from './type/types/number';
+export { IsObject, Object, type TObject } from './type/types/object';
+export { IsParameter, Parameter, type TParameter } from './type/types/parameter';
+export { IsPromise, Promise, type TPromise } from './type/types/promise';
+export { type TProperties, type TRequiredArray } from './type/types/properties';
+export { IsRecord, Record, RecordKey, RecordPattern as RecordKeyAsPattern, RecordValue, type TRecord, type TRecordKey as TRecordKey, type TRecordPattern as TRecordKeyAsPattern, type TRecordValue } from './type/types/record';
+export { IsRef, Ref, type TRef } from './type/types/ref';
+export { IsRest, Rest, type TRest } from './type/types/rest';
+export { IsKind, IsSchema, type TArrayOptions, type TFormat, type TIntersectOptions, type TNumberOptions, type TObjectOptions, type TSchema, type TSchemaOptions, type TStringOptions, type TTupleOptions } from './type/types/schema';
+export { type Static, type StaticDecode, type StaticEncode, type StaticParse } from './type/types/static';
+export { IsString, String, type TString } from './type/types/string';
+export { IsSymbol, Symbol, type TSymbol } from './type/types/symbol';
+export { IsTemplateLiteral, TemplateLiteral, type TTemplateLiteral } from './type/types/template-literal';
+export { IsThis, This, type TThis } from './type/types/this';
+export { IsTuple, type TTuple, Tuple } from './type/types/tuple';
+export { IsUndefined, type TUndefined, Undefined } from './type/types/undefined';
+export { IsUnion, type TUnion, Union } from './type/types/union';
+export { IsUnknown, type TUnknown, Unknown } from './type/types/unknown';
+export { IsUnsafe, type TUnsafe, Unsafe } from './type/types/unsafe';
+export { IsVoid, type TVoid, Void } from './type/types/void';

package/build/cjs/typebox.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsBigInt = exports.BigInt = exports.IsBase = exports.Base = exports.IsAsyncIterator = exports.AsyncIterator = exports.IsArray = exports.Array = exports.IsAny = exports.Any = exports.Refine = exports.IsRefine = exports.Readonly = exports.IsReadonly = exports.Optional = exports.IsOptional = exports.IsCodec = exports.EncodeBuilder = exports.Encode = exports.DecodeBuilder = exports.Decode = exports.Codec = exports.Uppercase = exports.Uncapitalize = exports.ReturnType = exports.Required = exports.Pick = exports.Partial = exports.Parameters = exports.Options = exports.Omit = exports.NonNullable = exports.Module = exports.Mapped = exports.Lowercase = exports.KeyOf = exports.Interface = exports.InstanceType = exports.Index = exports.Extract = exports.Exclude = exports.Evaluate = exports.ConstructorParameters = exports.Conditional = exports.Capitalize = exports.Awaited = exports.Script = exports.ExtendsResult = exports.Extends = exports.Instantiate = void 0;
+exports.IsString = exports.IsSchema = exports.IsKind = exports.Rest = exports.IsRest = exports.Ref = exports.IsRef = exports.RecordValue = exports.RecordKeyAsPattern = exports.RecordKey = exports.Record = exports.IsRecord = exports.Promise = exports.IsPromise = exports.Parameter = exports.IsParameter = exports.Object = exports.IsObject = exports.Number = exports.IsNumber = exports.Null = exports.IsNull = exports.Never = exports.IsNever = exports.Literal = exports.IsLiteral = exports.Iterator = exports.IsIterator = exports.IsIntersect = exports.Intersect = exports.IsInteger = exports.Integer = exports.IsInfer = exports.Infer = exports.IsIdentifier = exports.Identifier = exports.IsGeneric = exports.Generic = exports.IsFunction = exports.Function = exports.IsEnum = exports.Enum = exports.IsCyclic = exports.Cyclic = exports.IsConstructor = exports.Constructor = exports.IsCall = exports.Call = exports.IsBoolean = exports.Boolean = void 0;
+exports.Void = exports.IsVoid = exports.Unsafe = exports.IsUnsafe = exports.Unknown = exports.IsUnknown = exports.Union = exports.IsUnion = exports.Undefined = exports.IsUndefined = exports.Tuple = exports.IsTuple = exports.This = exports.IsThis = exports.TemplateLiteral = exports.IsTemplateLiteral = exports.Symbol = exports.IsSymbol = exports.String = void 0;
+// ------------------------------------------------------------------
+// Engine
+// ------------------------------------------------------------------
+var instantiate_1 = require("./type/engine/instantiate");
+Object.defineProperty(exports, "Instantiate", { enumerable: true, get: function () { return instantiate_1.Instantiate; } });
+// ------------------------------------------------------------------
+// Extends
+// ------------------------------------------------------------------
+var index_1 = require("./type/extends/index");
+Object.defineProperty(exports, "Extends", { enumerable: true, get: function () { return index_1.Extends; } });
+Object.defineProperty(exports, "ExtendsResult", { enumerable: true, get: function () { return index_1.ExtendsResult; } });
+// ------------------------------------------------------------------
+// Script
+// ------------------------------------------------------------------
+var index_2 = require("./type/script/index");
+Object.defineProperty(exports, "Script", { enumerable: true, get: function () { return index_2.Script; } });
+// ------------------------------------------------------------------
+// Actions
+// ------------------------------------------------------------------
+var awaited_1 = require("./type/action/awaited");
+Object.defineProperty(exports, "Awaited", { enumerable: true, get: function () { return awaited_1.Awaited; } });
+var capitalize_1 = require("./type/action/capitalize");
+Object.defineProperty(exports, "Capitalize", { enumerable: true, get: function () { return capitalize_1.Capitalize; } });
+var conditional_1 = require("./type/action/conditional");
+Object.defineProperty(exports, "Conditional", { enumerable: true, get: function () { return conditional_1.Conditional; } });
+var constructor_parameters_1 = require("./type/action/constructor-parameters");
+Object.defineProperty(exports, "ConstructorParameters", { enumerable: true, get: function () { return constructor_parameters_1.ConstructorParameters; } });
+var evaluate_1 = require("./type/action/evaluate");
+Object.defineProperty(exports, "Evaluate", { enumerable: true, get: function () { return evaluate_1.Evaluate; } });
+var exclude_1 = require("./type/action/exclude");
+Object.defineProperty(exports, "Exclude", { enumerable: true, get: function () { return exclude_1.Exclude; } });
+var extract_1 = require("./type/action/extract");
+Object.defineProperty(exports, "Extract", { enumerable: true, get: function () { return extract_1.Extract; } });
+var index_3 = require("./type/action/index");
+Object.defineProperty(exports, "Index", { enumerable: true, get: function () { return index_3.Index; } });
+var instance_type_1 = require("./type/action/instance-type");
+Object.defineProperty(exports, "InstanceType", { enumerable: true, get: function () { return instance_type_1.InstanceType; } });
+var interface_1 = require("./type/action/interface");
+Object.defineProperty(exports, "Interface", { enumerable: true, get: function () { return interface_1.Interface; } });
+var keyof_1 = require("./type/action/keyof");
+Object.defineProperty(exports, "KeyOf", { enumerable: true, get: function () { return keyof_1.KeyOf; } });
+var lowercase_1 = require("./type/action/lowercase");
+Object.defineProperty(exports, "Lowercase", { enumerable: true, get: function () { return lowercase_1.Lowercase; } });
+var mapped_1 = require("./type/action/mapped");
+Object.defineProperty(exports, "Mapped", { enumerable: true, get: function () { return mapped_1.Mapped; } });
+var module_1 = require("./type/action/module");
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return module_1.Module; } });
+var non_nullable_1 = require("./type/action/non-nullable");
+Object.defineProperty(exports, "NonNullable", { enumerable: true, get: function () { return non_nullable_1.NonNullable; } });
+var omit_1 = require("./type/action/omit");
+Object.defineProperty(exports, "Omit", { enumerable: true, get: function () { return omit_1.Omit; } });
+var options_1 = require("./type/action/options");
+Object.defineProperty(exports, "Options", { enumerable: true, get: function () { return options_1.Options; } });
+var parameters_1 = require("./type/action/parameters");
+Object.defineProperty(exports, "Parameters", { enumerable: true, get: function () { return parameters_1.Parameters; } });
+var partial_1 = require("./type/action/partial");
+Object.defineProperty(exports, "Partial", { enumerable: true, get: function () { return partial_1.Partial; } });
+var pick_1 = require("./type/action/pick");
+Object.defineProperty(exports, "Pick", { enumerable: true, get: function () { return pick_1.Pick; } });
+var required_1 = require("./type/action/required");
+Object.defineProperty(exports, "Required", { enumerable: true, get: function () { return required_1.Required; } });
+var return_type_1 = require("./type/action/return-type");
+Object.defineProperty(exports, "ReturnType", { enumerable: true, get: function () { return return_type_1.ReturnType; } });
+var uncapitalize_1 = require("./type/action/uncapitalize");
+Object.defineProperty(exports, "Uncapitalize", { enumerable: true, get: function () { return uncapitalize_1.Uncapitalize; } });
+var uppercase_1 = require("./type/action/uppercase");
+Object.defineProperty(exports, "Uppercase", { enumerable: true, get: function () { return uppercase_1.Uppercase; } });
+// ------------------------------------------------------------------
+// Extension
+// ------------------------------------------------------------------
+var _codec_1 = require("./type/types/_codec");
+Object.defineProperty(exports, "Codec", { enumerable: true, get: function () { return _codec_1.Codec; } });
+Object.defineProperty(exports, "Decode", { enumerable: true, get: function () { return _codec_1.Decode; } });
+Object.defineProperty(exports, "DecodeBuilder", { enumerable: true, get: function () { return _codec_1.DecodeBuilder; } });
+Object.defineProperty(exports, "Encode", { enumerable: true, get: function () { return _codec_1.Encode; } });
+Object.defineProperty(exports, "EncodeBuilder", { enumerable: true, get: function () { return _codec_1.EncodeBuilder; } });
+Object.defineProperty(exports, "IsCodec", { enumerable: true, get: function () { return _codec_1.IsCodec; } });
+var _optional_1 = require("./type/types/_optional");
+Object.defineProperty(exports, "IsOptional", { enumerable: true, get: function () { return _optional_1.IsOptional; } });
+Object.defineProperty(exports, "Optional", { enumerable: true, get: function () { return _optional_1.Optional; } });
+var _readonly_1 = require("./type/types/_readonly");
+Object.defineProperty(exports, "IsReadonly", { enumerable: true, get: function () { return _readonly_1.IsReadonly; } });
+Object.defineProperty(exports, "Readonly", { enumerable: true, get: function () { return _readonly_1.Readonly; } });
+var _refine_1 = require("./type/types/_refine");
+Object.defineProperty(exports, "IsRefine", { enumerable: true, get: function () { return _refine_1.IsRefine; } });
+Object.defineProperty(exports, "Refine", { enumerable: true, get: function () { return _refine_1.Refine; } });
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+var any_1 = require("./type/types/any");
+Object.defineProperty(exports, "Any", { enumerable: true, get: function () { return any_1.Any; } });
+Object.defineProperty(exports, "IsAny", { enumerable: true, get: function () { return any_1.IsAny; } });
+var array_1 = require("./type/types/array");
+Object.defineProperty(exports, "Array", { enumerable: true, get: function () { return array_1.Array; } });
+Object.defineProperty(exports, "IsArray", { enumerable: true, get: function () { return array_1.IsArray; } });
+var async_iterator_1 = require("./type/types/async-iterator");
+Object.defineProperty(exports, "AsyncIterator", { enumerable: true, get: function () { return async_iterator_1.AsyncIterator; } });
+Object.defineProperty(exports, "IsAsyncIterator", { enumerable: true, get: function () { return async_iterator_1.IsAsyncIterator; } });
+var base_1 = require("./type/types/base");
+Object.defineProperty(exports, "Base", { enumerable: true, get: function () { return base_1.Base; } });
+Object.defineProperty(exports, "IsBase", { enumerable: true, get: function () { return base_1.IsBase; } });
+var bigint_1 = require("./type/types/bigint");
+Object.defineProperty(exports, "BigInt", { enumerable: true, get: function () { return bigint_1.BigInt; } });
+Object.defineProperty(exports, "IsBigInt", { enumerable: true, get: function () { return bigint_1.IsBigInt; } });
+var boolean_1 = require("./type/types/boolean");
+Object.defineProperty(exports, "Boolean", { enumerable: true, get: function () { return boolean_1.Boolean; } });
+Object.defineProperty(exports, "IsBoolean", { enumerable: true, get: function () { return boolean_1.IsBoolean; } });
+var call_1 = require("./type/types/call");
+Object.defineProperty(exports, "Call", { enumerable: true, get: function () { return call_1.Call; } });
+Object.defineProperty(exports, "IsCall", { enumerable: true, get: function () { return call_1.IsCall; } });
+var constructor_1 = require("./type/types/constructor");
+Object.defineProperty(exports, "Constructor", { enumerable: true, get: function () { return constructor_1.Constructor; } });
+Object.defineProperty(exports, "IsConstructor", { enumerable: true, get: function () { return constructor_1.IsConstructor; } });
+var cyclic_1 = require("./type/types/cyclic");
+Object.defineProperty(exports, "Cyclic", { enumerable: true, get: function () { return cyclic_1.Cyclic; } });
+Object.defineProperty(exports, "IsCyclic", { enumerable: true, get: function () { return cyclic_1.IsCyclic; } });
+var enum_1 = require("./type/types/enum");
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return enum_1.Enum; } });
+Object.defineProperty(exports, "IsEnum", { enumerable: true, get: function () { return enum_1.IsEnum; } });
+var function_1 = require("./type/types/function");
+Object.defineProperty(exports, "Function", { enumerable: true, get: function () { return function_1.Function; } });
+Object.defineProperty(exports, "IsFunction", { enumerable: true, get: function () { return function_1.IsFunction; } });
+var generic_1 = require("./type/types/generic");
+Object.defineProperty(exports, "Generic", { enumerable: true, get: function () { return generic_1.Generic; } });
+Object.defineProperty(exports, "IsGeneric", { enumerable: true, get: function () { return generic_1.IsGeneric; } });
+var identifier_1 = require("./type/types/identifier");
+Object.defineProperty(exports, "Identifier", { enumerable: true, get: function () { return identifier_1.Identifier; } });
+Object.defineProperty(exports, "IsIdentifier", { enumerable: true, get: function () { return identifier_1.IsIdentifier; } });
+var infer_1 = require("./type/types/infer");
+Object.defineProperty(exports, "Infer", { enumerable: true, get: function () { return infer_1.Infer; } });
+Object.defineProperty(exports, "IsInfer", { enumerable: true, get: function () { return infer_1.IsInfer; } });
+var integer_1 = require("./type/types/integer");
+Object.defineProperty(exports, "Integer", { enumerable: true, get: function () { return integer_1.Integer; } });
+Object.defineProperty(exports, "IsInteger", { enumerable: true, get: function () { return integer_1.IsInteger; } });
+var intersect_1 = require("./type/types/intersect");
+Object.defineProperty(exports, "Intersect", { enumerable: true, get: function () { return intersect_1.Intersect; } });
+Object.defineProperty(exports, "IsIntersect", { enumerable: true, get: function () { return intersect_1.IsIntersect; } });
+var iterator_1 = require("./type/types/iterator");
+Object.defineProperty(exports, "IsIterator", { enumerable: true, get: function () { return iterator_1.IsIterator; } });
+Object.defineProperty(exports, "Iterator", { enumerable: true, get: function () { return iterator_1.Iterator; } });
+var literal_1 = require("./type/types/literal");
+Object.defineProperty(exports, "IsLiteral", { enumerable: true, get: function () { return literal_1.IsLiteral; } });
+Object.defineProperty(exports, "Literal", { enumerable: true, get: function () { return literal_1.Literal; } });
+var never_1 = require("./type/types/never");
+Object.defineProperty(exports, "IsNever", { enumerable: true, get: function () { return never_1.IsNever; } });
+Object.defineProperty(exports, "Never", { enumerable: true, get: function () { return never_1.Never; } });
+var null_1 = require("./type/types/null");
+Object.defineProperty(exports, "IsNull", { enumerable: true, get: function () { return null_1.IsNull; } });
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return null_1.Null; } });
+var number_1 = require("./type/types/number");
+Object.defineProperty(exports, "IsNumber", { enumerable: true, get: function () { return number_1.IsNumber; } });
+Object.defineProperty(exports, "Number", { enumerable: true, get: function () { return number_1.Number; } });
+var object_1 = require("./type/types/object");
+Object.defineProperty(exports, "IsObject", { enumerable: true, get: function () { return object_1.IsObject; } });
+Object.defineProperty(exports, "Object", { enumerable: true, get: function () { return object_1.Object; } });
+var parameter_1 = require("./type/types/parameter");
+Object.defineProperty(exports, "IsParameter", { enumerable: true, get: function () { return parameter_1.IsParameter; } });
+Object.defineProperty(exports, "Parameter", { enumerable: true, get: function () { return parameter_1.Parameter; } });
+var promise_1 = require("./type/types/promise");
+Object.defineProperty(exports, "IsPromise", { enumerable: true, get: function () { return promise_1.IsPromise; } });
+Object.defineProperty(exports, "Promise", { enumerable: true, get: function () { return promise_1.Promise; } });
+var record_1 = require("./type/types/record");
+Object.defineProperty(exports, "IsRecord", { enumerable: true, get: function () { return record_1.IsRecord; } });
+Object.defineProperty(exports, "Record", { enumerable: true, get: function () { return record_1.Record; } });
+Object.defineProperty(exports, "RecordKey", { enumerable: true, get: function () { return record_1.RecordKey; } });
+Object.defineProperty(exports, "RecordKeyAsPattern", { enumerable: true, get: function () { return record_1.RecordPattern; } });
+Object.defineProperty(exports, "RecordValue", { enumerable: true, get: function () { return record_1.RecordValue; } });
+var ref_1 = require("./type/types/ref");
+Object.defineProperty(exports, "IsRef", { enumerable: true, get: function () { return ref_1.IsRef; } });
+Object.defineProperty(exports, "Ref", { enumerable: true, get: function () { return ref_1.Ref; } });
+var rest_1 = require("./type/types/rest");
+Object.defineProperty(exports, "IsRest", { enumerable: true, get: function () { return rest_1.IsRest; } });
+Object.defineProperty(exports, "Rest", { enumerable: true, get: function () { return rest_1.Rest; } });
+var schema_1 = require("./type/types/schema");
+Object.defineProperty(exports, "IsKind", { enumerable: true, get: function () { return schema_1.IsKind; } });
+Object.defineProperty(exports, "IsSchema", { enumerable: true, get: function () { return schema_1.IsSchema; } });
+var string_1 = require("./type/types/string");
+Object.defineProperty(exports, "IsString", { enumerable: true, get: function () { return string_1.IsString; } });
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return string_1.String; } });
+var symbol_1 = require("./type/types/symbol");
+Object.defineProperty(exports, "IsSymbol", { enumerable: true, get: function () { return symbol_1.IsSymbol; } });
+Object.defineProperty(exports, "Symbol", { enumerable: true, get: function () { return symbol_1.Symbol; } });
+var template_literal_1 = require("./type/types/template-literal");
+Object.defineProperty(exports, "IsTemplateLiteral", { enumerable: true, get: function () { return template_literal_1.IsTemplateLiteral; } });
+Object.defineProperty(exports, "TemplateLiteral", { enumerable: true, get: function () { return template_literal_1.TemplateLiteral; } });
+var this_1 = require("./type/types/this");
+Object.defineProperty(exports, "IsThis", { enumerable: true, get: function () { return this_1.IsThis; } });
+Object.defineProperty(exports, "This", { enumerable: true, get: function () { return this_1.This; } });
+var tuple_1 = require("./type/types/tuple");
+Object.defineProperty(exports, "IsTuple", { enumerable: true, get: function () { return tuple_1.IsTuple; } });
+Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return tuple_1.Tuple; } });
+var undefined_1 = require("./type/types/undefined");
+Object.defineProperty(exports, "IsUndefined", { enumerable: true, get: function () { return undefined_1.IsUndefined; } });
+Object.defineProperty(exports, "Undefined", { enumerable: true, get: function () { return undefined_1.Undefined; } });
+var union_1 = require("./type/types/union");
+Object.defineProperty(exports, "IsUnion", { enumerable: true, get: function () { return union_1.IsUnion; } });
+Object.defineProperty(exports, "Union", { enumerable: true, get: function () { return union_1.Union; } });
+var unknown_1 = require("./type/types/unknown");
+Object.defineProperty(exports, "IsUnknown", { enumerable: true, get: function () { return unknown_1.IsUnknown; } });
+Object.defineProperty(exports, "Unknown", { enumerable: true, get: function () { return unknown_1.Unknown; } });
+var unsafe_1 = require("./type/types/unsafe");
+Object.defineProperty(exports, "IsUnsafe", { enumerable: true, get: function () { return unsafe_1.IsUnsafe; } });
+Object.defineProperty(exports, "Unsafe", { enumerable: true, get: function () { return unsafe_1.Unsafe; } });
+var void_1 = require("./type/types/void");
+Object.defineProperty(exports, "IsVoid", { enumerable: true, get: function () { return void_1.IsVoid; } });
+Object.defineProperty(exports, "Void", { enumerable: true, get: function () { return void_1.Void; } });

package/build/cjs/value/assert/assert.d.ts

@@ -0,0 +1,14 @@
+import type { TLocalizedValidationError } from '../../error/index';
+import type { Static, TProperties, TSchema } from '../../type/index';
+export declare class AssertError extends Error {
+    readonly cause: {
+        source: string;
+        errors: TLocalizedValidationError[];
+        value: unknown;
+    };
+    constructor(source: string, value: unknown, errors: TLocalizedValidationError[]);
+}
+/** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
+export declare function Assert<Context extends TProperties, const Type extends TSchema, Result extends unknown = Static<Type, Context>>(context: Context, type: Type, value: unknown): asserts value is Result;
+/** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
+export declare function Assert<const Type extends TSchema, Result extends unknown = Static<Type>>(type: Type, value: unknown): asserts value is Result;

package/build/cjs/value/assert/assert.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertError = void 0;
+exports.Assert = Assert;
+const index_1 = require("../../system/arguments/index");
+const index_2 = require("../check/index");
+const index_3 = require("../errors/index");
+// ------------------------------------------------------------------
+// AssertError
+// ------------------------------------------------------------------
+class AssertError extends Error {
+    constructor(source, value, errors) {
+        super(source);
+        Object.defineProperty(this, 'cause', {
+            value: { source, errors, value },
+            writable: false,
+            configurable: false,
+            enumerable: false
+        });
+    }
+}
+exports.AssertError = AssertError;
+/** Asserts the a value matches the given type. This function returns a TypeScript type asserts predicate and will throw AssertError if value does not match. */
+function Assert(...args) {
+    const [context, type, value] = index_1.Arguments.Match(args, {
+        3: (context, type, value) => [context, type, value],
+        2: (type, value) => [{}, type, value]
+    });
+    const check = (0, index_2.Check)(context, type, value);
+    if (!check)
+        throw new AssertError('Assert', value, (0, index_3.Errors)(context, type, value));
+}

package/build/cjs/value/assert/index.d.ts

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

package/build/cjs/value/assert/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("./assert"), exports);