@sinclair/typebox 0.32.0-dev-3 → 0.32.0-dev-5

package/esm/type/tuple/tuple.mjs

@@ -1,38 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import { CloneRest } from '../clone/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[Json]` Creates a Tuple type */
-export function Tuple(items, options = {}) {
-    // return TupleResolver.Resolve(T)
-    const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
-    // prettier-ignore
-    return (items.length > 0 ?
-        { ...options, [Kind]: 'Tuple', type: 'array', items: CloneRest(items), additionalItems, minItems, maxItems } :
-        { ...options, [Kind]: 'Tuple', type: 'array', minItems, maxItems });
-}

package/esm/type/type/index.d.mts

@@ -1,6 +0,0 @@
-export { JsonTypeBuilder } from './json.mjs';
-import { JavaScriptTypeBuilder } from './javascript.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-declare const Type: JavaScriptTypeBuilder;
-export { JavaScriptTypeBuilder };
-export { Type };

package/esm/type/type/index.mjs

@@ -1,40 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-// ------------------------------------------------------------------
-// JsonTypeBuilder
-// ------------------------------------------------------------------
-export { JsonTypeBuilder } from './json.mjs';
-// ------------------------------------------------------------------
-// JavaScriptTypeBuilder
-// ------------------------------------------------------------------
-import * as TypeBuilder from './type.mjs';
-import { JavaScriptTypeBuilder } from './javascript.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-const Type = TypeBuilder;
-export { JavaScriptTypeBuilder };
-export { Type };

package/esm/type/type/javascript.d.mts

@@ -1,58 +0,0 @@
-import { JsonTypeBuilder } from './json.mjs';
-import { type TAsyncIterator } from '../async-iterator/index.mjs';
-import { type TAwaited } from '../awaited/index.mjs';
-import { type TBigInt, type BigIntOptions } from '../bigint/index.mjs';
-import { type TConstructor } from '../constructor/index.mjs';
-import { type TConstructorParameters } from '../constructor-parameters/index.mjs';
-import { type TDate, type DateOptions } from '../date/index.mjs';
-import { type TFunction } from '../function/index.mjs';
-import { type TInstanceType } from '../instance-type/index.mjs';
-import { type TIterator } from '../iterator/index.mjs';
-import { type TParameters } from '../parameters/index.mjs';
-import { type TPromise } from '../promise/index.mjs';
-import { type TRegExp } from '../regexp/index.mjs';
-import { type TReturnType } from '../return-type/index.mjs';
-import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
-import { type TSymbol } from '../symbol/index.mjs';
-import { type TUint8Array, type Uint8ArrayOptions } from '../uint8array/index.mjs';
-import { type TUndefined } from '../undefined/index.mjs';
-import { type TVoid } from '../void/index.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-export declare class JavaScriptTypeBuilder extends JsonTypeBuilder {
-    /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator<T extends TSchema>(items: T, options?: SchemaOptions): TAsyncIterator<T>;
-    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited<T extends TSchema>(schema: T, options?: SchemaOptions): TAwaited<T>;
-    /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options?: BigIntOptions): TBigInt;
-    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
-    /** `[JavaScript]` Creates a Constructor type */
-    Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
-    /** `[JavaScript]` Creates a Date type */
-    Date(options?: DateOptions): TDate;
-    /** `[JavaScript]` Creates a Function type */
-    Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
-    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;
-    /** `[JavaScript]` Creates an Iterator type */
-    Iterator<T extends TSchema>(items: T, options?: SchemaOptions): TIterator<T>;
-    /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;
-    /** `[JavaScript]` Creates a Promise type */
-    Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;
-    /** `[JavaScript]` Creates a String type from a Regular Expression pattern */
-    RegExp(pattern: string, options?: SchemaOptions): TRegExp;
-    /** `[JavaScript]` Creates a String type from a Regular Expression */
-    RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;
-    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;
-    /** `[JavaScript]` Creates a Symbol type */
-    Symbol(options?: SchemaOptions): TSymbol;
-    /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options?: SchemaOptions): TUndefined;
-    /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options?: Uint8ArrayOptions): TUint8Array;
-    /** `[JavaScript]` Creates a Void type */
-    Void(options?: SchemaOptions): TVoid;
-}

package/esm/type/type/javascript.mjs

