typebox 1.0.33 → 1.0.34

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

@@ -1,16 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema';
-import { type TTypeScriptEnumLike } from '../engine/enum/typescript-enum-to-enum-values';
-import { type TTypeScriptEnumToEnumValues } from '../engine/enum/typescript-enum-to-enum-values';
-export type StaticEnum<Values extends TEnumValue[]> = (Values[number]);
-export type TEnumValue = string | number | null;
-/** Represents an Enum type. */
-export interface TEnum<Values extends TEnumValue[] = TEnumValue[]> extends TSchema {
-    '~kind': 'Enum';
-    enum: Values;
-}
-/** Creates an Enum type. */
-export declare function Enum<Values extends TEnumValue[]>(values: readonly [...Values], options?: TSchemaOptions): TEnum<Values>;
-/** Creates an Enum type from a TypeScript enum declaration. */
-export declare function Enum<Enum extends TTypeScriptEnumLike>(value: Enum, options?: TSchemaOptions): TEnum<TTypeScriptEnumToEnumValues<Enum>>;
-/** Returns true if the given value is a TEnum. */
-export declare function IsEnum(value: unknown): value is TEnum;

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

@@ -1,21 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Enum = Enum;
-exports.IsEnum = IsEnum;
-const index_1 = require("../../system/memory/index");
-const schema_1 = require("./schema");
-const typescript_enum_to_enum_values_1 = require("../engine/enum/typescript-enum-to-enum-values");
-const typescript_enum_to_enum_values_2 = require("../engine/enum/typescript-enum-to-enum-values");
-/** Creates an Enum type. */
-function Enum(value, options) {
-    const values = (0, typescript_enum_to_enum_values_1.IsTypeScriptEnumLike)(value) ? (0, typescript_enum_to_enum_values_2.TypeScriptEnumToEnumValues)(value) : value;
-    return index_1.Memory.Create({ '~kind': 'Enum' }, { enum: values }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TEnum. */
-function IsEnum(value) {
-    return (0, schema_1.IsKind)(value, 'Enum');
-}

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

@@ -1,20 +0,0 @@
-import { type StaticType, type StaticDirection } from './static';
-import { type TSchema, type TSchemaOptions } from './schema';
-import { type TProperties } from './properties';
-import { type TTuple } from './tuple';
-import { type TInstantiate } from '../engine/instantiate';
-export type StaticInstantiatedParameters<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], Evaluated extends TSchema = TInstantiate<Context, TTuple<Parameters>>, Static extends unknown = StaticType<Stack, Direction, Context, This, Evaluated>, Result extends unknown[] = Static extends unknown[] ? Static : []> = Result;
-export type StaticFunction<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Parameters extends TSchema[], ReturnType extends TSchema, StaticParameters extends unknown[] = StaticInstantiatedParameters<Stack, Direction, Context, This, Parameters>, StaticReturnType extends unknown = StaticType<Stack, Direction, Context, This, ReturnType>, Result = (...args: StaticParameters) => StaticReturnType> = Result;
-/** Represents a Function type. */
-export interface TFunction<Parameters extends TSchema[] = TSchema[], ReturnType extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Function';
-    type: 'function';
-    parameters: Parameters;
-    returnType: ReturnType;
-}
-/** Creates a Function type. */
-export declare function Function<Parameters extends TSchema[], ReturnType extends TSchema>(parameters: [...Parameters], returnType: ReturnType, options?: TSchemaOptions): TFunction<Parameters, ReturnType>;
-/** Returns true if the given value is TFunction. */
-export declare function IsFunction(value: unknown): value is TFunction;
-/** Extracts options from a TFunction. */
-export declare function FunctionOptions(type: TFunction): TSchemaOptions;

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

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

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

@@ -1,13 +0,0 @@
-import { type TSchema } from '../types/schema';
-import { type TParameter } from './parameter';
-/** Represents a callable Generic type. */
-export interface TGeneric<Parameters extends TParameter[] = TParameter[], Expression extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Generic';
-    type: 'generic';
-    parameters: Parameters;
-    expression: Expression;
-}
-/** Creates a Generic type. */
-export declare function Generic<Parameters extends TParameter[], Expression extends TSchema>(parameters: [...Parameters], expression: Expression): TGeneric<Parameters, Expression>;
-/** Returns true if the given value is a TGeneric. */
-export declare function IsGeneric(value: unknown): value is TGeneric;

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

