typebox 1.0.33 → 1.0.34

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

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

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

@@ -1,20 +0,0 @@
-import { type StaticDirection } from './static';
-import { type TSchema, type TObjectOptions } from './schema';
-import { type TProperties, type TRequiredArray, type StaticProperties } from './properties';
-export type StaticObject<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, _This extends TProperties, Properties extends TProperties, Result = keyof Properties extends never ? object : StaticProperties<Stack, Direction, Context, Properties, Properties>> = Result;
-/** Represents an Object type. */
-export interface TObject<Properties extends TProperties = TProperties> extends TSchema {
-    '~kind': 'Object';
-    type: 'object';
-    properties: Properties;
-    required: TRequiredArray<Properties>;
-}
-/** Creates an Object type. */
-declare function _Object_<Properties extends TProperties>(properties: Properties, options?: TObjectOptions): TObject<Properties>;
-/** `[Json]` Creates an Object type */
-export declare var Object: typeof _Object_;
-/** Returns true if the given value is TObject. */
-export declare function IsObject(value: unknown): value is TObject;
-/** Extracts options from a TObject. */
-export declare function ObjectOptions(type: TObject): TObjectOptions;
-export {};

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

@@ -1,34 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Object = void 0;
-exports.IsObject = IsObject;
-exports.ObjectOptions = ObjectOptions;
-const index_1 = require("../../system/memory/index");
-const schema_1 = require("./schema");
-const properties_1 = require("./properties");
-// ------------------------------------------------------------------
-// Factory
-// ------------------------------------------------------------------
-/** Creates an Object type. */
-function _Object_(properties, options = {}) {
-    const requiredKeys = (0, properties_1.RequiredArray)(properties);
-    const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
-    return index_1.Memory.Create({ '~kind': 'Object' }, { type: 'object', ...required, properties }, options);
-}
-/** `[Json]` Creates an Object type */
-exports.Object = _Object_; // Required for CommonJS ES Interop
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/** Returns true if the given value is TObject. */
-function IsObject(value) {
-    return (0, schema_1.IsKind)(value, 'Object');
-}
-// ------------------------------------------------------------------
-// Options
-// ------------------------------------------------------------------
-/** Extracts options from a TObject. */
-function ObjectOptions(type) {
-    return index_1.Memory.Discard(type, ['~kind', 'type', 'properties', 'required']);
-}

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

@@ -1,17 +0,0 @@
-import { type TSchema } from './schema';
-import { type TUnknown } from './unknown';
-/** Represents a Generic parameter. */
-export interface TParameter<Name extends string = string, Extends extends TSchema = TSchema, Equals extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Parameter';
-    name: Name;
-    extends: Extends;
-    equals: Equals;
-}
-/** Creates a Parameter type. */
-export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends, equals: Equals): TParameter<Name, Extends, Equals>;
-/** Creates a Parameter type. */
-export declare function Parameter<Name extends string, Extends extends TSchema, Equals extends TSchema>(name: Name, extends_: Extends): TParameter<Name, Extends, Extends>;
-/** Creates a Parameter type. */
-export declare function Parameter<Name extends string>(name: Name): TParameter<Name, TUnknown, TUnknown>;
-/** Returns true if the given value is TParameter. */
-export declare function IsParameter(value: unknown): value is TParameter;

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

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

package/build/cjs/type/types/promise.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 StaticPromise<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = Promise<StaticType<Stack, Direction, Context, This, Type>>> = Result;
-/** Represents a Promise type. */
-export interface TPromise<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Promise';
-    type: 'promise';
-    item: Type;
-}
-/** Creates a Promise type. */
-export declare function Promise<Type extends TSchema>(item: Type, options?: TSchemaOptions): TPromise<Type>;
-/** Returns true if the given type is TPromise. */
-export declare function IsPromise(value: unknown): value is TPromise;
-/** Extracts options from a TPromise. */
-export declare function PromiseOptions(type: TPromise): TSchemaOptions;

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

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

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