@@ -1,116 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import { JsonTypeBuilder } from './json.mjs';
-import { AsyncIterator } from '../async-iterator/index.mjs';
-import { Awaited } from '../awaited/index.mjs';
-import { BigInt } from '../bigint/index.mjs';
-import { Constructor } from '../constructor/index.mjs';
-import { ConstructorParameters } from '../constructor-parameters/index.mjs';
-import { Date } from '../date/index.mjs';
-import { Function } from '../function/index.mjs';
-import { InstanceType } from '../instance-type/index.mjs';
-import { Iterator } from '../iterator/index.mjs';
-import { Parameters } from '../parameters/index.mjs';
-import { Promise } from '../promise/index.mjs';
-import { RegExp } from '../regexp/index.mjs';
-import { ReturnType } from '../return-type/index.mjs';
-import { Symbol } from '../symbol/index.mjs';
-import { Uint8Array } from '../uint8array/index.mjs';
-import { Undefined } from '../undefined/index.mjs';
-import { Void } from '../void/index.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-export class JavaScriptTypeBuilder extends JsonTypeBuilder {
-    /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options = {}) {
-        return AsyncIterator(items, options);
-    }
-    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options = {}) {
-        return Awaited(schema, options);
-    }
-    /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options = {}) {
-        return BigInt(options);
-    }
-    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options = {}) {
-        return ConstructorParameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Constructor type */
-    Constructor(parameters, returns, options) {
-        return Constructor(parameters, returns, options);
-    }
-    /** `[JavaScript]` Creates a Date type */
-    Date(options = {}) {
-        return Date(options);
-    }
-    /** `[JavaScript]` Creates a Function type */
-    Function(parameters, returns, options) {
-        return Function(parameters, returns, options);
-    }
-    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options = {}) {
-        return InstanceType(schema, options);
-    }
-    /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options = {}) {
-        return Iterator(items, options);
-    }
-    /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options = {}) {
-        return Parameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options = {}) {
-        return Promise(item, options);
-    }
-    /** `[JavaScript]` Creates a String type */
-    RegExp(unresolved, options = {}) {
-        return RegExp(unresolved, options);
-    }
-    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(schema, options = {}) {
-        return ReturnType(schema, options);
-    }
-    /** `[JavaScript]` Creates a Symbol type */
-    Symbol(options) {
-        return Symbol(options);
-    }
-    /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options = {}) {
-        return Undefined(options);
-    }
-    /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options = {}) {
-        return Uint8Array(options);
-    }
-    /** `[JavaScript]` Creates a Void type */
-    Void(options = {}) {
-        return Void(options);
-    }
-}

package/esm/type/type/json.d.mts