@@ -1,21 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Generic = Generic;
-exports.IsGeneric = IsGeneric;
-const index_1 = require("../../system/memory/index");
-const schema_1 = require("../types/schema");
-// ------------------------------------------------------------------
-// Type
-// ------------------------------------------------------------------
-/** Creates a Generic type. */
-function Generic(parameters, expression) {
-    return index_1.Memory.Create({ '~kind': 'Generic' }, { type: 'generic', parameters, expression });
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TGeneric. */
-function IsGeneric(value) {
-    return (0, schema_1.IsKind)(value, 'Generic');
-}

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

@@ -1,11 +0,0 @@
-import { type TSchema } from '../types/schema';
-/** Represents a Identifier. */
-export interface TIdentifier<Name extends string = string> extends TSchema {
-    '~kind': 'Identifier';
-    type: 'identifier';
-    name: Name;
-}
-/** Creates an Identifier. */
-export declare function Identifier<Name extends string>(name: Name): TIdentifier<Name>;
-/** Returns true if the given value is a TIdentifier. */
-export declare function IsIdentifier(value: unknown): value is TIdentifier;

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

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

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

@@ -1,47 +0,0 @@
-export * from './_codec';
-export * from './_optional';
-export * from './_readonly';
-export * from './_refine';
-export * from './any';
-export * from './array';
-export * from './async-iterator';
-export * from './base';
-export * from './bigint';
-export * from './boolean';
-export * from './call';
-export * from './constructor';
-export * from './cyclic';
-export * from './deferred';
-export * from './enum';
-export * from './function';
-export * from './generic';
-export * from './identifier';
-export * from './infer';
-export * from './integer';
-export * from './intersect';
-export * from './iterator';
-export * from './literal';
-export * from './never';
-export * from './null';
-export * from './number';
-export * from './unknown';
-export * from './symbol';
-export * from './object';
-export * from './parameter';
-export * from './promise';
-export * from './properties';
-export * from './record';
-export * from './ref';
-export * from './rest';
-export * from './schema';
-export * from './static';
-export * from './string';
-export * from './symbol';
-export * from './template-literal';
-export * from './this';
-export * from './tuple';
-export * from './undefined';
-export * from './union';
-export * from './unknown';
-export * from './unsafe';
-export * from './void';

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

@@ -1,69 +0,0 @@
-"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 });
-// ------------------------------------------------------------------
-// Extensions
-// ------------------------------------------------------------------
-__exportStar(require("./_codec"), exports);
-__exportStar(require("./_optional"), exports);
-__exportStar(require("./_readonly"), exports);
-__exportStar(require("./_refine"), exports);
-// ------------------------------------------------------------------
-// Standard
-// ------------------------------------------------------------------
-__exportStar(require("./any"), exports);
-__exportStar(require("./array"), exports);
-__exportStar(require("./async-iterator"), exports);
-__exportStar(require("./base"), exports);
-__exportStar(require("./bigint"), exports);
-__exportStar(require("./boolean"), exports);
-__exportStar(require("./call"), exports);
-__exportStar(require("./constructor"), exports);
-__exportStar(require("./cyclic"), exports);
-__exportStar(require("./deferred"), exports);
-__exportStar(require("./enum"), exports);
-__exportStar(require("./function"), exports);
-__exportStar(require("./generic"), exports);
-__exportStar(require("./identifier"), exports);
-__exportStar(require("./infer"), exports);
-__exportStar(require("./integer"), exports);
-__exportStar(require("./intersect"), exports);
-__exportStar(require("./iterator"), exports);
-__exportStar(require("./literal"), exports);
-__exportStar(require("./never"), exports);
-__exportStar(require("./null"), exports);
-__exportStar(require("./number"), exports);
-__exportStar(require("./unknown"), exports);
-__exportStar(require("./symbol"), exports);
-__exportStar(require("./object"), exports);
-__exportStar(require("./parameter"), exports);
-__exportStar(require("./promise"), exports);
-__exportStar(require("./properties"), exports);
-__exportStar(require("./record"), exports);
-__exportStar(require("./ref"), exports);
-__exportStar(require("./rest"), exports);
-__exportStar(require("./schema"), exports);
-__exportStar(require("./static"), exports);
-__exportStar(require("./string"), exports);
-__exportStar(require("./symbol"), exports);
-__exportStar(require("./template-literal"), exports);
-__exportStar(require("./this"), exports);
-__exportStar(require("./tuple"), exports);
-__exportStar(require("./undefined"), exports);
-__exportStar(require("./union"), exports);
-__exportStar(require("./unknown"), exports);
-__exportStar(require("./unsafe"), exports);
-__exportStar(require("./void"), exports);

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

@@ -1,15 +0,0 @@
-import { type TSchema } from '../types/schema';
-import { type TUnknown } from '../types/unknown';
-/** Represents an Infer instruction. */
-export interface TInfer<Name extends string = string, Extends extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Infer';
-    type: 'infer';
-    name: Name;
-    extends: Extends;
-}
-/** Creates an Infer instruction. */
-export declare function Infer<Name extends string, Extends extends TSchema>(name: Name, extends_: Extends): TInfer<Name, Extends>;
-/** Creates an Infer instruction. */
-export declare function Infer<Name extends string>(name: Name): TInfer<Name, TUnknown>;
-/** Returns true if the given value is TInfer. */
-export declare function IsInfer(value: unknown): value is TInfer;

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