@@ -1,42 +0,0 @@
-import { type StaticType, type StaticDirection, type StaticEvaluate } from './static';
-import { type TSchema } from './schema';
-import { type TOptional } from './_optional';
-import { type TReadonly } from './_readonly';
-import { type TUnionToTuple } from '../engine/helpers/union';
-type ReadonlyOptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
-    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? Key : never) : never;
-}[keyof Properties]> = Result;
-type ReadonlyKeys<Properties extends TProperties, Result extends PropertyKey = {
-    [Key in keyof Properties]: Properties[Key] extends TReadonly<TSchema> ? (Properties[Key] extends TOptional<Properties[Key]> ? never : Key) : never;
-}[keyof Properties]> = Result;
-type OptionalKeys<Properties extends TProperties, Result extends PropertyKey = {
-    [Key in keyof Properties]: Properties[Key] extends TOptional<TSchema> ? (Properties[Key] extends TReadonly<Properties[Key]> ? never : Key) : never;
-}[keyof Properties]> = Result;
-type RequiredKeys<Properties extends TProperties, Result extends PropertyKey = keyof Omit<Properties, ReadonlyOptionalKeys<Properties> | ReadonlyKeys<Properties> | OptionalKeys<Properties>>> = Result;
-type StaticPropertiesWithModifiers<Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown>> = StaticEvaluate<Readonly<Partial<Pick<PropertiesWithoutModifiers, ReadonlyOptionalKeys<Properties>>>> & Readonly<Pick<PropertiesWithoutModifiers, ReadonlyKeys<Properties>>> & Partial<Pick<PropertiesWithoutModifiers, OptionalKeys<Properties>>> & Required<Pick<PropertiesWithoutModifiers, RequiredKeys<Properties>>>>;
-type StaticPropertiesWithoutModifiers<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, Result extends Record<PropertyKey, unknown> = {
-    [Key in keyof Properties]: StaticType<Stack, Direction, Context, This, Properties[Key]>;
-}> = Result;
-export type StaticProperties<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Properties extends TProperties, PropertiesWithoutModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithoutModifiers<Stack, Direction, Context, This, Properties>, PropertiesWithModifiers extends Record<PropertyKey, unknown> = StaticPropertiesWithModifiers<Properties, PropertiesWithoutModifiers>, Result extends Record<PropertyKey, unknown> = {
-    [Key in keyof PropertiesWithModifiers]: PropertiesWithModifiers[Key];
-}> = Result;
-/** Represents a Record<PropertyKey, TSchema> structure. */
-export interface TProperties extends TSchema {
-    [key: PropertyKey]: TSchema;
-}
-/** Creates a RequiredArray derived from the given TProperties value. */
-export type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = {
-    [Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key];
-}, RequiredKeys extends string[] = TUnionToTuple<Extract<keyof RequiredProperties, string>>, Result extends string[] | undefined = RequiredKeys extends [] ? undefined : RequiredKeys> = Result;
-/** Creates a RequiredArray derived from the given TProperties value. */
-export declare function RequiredArray<Properties extends TProperties>(properties: Properties): TRequiredArray<Properties>;
-/** Extracts a tuple of keys from a TProperties value. */
-export type TPropertyKeys<Properties extends TProperties, Result extends string[] = TUnionToTuple<Extract<keyof Properties, string>>> = Result;
-/** Extracts a tuple of keys from a TProperties value. */
-export declare function PropertyKeys<Properties extends TProperties>(properties: Properties): TPropertyKeys<Properties>;
-type TPropertyValuesReduce<Properties extends TProperties, Keys extends string[], Result extends TSchema[] = []> = Keys extends [infer Left extends string, ...infer Right extends string[]] ? Left extends keyof Properties ? TPropertyValuesReduce<Properties, Right, [...Result, Properties[Left]]> : TPropertyValuesReduce<Properties, Right, Result> : Result;
-/** Extracts a tuple of property values from a TProperties value. */
-export type TPropertyValues<Properties extends TProperties, Keys extends string[] = TPropertyKeys<Properties>, Result extends TSchema[] = TPropertyValuesReduce<Properties, Keys>> = Result;
-/** Extracts a tuple of property values from a TProperties value. */
-export declare function PropertyValues<Properties extends TProperties>(properties: Properties): TPropertyValues<Properties>;
-export {};

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