@@ -1,139 +0,0 @@
-import { type TAny } from '../any/index.mjs';
-import { type TArray, type ArrayOptions } from '../array/index.mjs';
-import { type TBoolean } from '../boolean/index.mjs';
-import { type TComposite } from '../composite/index.mjs';
-import { type TConst } from '../const/index.mjs';
-import { type TDeref } from '../deref/index.mjs';
-import { type TEnum, type TEnumKey, type TEnumValue } from '../enum/index.mjs';
-import { type TExclude } from '../exclude/index.mjs';
-import { type TExtends } from '../extends/index.mjs';
-import { type TExtract } from '../extract/index.mjs';
-import { TIndex, type IndexedKeyResolve } from '../indexed/index.mjs';
-import { type IntegerOptions, type TInteger } from '../integer/index.mjs';
-import { type IntersectOptions, type IntersectResolve } from '../intersect/index.mjs';
-import { type TCapitalize, type TUncapitalize, type TLowercase, type TUppercase } from '../intrinsic/index.mjs';
-import { type TKeyOf } from '../keyof/index.mjs';
-import { type TLiteral, type TLiteralValue } from '../literal/index.mjs';
-import { type TNever } from '../never/index.mjs';
-import { type TNot } from '../not/index.mjs';
-import { type TNull } from '../null/index.mjs';
-import { type TNumber, type NumberOptions } from '../number/index.mjs';
-import { type TObject, type TProperties, type ObjectOptions } from '../object/index.mjs';
-import { type TOmit } from '../omit/index.mjs';
-import { type TOptional } from '../optional/index.mjs';
-import { type TPartial } from '../partial/index.mjs';
-import { type TPick } from '../pick/index.mjs';
-import { type TReadonly } from '../readonly/index.mjs';
-import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
-import { type RecordResolve } from '../record/index.mjs';
-import { type TRecursive, type TThis } from '../recursive/index.mjs';
-import { type TRef } from '../ref/index.mjs';
-import { type TRequired } from '../required/index.mjs';
-import { type TRest } from '../rest/index.mjs';
-import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
-import { type TString, type StringOptions } from '../string/index.mjs';
-import { type TTemplateLiteral, type TTemplateLiteralKind, type TemplateLiteralSyntax } from '../template-literal/index.mjs';
-import { TransformDecodeBuilder } from '../transform/index.mjs';
-import { type TTuple } from '../tuple/index.mjs';
-import { type UnionResolve } from '../union/index.mjs';
-import { type TUnknown } from '../unknown/index.mjs';
-import { type TUnsafe, type UnsafeOptions } from '../unsafe/index.mjs';
-/** Json Type Builder with Static Resolution for TypeScript */
-export declare class JsonTypeBuilder {
-    /** `[Json]` Omits compositing symbols from this schema */
-    Strict<T extends TSchema>(schema: T): T;
-    /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional<T extends TSchema>(schema: T): TReadonlyOptional<T>;
-    /** `[Json]` Creates a Readonly property */
-    Readonly<T extends TSchema>(schema: T): TReadonly<T>;
-    /** `[Json]` Creates an Optional property */
-    Optional<T extends TSchema>(schema: T): TOptional<T>;
-    /** `[Json]` Creates an Any type */
-    Any(options?: SchemaOptions): TAny;
-    /** `[Json]` Creates an Array type */
-    Array<T extends TSchema>(schema: T, options?: ArrayOptions): TArray<T>;
-    /** `[Json]` Creates a Boolean type */
-    Boolean(options?: SchemaOptions): TBoolean;
-    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TCapitalize<T>;
-    /** `[Json]` Creates a Composite object type */
-    Composite<T extends TObject[]>(objects: [...T], options?: ObjectOptions): TComposite<T>;
-    /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const</* const (not supported in 4.0) */ T>(value: T, options?: SchemaOptions): TConst<T>;
-    /** `[Json]` Creates a dereferenced type */
-    Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-    /** `[Json]` Creates a Enum type */
-    Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;
-    /** `[Json]` Creates a Conditional type */
-    Extends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema>(left: L, right: R, trueType: T, falseType: U, options?: SchemaOptions): TExtends<L, R, T, U>;
-    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
-    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract<L extends TSchema, R extends TSchema>(type: L, union: R, options?: SchemaOptions): TExtract<L, R>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TIndex<T, I>;
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TIndex<T, K>;
-    /** `[Json]` Creates an Integer type */
-    Integer(options?: IntegerOptions): TInteger;
-    /** `[Json]` Creates an Intersect type */
-    Intersect<T extends TSchema[]>(T: [...T], options?: IntersectOptions): IntersectResolve<T>;
-    /** `[Json]` Creates a KeyOf type */
-    KeyOf<T extends TSchema>(schema: T, options?: SchemaOptions): TKeyOf<T>;
-    /** `[Json]` Creates a Literal type */
-    Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;
-    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase<T extends TSchema>(schema: T, options?: SchemaOptions): TLowercase<T>;
-    /** `[Json]` Creates a Never type */
-    Never(options?: SchemaOptions): TNever;
-    /** `[Json]` Creates a Not type */
-    Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;
-    /** `[Json]` Creates a Null type */
-    Null(options?: SchemaOptions): TNull;
-    /** `[Json]` Creates a Number type */
-    Number(options?: NumberOptions): TNumber;
-    /** `[Json]` Creates an Object type */
-    Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial<T extends TSchema>(schema: T, options?: ObjectOptions): TPartial<T>;
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
-    /** `[Json]` Creates a Record type */
-    Record<K extends TSchema, T extends TSchema>(key: K, schema: T, options?: ObjectOptions): RecordResolve<K, T>;
-    /** `[Json]` Creates a Recursive type */
-    Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;
-    /** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-    Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
-    /** `[Json]` Creates a Ref type. */
-    Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;
-    /** `[Json]` Constructs a type where all properties are required */
-    Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
-    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest<T extends TSchema>(schema: T): TRest<T>;
-    /** `[Json]` Creates a String type */
-    String(options?: StringOptions): TString;
-    /** `[Json]` Creates a TemplateLiteral type from template dsl string */
-    TemplateLiteral<T extends string>(syntax: T, options?: SchemaOptions): TemplateLiteralSyntax<T>;
-    /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral<T extends TTemplateLiteralKind[]>(kinds: [...T], options?: SchemaOptions): TTemplateLiteral<T>;
-    /** `[Json]` Creates a Transform type */
-    Transform<I extends TSchema>(schema: I): TransformDecodeBuilder<I>;
-    /** `[Json]` Creates a Tuple type */
-    Tuple<T extends TSchema[]>(items: [...T], options?: SchemaOptions): TTuple<T>;
-    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize<T extends TSchema>(schema: T, options?: SchemaOptions): TUncapitalize<T>;
-    /** `[Json]` Creates a Union type */
-    Union<T extends TSchema[]>(schemas: [...T], options?: SchemaOptions): UnionResolve<T>;
-    /** `[Json]` Creates an Unknown type */
-    Unknown(options?: SchemaOptions): TUnknown;
-    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe<T>(options?: UnsafeOptions): TUnsafe<T>;
-    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase<T extends TSchema>(schema: T, options?: SchemaOptions): TUppercase<T>;
-}