@@ -1,24 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Infer = Infer;
-exports.IsInfer = IsInfer;
-const index_1 = require("../../system/arguments/index");
-const index_2 = require("../../system/memory/index");
-const schema_1 = require("../types/schema");
-const unknown_1 = require("../types/unknown");
-/** Creates an Infer instruction. */
-function Infer(...args) {
-    const [name, extends_] = index_1.Arguments.Match(args, {
-        2: (name, extends_) => [name, extends_, extends_],
-        1: (name) => [name, (0, unknown_1.Unknown)(), (0, unknown_1.Unknown)()],
-    });
-    return index_2.Memory.Create({ ['~kind']: 'Infer' }, { type: 'infer', name, extends: extends_ }, {});
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TInfer. */
-function IsInfer(value) {
-    return (0, schema_1.IsKind)(value, 'Infer');
-}

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

@@ -1,12 +0,0 @@
-import { type TSchema, type TNumberOptions } from './schema';
-export declare const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
-export type StaticInteger = number;
-/** Represents an integer type. */
-export interface TInteger extends TSchema {
-    '~kind': 'Integer';
-    type: 'integer';
-}
-/** Creates a Integer type. */
-export declare function Integer(options?: TNumberOptions): TInteger;
-/** Returns true if the given value is TInteger. */
-export declare function IsInteger(value: unknown): value is TInteger;

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

@@ -1,26 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegerPattern = void 0;
-exports.Integer = Integer;
-exports.IsInteger = IsInteger;
-const index_1 = require("../../system/memory/index");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Pattern
-// ------------------------------------------------------------------
-exports.IntegerPattern = '-?(?:0|[1-9][0-9]*)';
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Integer type. */
-function Integer(options) {
-    return index_1.Memory.Create({ '~kind': 'Integer' }, { type: 'integer' }, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TInteger. */
-function IsInteger(value) {
-    return (0, schema_1.IsKind)(value, 'Integer');
-}

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

@@ -1,15 +0,0 @@
-import { type StaticType, type StaticDirection } from './static';
-import { type TSchema, type TIntersectOptions } from './schema';
-import { type TProperties } from './properties';
-export type StaticIntersect<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticIntersect<Stack, Direction, Context, This, Right, Result & StaticType<Stack, Direction, Context, This, Left>> : Result);
-/** Represents a logical Intersect type. */
-export interface TIntersect<Types extends TSchema[] = TSchema[]> extends TSchema {
-    '~kind': 'Intersect';
-    allOf: Types;
-}
-/** Creates a Intersect type. */
-export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: TIntersectOptions): TIntersect<Types>;
-/** Returns true if the given value is TIntersect. */
-export declare function IsIntersect(value: unknown): value is TIntersect;
-/** Extracts options from a TIntersect. */
-export declare function IntersectOptions(type: TIntersect): TIntersectOptions;

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

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

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

@@ -1,16 +0,0 @@
-import { type StaticType, type StaticDirection } from './static';
-import { type TSchema, type TSchemaOptions } from './schema';
-import { type TProperties } from './properties';
-export type StaticIterator<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = IterableIterator<StaticType<Stack, Direction, Context, This, Type>>> = Result;
-/** Represents an Iterator. */
-export interface TIterator<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Iterator';
-    type: 'iterator';
-    iteratorItems: Type;
-}
-/** Creates a Iterator type. */
-export declare function Iterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TIterator<Type>;
-/** Returns true if the given value is TIterator. */
-export declare function IsIterator(value: unknown): value is TIterator;
-/** Extracts options from a TIterator. */
-export declare function IteratorOptions(type: TIterator): TSchemaOptions;

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

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

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