@@ -1,21 +0,0 @@
-"use strict";
-// deno-lint-ignore-file no-array-constructor
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequiredArray = RequiredArray;
-exports.PropertyKeys = PropertyKeys;
-exports.PropertyValues = PropertyValues;
-const index_1 = require("../../guard/index");
-const _optional_1 = require("./_optional");
-/** Creates a RequiredArray derived from the given TProperties value. */
-function RequiredArray(properties) {
-    return index_1.Guard.Keys(properties).filter((key) => !(0, _optional_1.IsOptional)(properties[key]));
-}
-/** Extracts a tuple of keys from a TProperties value. */
-function PropertyKeys(properties) {
-    return index_1.Guard.Keys(properties);
-}
-/** Extracts a tuple of property values from a TProperties value. */
-function PropertyValues(properties) {
-    return index_1.Guard.Values(properties);
-}

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

@@ -1,44 +0,0 @@
-import { type TSchema, type TObjectOptions } from './schema';
-import { type StaticType, type StaticDirection } from './static';
-import { type TProperties } from './properties';
-import { type TInteger } from './integer';
-import { type TNumber } from './number';
-import { type TString } from './string';
-import { type TDeferred } from './deferred';
-import { type TInstantiate } from '../engine/instantiate';
-export type StaticRecord<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Key extends string, Value extends TSchema, StaticValue extends unknown = StaticType<Stack, Direction, Context, This, Value>, Result extends Record<PropertyKey, unknown> = (Key extends TStringKey ? Record<string, StaticValue> : Key extends TIntegerKey ? Record<number, StaticValue> : Key extends TNumberKey ? Record<number, StaticValue> : Record<string, StaticValue>)> = Result;
-export type TStringKey = typeof StringKey;
-export type TIntegerKey = typeof IntegerKey;
-export type TNumberKey = typeof NumberKey;
-export declare const IntegerKey = "^-?(?:0|[1-9][0-9]*)$";
-export declare const NumberKey = "^-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?$";
-export declare const StringKey = "^.*$";
-export interface TRecord<Key extends string = string, Value extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Record';
-    type: 'object';
-    patternProperties: {
-        [_ in Key]: Value;
-    };
-}
-/** Represents a deferred Record action. */
-export type TRecordDeferred<Key extends TSchema, Value extends TSchema> = (TDeferred<'Record', [Key, Value]>);
-/** Represents a deferred Record action. */
-export declare function RecordDeferred<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordDeferred<Key, Value>;
-export type TRecordConstruct<Key extends TSchema, Value extends TSchema> = (TInstantiate<{}, TRecordDeferred<Key, Value>>);
-export declare function RecordConstruct<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
-/** Creates a Record type. */
-export declare function Record<Key extends TSchema, Value extends TSchema>(key: Key, value: Value, options?: TObjectOptions): TRecordConstruct<Key, Value>;
-/** Creates a Record type from regular expression pattern. */
-export declare function RecordFromPattern<Pattern extends string, Value extends TSchema>(key: Pattern, value: Value): TRecord<Pattern, Value>;
-/** Returns the raw string pattern used for the Record key  */
-export type TRecordPattern<Type extends TRecord, Result extends string = Extract<keyof Type['patternProperties'], string>> = Result;
-/** Returns the raw string pattern used for the Record key  */
-export declare function RecordPattern<Type extends TRecord>(type: Type): TRecordPattern<Type>;
-/** Returns the Record key as a TypeBox type  */
-export type TRecordKey<Type extends TRecord, Pattern extends string = TRecordPattern<Type>, Result extends TSchema = (Pattern extends typeof IntegerKey ? TInteger : Pattern extends typeof NumberKey ? TNumber : TString)> = Result;
-/** Returns the Record key as a TypeBox type  */
-export declare function RecordKey<Type extends TRecord>(type: Type): TRecordKey<Type>;
-export type TRecordValue<Type extends TRecord, Result extends TSchema = Type['patternProperties'][TRecordPattern<Type>]> = Result;
-export declare function RecordValue<Type extends TRecord>(type: Type): TRecordValue<Type>;
-export declare function IsRecord(value: unknown): value is TRecord;
-export declare function RecordOptions(type: TRecord): TObjectOptions;

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

