typebox 1.0.33 → 1.0.34

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

@@ -1,19 +0,0 @@
-"use strict";
-// deno-lint-ignore-file
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IsKind = IsKind;
-exports.IsSchema = IsSchema;
-const index_1 = require("../../guard/index");
-// ------------------------------------------------------------------
-// Kind
-// ------------------------------------------------------------------
-function IsKind(value, kind) {
-    return index_1.Guard.IsObject(value) && index_1.Guard.HasPropertyKey(value, '~kind') && index_1.Guard.IsEqual(value["~kind"], kind);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-function IsSchema(value) {
-    return index_1.Guard.IsObject(value);
-}

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

@@ -1,47 +0,0 @@
-import type { StaticCodec, TCodec } from './_codec';
-import type { StaticAny, TAny } from './any';
-import type { StaticArray, TArray } from './array';
-import type { StaticAsyncIterator, TAsyncIterator } from './async-iterator';
-import type { StaticBigInt, TBigInt } from './bigint';
-import type { StaticBoolean, TBoolean } from './boolean';
-import type { StaticConstructor, TConstructor } from './constructor';
-import type { StaticCyclic, TCyclic } from './cyclic';
-import type { StaticEnum, TEnum, TEnumValue } from './enum';
-import type { StaticFunction, TFunction } from './function';
-import type { StaticInteger, TInteger } from './integer';
-import type { StaticIntersect, TIntersect } from './intersect';
-import type { StaticIterator, TIterator } from './iterator';
-import type { StaticLiteral, TLiteral, TLiteralValue } from './literal';
-import type { StaticNever, TNever } from './never';
-import type { StaticNull, TNull } from './null';
-import type { StaticNumber, TNumber } from './number';
-import type { StaticObject, TObject } from './object';
-import type { StaticPromise, TPromise } from './promise';
-import type { TProperties } from './properties';
-import type { StaticRecord, TRecord } from './record';
-import type { StaticRef, TRef } from './ref';
-import type { TSchema } from './schema';
-import type { StaticString, TString } from './string';
-import type { StaticSymbol, TSymbol } from './symbol';
-import type { StaticTemplateLiteral, TTemplateLiteral } from './template-literal';
-import type { StaticThis, TThis } from './this';
-import type { StaticTuple, TTuple } from './tuple';
-import type { StaticUndefined, TUndefined } from './undefined';
-import type { StaticUnion, TUnion } from './union';
-import type { StaticUnknown, TUnknown } from './unknown';
-import type { StaticUnsafe, TUnsafe } from './unsafe';
-import type { StaticVoid, TVoid } from './void';
-import type { XStatic } from '../../schema/types/static';
-export type StaticEvaluate<T> = {
-    [K in keyof T]: T[K];
-} & {};
-export type StaticDirection = 'Encode' | 'Decode';
-export type StaticType<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema> = (Type extends TCodec<infer Type extends TSchema, infer Decoded extends unknown> ? StaticCodec<Stack, Direction, Context, This, Type, Decoded> : Type extends TAny ? StaticAny : Type extends TArray<infer Type extends TSchema> ? StaticArray<Stack, Direction, Context, This, Type> : Type extends TAsyncIterator<infer Type extends TSchema> ? StaticAsyncIterator<Stack, Direction, Context, This, Type> : Type extends TBigInt ? StaticBigInt : Type extends TBoolean ? StaticBoolean : Type extends TConstructor<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticConstructor<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TEnum<infer Values extends TEnumValue[]> ? StaticEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? StaticFunction<Stack, Direction, Context, This, Parameters, ReturnType> : Type extends TInteger ? StaticInteger : Type extends TIntersect<infer Types extends TSchema[]> ? StaticIntersect<Stack, Direction, Context, This, Types> : Type extends TIterator<infer Types extends TSchema> ? StaticIterator<Stack, Direction, Context, This, Types> : Type extends TLiteral<infer Value extends TLiteralValue> ? StaticLiteral<Value> : Type extends TNever ? StaticNever : Type extends TNull ? StaticNull : Type extends TNumber ? StaticNumber : Type extends TObject<infer Properties extends TProperties> ? StaticObject<Stack, Direction, Context, This, Properties> : Type extends TPromise<infer Type extends TSchema> ? StaticPromise<Stack, Direction, Context, This, Type> : Type extends TRecord<infer Key extends string, infer Value extends TSchema> ? StaticRecord<Stack, Direction, Context, This, Key, Value> : Type extends TCyclic<infer Defs extends TProperties, infer Ref extends string> ? StaticCyclic<Stack, Direction, Context, This, Defs, Ref> : Type extends TRef<infer Ref extends string> ? StaticRef<Stack, Direction, Context, This, Ref> : Type extends TString ? StaticString : Type extends TSymbol ? StaticSymbol : Type extends TTemplateLiteral<infer Pattern extends string> ? StaticTemplateLiteral<Pattern> : Type extends TThis ? StaticThis<Stack, Direction, Context, This> : Type extends TTuple<infer Types extends TSchema[]> ? StaticTuple<Stack, Direction, Context, This, Types> : Type extends TUndefined ? StaticUndefined : Type extends TUnion<infer Types extends TSchema[]> ? StaticUnion<Stack, Direction, Context, This, Types> : Type extends TUnknown ? StaticUnknown : Type extends TUnsafe<infer Type extends unknown> ? StaticUnsafe<Type> : Type extends TVoid ? StaticVoid : XStatic<Type>);
-/** Infers a static type from a TypeBox type using Parse logic. */
-export type StaticParse<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Decode', Context, {}, Type>;
-/** Infers a static type from a TypeBox type using Decode logic. */
-export type StaticDecode<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Decode', Context, {}, Type>;
-/** Infers a static type from a TypeBox type using Encode logic. */
-export type StaticEncode<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Encode', Context, {}, Type>;
-/** Infers a static type from a TypeBox type. */
-export type Static<Type extends TSchema, Context extends TProperties = {}> = StaticType<[], 'Encode', Context, {}, Type>;

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

@@ -1,4 +0,0 @@
-"use strict";
-// deno-lint-ignore-file
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,12 +0,0 @@
-import { type TSchema, type TStringOptions } from './schema';
-export declare const StringPattern = ".*";
-export type StaticString = string;
-/** Represents a String type. */
-export interface TString extends TSchema {
-    '~kind': 'String';
-    type: 'string';
-}
-/** Creates a String type. */
-export declare function String(options?: TStringOptions): TString;
-/** Returns true if the given value is TString. */
-export declare function IsString(value: unknown): value is TString;

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

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

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

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

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

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

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

@@ -1,24 +0,0 @@
-import { type TSchema, type TSchemaOptions } from './schema';
-import { type TDeferred } from './deferred';
-import { type TParseTemplateIntoTypes } from '../engine/patterns/template';
-import { type TInstantiate } from '../engine/instantiate';
-import { type TTemplateLiteralStatic } from '../engine/template-literal/static';
-export type StaticTemplateLiteral<Pattern extends string> = (TTemplateLiteralStatic<Pattern>);
-/** Represents a TemplateLiteral type. */
-export interface TTemplateLiteral<Pattern extends string = string> extends TSchema {
-    '~kind': 'TemplateLiteral';
-    type: 'string';
-    pattern: Pattern;
-}
-/** Creates a deferred TemplateLiteral action. */
-export type TTemplateLiteralDeferred<Types extends TSchema[]> = (TDeferred<'TemplateLiteral', [Types]>);
-/** Creates a deferred TemplateLiteral action. */
-export declare function TemplateLiteralDeferred<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralDeferred<Types>;
-export type TTemplateLiteralConstruct<Types extends TSchema[]> = (TInstantiate<{}, TTemplateLiteralDeferred<Types>>);
-export declare function TemplateLiteralConstruct<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralConstruct<Types>;
-/** Creates a TemplateLiteral type. */
-export declare function TemplateLiteral<Template extends string>(template: Template, options?: TSchemaOptions): TTemplateLiteralConstruct<TParseTemplateIntoTypes<Template>>;
-/** Creates a TemplateLiteral type. */
-export declare function TemplateLiteral<Types extends TSchema[]>(types: [...Types], options?: TSchemaOptions): TTemplateLiteralConstruct<Types>;
-/** Returns true if the given value is TTemplateLiteral. */
-export declare function IsTemplateLiteral(value: unknown): value is TTemplateLiteral;

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

@@ -1,32 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-// deno-lint-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TemplateLiteralDeferred = TemplateLiteralDeferred;
-exports.TemplateLiteralConstruct = TemplateLiteralConstruct;
-exports.TemplateLiteral = TemplateLiteral;
-exports.IsTemplateLiteral = IsTemplateLiteral;
-const index_1 = require("../../guard/index");
-const schema_1 = require("./schema");
-const deferred_1 = require("./deferred");
-const template_1 = require("../engine/patterns/template");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred TemplateLiteral action. */
-function TemplateLiteralDeferred(types, options = {}) {
-    return (0, deferred_1.Deferred)('TemplateLiteral', [types], options);
-}
-function TemplateLiteralConstruct(types, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, TemplateLiteralDeferred(types, options));
-}
-/** Creates a TemplateLiteral type. */
-function TemplateLiteral(input, options = {}) {
-    const types = index_1.Guard.IsString(input) ? (0, template_1.ParseTemplateIntoTypes)(input) : input;
-    return TemplateLiteralConstruct(types, options);
-}
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TTemplateLiteral. */
-function IsTemplateLiteral(value) {
-    return (0, schema_1.IsKind)(value, 'TemplateLiteral');
-}

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

@@ -1,14 +0,0 @@
-import { type StaticType, type StaticDirection } from './static';
-import { type TSchema, type TSchemaOptions } from './schema';
-import { type TObject } from './object';
-import { type TProperties } from './properties';
-export type StaticThis<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties> = (StaticType<Stack, Direction, Context, This, TObject<This>>);
-/** Represents a This type. */
-export interface TThis extends TSchema {
-    '~kind': 'This';
-    $ref: '#';
-}
-/** Creates a This type. */
-export declare function This(options?: TSchemaOptions): TThis;
-/** Returns true if the given value is TThis. */
-export declare function IsThis(value: unknown): value is TThis;

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

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

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

@@ -1,37 +0,0 @@
-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

@@ -1,30 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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

@@ -1,15 +0,0 @@
-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

@@ -1,29 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,22 +0,0 @@
-"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

@@ -1,11 +0,0 @@
-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

@@ -1,21 +0,0 @@
-"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

@@ -1,71 +0,0 @@
-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';