@@ -1,22 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema';
-export type StaticLiteral<Value extends TLiteralValue> = (Value);
-export type TLiteralValue = string | number | boolean | bigint;
-/** Represents a Literal type. */
-export interface TLiteral<Value extends TLiteralValue = TLiteralValue> extends TSchema {
-    '~kind': 'Literal';
-    const: Value;
-}
-/** Creates a Literal type. */
-export declare function Literal<Value extends TLiteralValue>(value: Value, options?: TSchemaOptions): TLiteral<Value>;
-/** Returns true if the given value is a TLiteralValue. */
-export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
-/** Returns true if the given value is TLiteral<bigint>. */
-export declare function IsLiteralBigInt(value: unknown): value is TLiteral<bigint>;
-/** Returns true if the given value is TLiteral<boolean>. */
-export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
-/** Returns true if the given value is TLiteral<number>. */
-export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
-/** Returns true if the given value is TLiteral<string>. */
-export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
-/** Returns true if the given value is TLiteral. */
-export declare function IsLiteral(value: unknown): value is TLiteral;

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

@@ -1,50 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Literal = Literal;
-exports.IsLiteralValue = IsLiteralValue;
-exports.IsLiteralBigInt = IsLiteralBigInt;
-exports.IsLiteralBoolean = IsLiteralBoolean;
-exports.IsLiteralNumber = IsLiteralNumber;
-exports.IsLiteralString = IsLiteralString;
-exports.IsLiteral = IsLiteral;
-const index_1 = require("../../system/memory/index");
-const index_2 = require("../../guard/index");
-const schema_1 = require("./schema");
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates a Literal type. */
-function Literal(value, options) {
-    return index_1.Memory.Create({ '~kind': 'Literal' }, { const: value }, options);
-}
-// ------------------------------------------------------------------
-// Guards
-// ------------------------------------------------------------------
-/** Returns true if the given value is a TLiteralValue. */
-function IsLiteralValue(value) {
-    return index_2.Guard.IsBigInt(value)
-        || index_2.Guard.IsBoolean(value)
-        || index_2.Guard.IsNumber(value)
-        || index_2.Guard.IsString(value);
-}
-/** Returns true if the given value is TLiteral<bigint>. */
-function IsLiteralBigInt(value) {
-    return IsLiteral(value) && index_2.Guard.IsBigInt(value.const);
-}
-/** Returns true if the given value is TLiteral<boolean>. */
-function IsLiteralBoolean(value) {
-    return IsLiteral(value) && index_2.Guard.IsBoolean(value.const);
-}
-/** Returns true if the given value is TLiteral<number>. */
-function IsLiteralNumber(value) {
-    return IsLiteral(value) && index_2.Guard.IsNumber(value.const);
-}
-/** Returns true if the given value is TLiteral<string>. */
-function IsLiteralString(value) {
-    return IsLiteral(value) && index_2.Guard.IsString(value.const);
-}
-/** Returns true if the given value is TLiteral. */
-function IsLiteral(value) {
-    return (0, schema_1.IsKind)(value, 'Literal');
-}

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

@@ -1,12 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema';
-export declare const NeverPattern = "(?!)";
-export type StaticNever = never;
-/** Represents a Never type. */
-export interface TNever extends TSchema {
-    '~kind': 'Never';
-    not: {};
-}
-/** Creates a Never type. */
-export declare function Never(options?: TSchemaOptions): TNever;
-/** Returns true if the given value is TNever. */
-export declare function IsNever(value: unknown): value is TNever;

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

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

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

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

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

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

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

@@ -1,12 +0,0 @@
-import { type TSchema, type TNumberOptions } from './schema';
-export declare const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?";
-export type StaticNumber = number;
-/** Represents a Number type. */
-export interface TNumber extends TSchema {
-    '~kind': 'Number';
-    type: 'number';
-}
-/** Creates a Number type. */
-export declare function Number(options?: TNumberOptions): TNumber;
-/** Returns true if the given value is a TNumber. */
-export declare function IsNumber(value: unknown): value is TNumber;