@@ -1,73 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StringKey = exports.NumberKey = exports.IntegerKey = void 0;
-exports.RecordDeferred = RecordDeferred;
-exports.RecordConstruct = RecordConstruct;
-exports.Record = Record;
-exports.RecordFromPattern = RecordFromPattern;
-exports.RecordPattern = RecordPattern;
-exports.RecordKey = RecordKey;
-exports.RecordValue = RecordValue;
-exports.IsRecord = IsRecord;
-exports.RecordOptions = RecordOptions;
-const index_1 = require("../../system/memory/index");
-const index_2 = require("../../guard/index");
-const schema_1 = require("./schema");
-const integer_1 = require("./integer");
-const number_1 = require("./number");
-const string_1 = require("./string");
-const deferred_1 = require("./deferred");
-const instantiate_1 = require("../engine/instantiate");
-const record_create_1 = require("../engine/record/record-create");
-exports.IntegerKey = `^${integer_1.IntegerPattern}$`;
-exports.NumberKey = `^${number_1.NumberPattern}$`;
-exports.StringKey = `^${string_1.StringPattern}$`;
-/** Represents a deferred Record action. */
-function RecordDeferred(key, value, options = {}) {
-    return (0, deferred_1.Deferred)('Record', [key, value], options);
-}
-function RecordConstruct(key, value, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, RecordDeferred(key, value, options));
-}
-// -------------------------------------------------------------------
-// Factory
-// -------------------------------------------------------------------
-/** Creates a Record type. */
-function Record(key, value, options = {}) {
-    return RecordConstruct(key, value, options);
-}
-// -------------------------------------------------------------------
-// FromPattern
-// -------------------------------------------------------------------
-/** Creates a Record type from regular expression pattern. */
-function RecordFromPattern(key, value) {
-    return (0, record_create_1.CreateRecord)(key, value);
-}
-/** Returns the raw string pattern used for the Record key  */
-function RecordPattern(type) {
-    return index_2.Guard.Keys(type.patternProperties)[0];
-}
-/** Returns the Record key as a TypeBox type  */
-function RecordKey(type) {
-    const pattern = RecordPattern(type);
-    const result = (index_2.Guard.IsEqual(pattern, exports.IntegerKey) ? (0, integer_1.Integer)() :
-        index_2.Guard.IsEqual(pattern, exports.NumberKey) ? (0, number_1.Number)() :
-            (0, string_1.String)());
-    return result;
-}
-function RecordValue(type) {
-    return type.patternProperties[RecordPattern(type)];
-}
-// -------------------------------------------------------------------
-// Guard
-// -------------------------------------------------------------------
-function IsRecord(value) {
-    return (0, schema_1.IsKind)(value, 'Record');
-}
-// -------------------------------------------------------------------
-// Options
-// -------------------------------------------------------------------
-function RecordOptions(type) {
-    return index_1.Memory.Discard(type, ['~kind', 'type', 'patternProperties']);
-}

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

@@ -1,19 +0,0 @@
-import { type StaticType, type StaticDirection } from './static';
-import { type TSchema, type TSchemaOptions } from './schema';
-import { type TProperties } from './properties';
-import { type TObject } from './object';
-import { type TUnknown } from './unknown';
-type CyclicStackLength<Stack extends unknown[], MaxLength extends number, Buffer extends unknown[] = []> = (Stack extends [infer Left, ...infer Right] ? Buffer['length'] extends MaxLength ? false : CyclicStackLength<Right, MaxLength, [...Buffer, Left]> : true);
-type CyclicGuard<Stack extends unknown[], Ref extends string> = (Ref extends Stack[number] ? CyclicStackLength<Stack, 2> : true);
-type StaticGuardedRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, Type extends TSchema> = (CyclicGuard<Stack, Ref> extends true ? StaticType<[...Stack, Ref], Direction, Context, This, Type> : any);
-export type StaticRef<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Ref extends string, Target extends TSchema = Ref extends keyof Context ? Context[Ref] : TUnknown, Result extends unknown = Target extends TObject ? StaticType<[], Direction, Context, This, Target> : StaticGuardedRef<Stack, Direction, Context, This, Ref, Target>> = Result;
-/** Represents a type reference. */
-export interface TRef<Ref extends string = string> extends TSchema {
-    '~kind': 'Ref';
-    $ref: Ref;
-}
-/** Creates a Ref type. */
-export declare function Ref<Ref extends string>(ref: Ref, options?: TSchemaOptions): TRef<Ref>;
-/** Returns true if the given value is TRef. */
-export declare function IsRef(value: unknown): value is TRef;
-export {};

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

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

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