package/esm/type/type/json.mjs

@@ -1,251 +0,0 @@
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/type
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-import { Any } from '../any/index.mjs';
-import { Array } from '../array/index.mjs';
-import { Boolean } from '../boolean/index.mjs';
-import { Composite } from '../composite/index.mjs';
-import { Const } from '../const/index.mjs';
-import { Deref } from '../deref/index.mjs';
-import { Enum } from '../enum/index.mjs';
-import { Exclude } from '../exclude/index.mjs';
-import { Extends } from '../extends/index.mjs';
-import { Extract } from '../extract/index.mjs';
-import { Index } from '../indexed/index.mjs';
-import { Integer } from '../integer/index.mjs';
-import { Intersect } from '../intersect/index.mjs';
-import { Capitalize, Uncapitalize, Lowercase, Uppercase } from '../intrinsic/index.mjs';
-import { KeyOf } from '../keyof/index.mjs';
-import { Literal } from '../literal/index.mjs';
-import { Never } from '../never/index.mjs';
-import { Not } from '../not/index.mjs';
-import { Null } from '../null/index.mjs';
-import { Number } from '../number/index.mjs';
-import { Object } from '../object/index.mjs';
-import { Omit } from '../omit/index.mjs';
-import { Optional } from '../optional/index.mjs';
-import { Partial } from '../partial/index.mjs';
-import { Pick } from '../pick/index.mjs';
-import { Readonly } from '../readonly/index.mjs';
-import { ReadonlyOptional } from '../readonly-optional/index.mjs';
-import { Record } from '../record/index.mjs';
-import { Recursive } from '../recursive/index.mjs';
-import { Ref } from '../ref/index.mjs';
-import { Required } from '../required/index.mjs';
-import { Rest } from '../rest/index.mjs';
-import { Strict } from '../strict/index.mjs';
-import { String } from '../string/index.mjs';
-import { TemplateLiteral } from '../template-literal/index.mjs';
-import { Transform } from '../transform/index.mjs';
-import { Tuple } from '../tuple/index.mjs';
-import { Union } from '../union/index.mjs';
-import { Unknown } from '../unknown/index.mjs';
-import { Unsafe } from '../unsafe/index.mjs';
-/** Json Type Builder with Static Resolution for TypeScript */
-export class JsonTypeBuilder {
-    // ------------------------------------------------------------------------
-    // Strict
-    // ------------------------------------------------------------------------
-    /** `[Json]` Omits compositing symbols from this schema */
-    Strict(schema) {
-        return Strict(schema);
-    }
-    // ------------------------------------------------------------------------
-    // Modifiers
-    // ------------------------------------------------------------------------
-    /** `[Json]` Creates a Readonly and Optional property */
-    ReadonlyOptional(schema) {
-        return ReadonlyOptional(schema);
-    }
-    /** `[Json]` Creates a Readonly property */
-    Readonly(schema) {
-        return Readonly(schema);
-    }
-    /** `[Json]` Creates an Optional property */
-    Optional(schema) {
-        return Optional(schema);
-    }
-    // ------------------------------------------------------------------------
-    // Types
-    // ------------------------------------------------------------------------
-    /** `[Json]` Creates an Any type */
-    Any(options = {}) {
-        return Any(options);
-    }
-    /** `[Json]` Creates an Array type */
-    Array(schema, options = {}) {
-        return Array(schema, options);
-    }
-    /** `[Json]` Creates a Boolean type */
-    Boolean(options = {}) {
-        return Boolean(options);
-    }
-    /** `[Json]` Intrinsic function to Capitalize LiteralString types */
-    Capitalize(schema, options = {}) {
-        return Capitalize(schema, options);
-    }
-    /** `[Json]` Creates a Composite object type */
-    Composite(objects, options) {
-        return Composite(objects, options); // (error) TS 5.4.0-dev - review TComposite implementation
-    }
-    /** `[JavaScript]` Creates a readonly const type from the given value. */
-    Const(value, options = {}) {
-        return Const(value, options);
-    }
-    /** `[Json]` Creates a dereferenced type */
-    Deref(schema, references) {
-        return Deref(schema, references);
-    }
-    /** `[Json]` Creates a Enum type */
-    Enum(item, options = {}) {
-        return Enum(item, options);
-    }
-    /** `[Json]` Creates a Conditional type */
-    Extends(left, right, trueType, falseType, options = {}) {
-        return Extends(left, right, trueType, falseType, options);
-    }
-    /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-    Exclude(unionType, excludedMembers, options = {}) {
-        return Exclude(unionType, excludedMembers, options);
-    }
-    /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-    Extract(type, union, options = {}) {
-        return Extract(type, union, options);
-    }
-    /** `[Json]` Returns an Indexed property type for the given keys */
-    Index(schema, unresolved, options = {}) {
-        return Index(schema, unresolved, options);
-    }
-    /** `[Json]` Creates an Integer type */
-    Integer(options = {}) {
-        return Integer(options);
-    }
-    /** `[Json]` Creates an Intersect type */
-    Intersect(T, options = {}) {
-        return Intersect(T, options);
-    }
-    /** `[Json]` Creates a KeyOf type */
-    KeyOf(schema, options = {}) {
-        return KeyOf(schema, options);
-    }
-    /** `[Json]` Creates a Literal type */
-    Literal(value, options = {}) {
-        return Literal(value, options);
-    }
-    /** `[Json]` Intrinsic function to Lowercase LiteralString types */
-    Lowercase(schema, options = {}) {
-        return Lowercase(schema, options);
-    }
-    /** `[Json]` Creates a Never type */
-    Never(options = {}) {
-        return Never(options);
-    }
-    /** `[Json]` Creates a Not type */
-    Not(schema, options) {
-        return Not(schema, options);
-    }
-    /** `[Json]` Creates a Null type */
-    Null(options = {}) {
-        return Null(options);
-    }
-    /** `[Json]` Creates a Number type */
-    Number(options = {}) {
-        return Number(options);
-    }
-    /** `[Json]` Creates an Object type */
-    Object(properties, options = {}) {
-        return Object(properties, options);
-    }
-    /** `[Json]` Constructs a type whose keys are omitted from the given type */
-    Omit(schema, unresolved, options = {}) {
-        return Omit(schema, unresolved, options);
-    }
-    /** `[Json]` Constructs a type where all properties are optional */
-    Partial(schema, options = {}) {
-        return Partial(schema, options);
-    }
-    /** `[Json]` Constructs a type whose keys are picked from the given type */
-    Pick(schema, unresolved, options = {}) {
-        return Pick(schema, unresolved, options);
-    }
-    /** `[Json]` Creates a Record type */
-    Record(key, schema, options = {}) {
-        return Record(key, schema);
-    }
-    /** `[Json]` Creates a Recursive type */
-    Recursive(callback, options = {}) {
-        return Recursive(callback, options);
-    }
-    /** `[Json]` Creates a Ref type. */
-    Ref(unresolved, options = {}) {
-        return Ref(unresolved, options);
-    }
-    /** `[Json]` Constructs a type where all properties are required */
-    Required(schema, options = {}) {
-        return Required(schema, options);
-    }
-    /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-    Rest(schema) {
-        return Rest(schema);
-    }
-    /** `[Json]` Creates a String type */
-    String(options = {}) {
-        return String(options);
-    }
-    /** `[Json]` Creates a TemplateLiteral type */
-    TemplateLiteral(unresolved, options = {}) {
-        return TemplateLiteral(unresolved, options);
-    }
-    /** `[Json]` Creates a Transform type */
-    Transform(schema) {
-        return Transform(schema);
-    }
-    /** `[Json]` Creates a Tuple type */
-    Tuple(items, options = {}) {
-        return Tuple(items, options);
-    }
-    /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
-    Uncapitalize(schema, options = {}) {
-        return Uncapitalize(schema, options);
-    }
-    /** `[Json]` Creates a Union type */
-    Union(schemas, options = {}) {
-        return Union(schemas, options);
-    }
-    /** `[Json]` Creates an Unknown type */
-    Unknown(options = {}) {
-        return Unknown(options);
-    }
-    /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
-    Unsafe(options = {}) {
-        return Unsafe(options);
-    }
-    /** `[Json]` Intrinsic function to Uppercase LiteralString types */
-    Uppercase(schema, options = {}) {
-        return Uppercase(schema, options);
-    }
-}