@@ -1,11 +0,0 @@
-import { type TSchema } from '../types/schema';
-/** Represents a Rest instruction. */
-export interface TRest<Type extends TSchema = TSchema> extends TSchema {
-    '~kind': 'Rest';
-    type: 'rest';
-    items: Type;
-}
-/** Creates a Rest instruction type. */
-export declare function Rest<Type extends TSchema>(type: Type): TRest<Type>;
-/** Returns true if the given value is TRest. */
-export declare function IsRest(value: unknown): value is TRest;

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

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

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

@@ -1,199 +0,0 @@
-export interface TSchema {
-}
-export declare function IsKind<Kind extends string>(value: unknown, kind: Kind): value is {
-    ['~kind']: Kind;
-};
-export declare function IsSchema(value: unknown): value is TSchema;
-export interface TSchemaOptions {
-    /**
-     * Allows for additional, unlisted properties to be included, typically for extensibility.
-     */
-    [key: PropertyKey]: unknown;
-    /**
-     * Specifies the URI of a JSON Schema that the current schema adheres to.
-     */
-    $schema?: string;
-    /**
-     * A URI that serves as a unique identifier for the schema.
-     */
-    $id?: string;
-    /**
-     * A short explanation about the purpose of the data described by the schema.
-     */
-    title?: string;
-    /**
-     * A detailed explanation of the data described by the schema.
-     */
-    description?: string;
-    /**
-     * A default value for the data, used when no value is provided.
-     */
-    default?: unknown;
-    /**
-     * Provides one or more examples of valid data conforming to the schema.
-     */
-    examples?: unknown;
-    /**
-     * Indicates that the data should only be readable and not modified.
-     */
-    readOnly?: boolean;
-    /**
-     * Indicates that the data should only be writable and not read back.
-     */
-    writeOnly?: boolean;
-    /**
-     * A schema to apply conditionally: if the data validates against this schema, 'then' applies.
-     */
-    if?: TSchema;
-    /**
-     * A schema to apply if the data validates against the 'if' schema.
-     */
-    then?: TSchema;
-    /**
-     * A schema to apply if the data does not validate against the 'if' schema.
-     */
-    else?: TSchema;
-}
-export interface TObjectOptions extends TSchemaOptions {
-    /**
-     * Defines whether additional properties are allowed beyond those explicitly defined in `properties`.
-     */
-    additionalProperties?: TSchema | boolean;
-    /**
-     * The minimum number of properties required in the object.
-     */
-    minProperties?: number;
-    /**
-     * The maximum number of properties allowed in the object.
-     */
-    maxProperties?: number;
-    /**
-     * Defines conditional requirements for properties.
-     */
-    dependencies?: Record<string, boolean | TSchema | string[]>;
-    /**
-     * Specifies properties that *must* be present if a given property is present.
-     */
-    dependentRequired?: Record<string, string[]>;
-    /**
-     * Defines schemas that apply if a specific property is present.
-     */
-    dependentSchemas?: Record<string, TSchema>;
-    /**
-     * Maps regular expressions to schemas properties matching a pattern must validate against the schema.
-     */
-    patternProperties?: Record<string, TSchema>;
-    /**
-     * A schema that all property names within the object must validate against.
-     */
-    propertyNames?: TSchema;
-}
-export interface TArrayOptions extends TSchemaOptions {
-    /**
-     * The minimum number of items allowed in the array.
-     */
-    minItems?: number;
-    /**
-     * The maximum number of items allowed in the array.
-     */
-    maxItems?: number;
-    /**
-     * A schema that at least one item in the array must validate against.
-     */
-    contains?: TSchema;
-    /**
-     * The minimum number of array items that must validate against the `contains` schema.
-     */
-    minContains?: number;
-    /**
-     * The maximum number of array items that may validate against the `contains` schema.
-     */
-    maxContains?: number;
-    /**
-     * An array of schemas, where each schema in `prefixItems` validates against items at corresponding positions from the beginning of the array.
-     */
-    prefixItems?: TSchema[];
-    /**
-     * If `true`, all items in the array must be unique.
-     */
-    uniqueItems?: boolean;
-}
-export interface TTupleOptions extends TArrayOptions {
-    /**
-     * A schema to apply to any items in the array that were not validated by `prefixItems` or `items`. If `false`, no additional items are allowed.
-     */
-    unevaluatedItems?: TSchema | boolean;
-}
-export interface TIntersectOptions extends TSchemaOptions {
-    /**
-     * A schema to apply to any properties in the object that were not validated by other keywords like `properties`, `patternProperties`, or `additionalProperties`. If `false`, no additional properties are allowed.
-     */
-    unevaluatedProperties?: TSchema | boolean;
-}
-export interface TNumberOptions extends TSchemaOptions {
-    /**
-     * Specifies an exclusive upper limit for the number (number must be less than this value).
-     */
-    exclusiveMaximum?: number | bigint;
-    /**
-     * Specifies an exclusive lower limit for the number (number must be greater than this value).
-     */
-    exclusiveMinimum?: number | bigint;
-    /**
-     * Specifies an inclusive upper limit for the number (number must be less than or equal to this value).
-     */
-    maximum?: number | bigint;
-    /**
-     * Specifies an inclusive lower limit for the number (number must be greater than or equal to this value).
-     */
-    minimum?: number | bigint;
-    /**
-     * Specifies that the number must be a multiple of this value.
-     */
-    multipleOf?: number | bigint;
-}
-export type TFormat = 'date-time' | 'date' | 'duration' | 'email' | 'hostname' | 'idn-email' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'iri-reference' | 'iri' | 'json-pointer-uri-fragment' | 'json-pointer' | 'json-string' | 'regex' | 'relative-json-pointer' | 'time' | 'uri-reference' | 'uri-template' | 'url' | 'uuid' | ({} & string);
-export interface TStringOptions extends TSchemaOptions {
-    /**
-     * Specifies the expected string format.
-     *
-     * Common values include:
-     * - `base64` – Base64-encoded string.
-     * - `date-time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date-time format.
-     * - `date` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date (YYYY-MM-DD).
-     * - `duration` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) duration format.
-     * - `email` – RFC 5321/5322 compliant email address.
-     * - `hostname` – RFC 1034/1035 compliant host name.
-     * - `idn-email` – Internationalized email address.
-     * - `idn-hostname` – Internationalized host name.
-     * - `ipv4` – IPv4 address.
-     * - `ipv6` – IPv6 address.
-     * - `iri` / `iri-reference` – Internationalized Resource Identifier.
-     * - `json-pointer` / `json-pointer-uri-fragment` – JSON Pointer format.
-     * - `json-string` – String containing valid JSON.
-     * - `regex` – Regular expression syntax.
-     * - `relative-json-pointer` – Relative JSON Pointer format.
-     * - `time` – [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) time (HH:MM:SS).
-     * - `uri-reference` / `uri-template` – URI reference or template.
-     * - `url` – Web URL format.
-     * - `uuid` – RFC 4122 UUID string.
-     *
-     * May also be a custom format string.
-     */
-    format?: TFormat;
-    /**
-     * Specifies the minimum number of characters allowed in the string.
-     * Must be a non-negative integer.
-     */
-    minLength?: number;
-    /**
-     * Specifies the maximum number of characters allowed in the string.
-     * Must be a non-negative integer.
-     */
-    maxLength?: number;
-    /**
-     * Specifies a regular expression pattern that the string value must match.
-     * Can be provided as a string (ECMA-262 regex syntax) or a `RegExp` object.
-     */
-    pattern?: string | RegExp;
-}