@depup/sinclair__typebox 0.34.48-depup.0

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

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

package/build/esm/type/regexp/index.mjs

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

package/build/esm/type/regexp/regexp.d.mts

@@ -0,0 +1,20 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export interface RegExpOptions extends SchemaOptions {
+    /** The maximum length of the string */
+    maxLength?: number;
+    /** The minimum length of the string */
+    minLength?: number;
+}
+export interface TRegExp extends TSchema {
+    [Kind]: 'RegExp';
+    static: `${string}`;
+    type: 'RegExp';
+    source: string;
+    flags: string;
+}
+/** `[JavaScript]` Creates a RegExp type */
+export declare function RegExp(pattern: string, options?: RegExpOptions): TRegExp;
+/** `[JavaScript]` Creates a RegExp type */
+export declare function RegExp(regex: RegExp, options?: RegExpOptions): TRegExp;

package/build/esm/type/regexp/regexp.mjs

@@ -0,0 +1,8 @@
+import { CreateType } from '../create/type.mjs';
+import { IsString } from '../guard/value.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[JavaScript]` Creates a RegExp type */
+export function RegExp(unresolved, options) {
+    const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+    return CreateType({ [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags }, options);
+}

package/build/esm/type/registry/format.d.mts

@@ -0,0 +1,13 @@
+export type FormatRegistryValidationFunction = (value: string) => boolean;
+/** Returns the entries in this registry */
+export declare function Entries(): Map<string, FormatRegistryValidationFunction>;
+/** Clears all user defined string formats */
+export declare function Clear(): void;
+/** Deletes a registered format */
+export declare function Delete(format: string): boolean;
+/** Returns true if the user defined string format exists */
+export declare function Has(format: string): boolean;
+/** Sets a validation function for a user defined string format */
+export declare function Set(format: string, func: FormatRegistryValidationFunction): void;
+/** Gets a validation function for a user defined string format */
+export declare function Get(format: string): FormatRegistryValidationFunction | undefined;

package/build/esm/type/registry/format.mjs

@@ -0,0 +1,26 @@
+/** A registry for user defined string formats */
+const map = new Map();
+/** Returns the entries in this registry */
+export function Entries() {
+    return new Map(map);
+}
+/** Clears all user defined string formats */
+export function Clear() {
+    return map.clear();
+}
+/** Deletes a registered format */
+export function Delete(format) {
+    return map.delete(format);
+}
+/** Returns true if the user defined string format exists */
+export function Has(format) {
+    return map.has(format);
+}
+/** Sets a validation function for a user defined string format */
+export function Set(format, func) {
+    map.set(format, func);
+}
+/** Gets a validation function for a user defined string format */
+export function Get(format) {
+    return map.get(format);
+}

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

@@ -0,0 +1,2 @@
+export * as FormatRegistry from './format.mjs';
+export * as TypeRegistry from './type.mjs';

package/build/esm/type/registry/index.mjs

@@ -0,0 +1,2 @@
+export * as FormatRegistry from './format.mjs';
+export * as TypeRegistry from './type.mjs';

package/build/esm/type/registry/type.d.mts

@@ -0,0 +1,13 @@
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+/** Returns the entries in this registry */
+export declare function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
+/** Clears all user defined types */
+export declare function Clear(): void;
+/** Deletes a registered type */
+export declare function Delete(kind: string): boolean;
+/** Returns true if this registry contains this kind */
+export declare function Has(kind: string): boolean;
+/** Sets a validation function for a user defined type */
+export declare function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
+/** Gets a custom validation function for a user defined type */
+export declare function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;

package/build/esm/type/registry/type.mjs

@@ -0,0 +1,26 @@
+/** A registry for user defined types */
+const map = new Map();
+/** Returns the entries in this registry */
+export function Entries() {
+    return new Map(map);
+}
+/** Clears all user defined types */
+export function Clear() {
+    return map.clear();
+}
+/** Deletes a registered type */
+export function Delete(kind) {
+    return map.delete(kind);
+}
+/** Returns true if this registry contains this kind */
+export function Has(kind) {
+    return map.has(kind);
+}
+/** Sets a validation function for a user defined type */
+export function Set(kind, func) {
+    map.set(kind, func);
+}
+/** Gets a custom validation function for a user defined type */
+export function Get(kind) {
+    return map.get(kind);
+}

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

@@ -0,0 +1,2 @@
+export * from './required-from-mapped-result.mjs';
+export * from './required.mjs';

package/build/esm/type/required/index.mjs

@@ -0,0 +1,2 @@
+export * from './required-from-mapped-result.mjs';
+export * from './required.mjs';

package/build/esm/type/required/required-from-mapped-result.d.mts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index.mjs';
+import type { Ensure, Evaluate } from '../helpers/index.mjs';
+import type { TProperties } from '../object/index.mjs';
+import { type TMappedResult } from '../mapped/index.mjs';
+import { type TRequired } from './required.mjs';
+type TFromProperties<P extends TProperties> = ({
+    [K2 in keyof P]: TRequired<P[K2]>;
+});
+type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
+export type TRequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
+export declare function RequiredFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
+export {};

package/build/esm/type/required/required-from-mapped-result.mjs

@@ -0,0 +1,18 @@
+import { MappedResult } from '../mapped/index.mjs';
+import { Required } from './required.mjs';
+// prettier-ignore
+function FromProperties(P, options) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = Required(P[K2], options);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, options) {
+    return FromProperties(R.properties, options);
+}
+// prettier-ignore
+export function RequiredFromMappedResult(R, options) {
+    const P = FromMappedResult(R, options);
+    return MappedResult(P);
+}

package/build/esm/type/required/required.d.mts

@@ -0,0 +1,35 @@
+import type { TSchema, SchemaOptions } from '../schema/index.mjs';
+import type { Evaluate, Ensure } from '../helpers/index.mjs';
+import type { TMappedResult } from '../mapped/index.mjs';
+import { type TReadonlyOptional } from '../readonly-optional/index.mjs';
+import { type TComputed } from '../computed/index.mjs';
+import { type TOptional } from '../optional/index.mjs';
+import { type TReadonly } from '../readonly/index.mjs';
+import { type TRecursive } from '../recursive/index.mjs';
+import { type TObject, type TProperties } from '../object/index.mjs';
+import { type TIntersect } from '../intersect/index.mjs';
+import { type TUnion } from '../union/index.mjs';
+import { type TRef } from '../ref/index.mjs';
+import { type TBigInt } from '../bigint/index.mjs';
+import { type TBoolean } from '../boolean/index.mjs';
+import { type TInteger } from '../integer/index.mjs';
+import { type TLiteral } from '../literal/index.mjs';
+import { type TNull } from '../null/index.mjs';
+import { type TNumber } from '../number/index.mjs';
+import { type TString } from '../string/index.mjs';
+import { type TSymbol } from '../symbol/index.mjs';
+import { type TUndefined } from '../undefined/index.mjs';
+import { type TRequiredFromMappedResult } from './required-from-mapped-result.mjs';
+type TFromComputed<Target extends string, Parameters extends TSchema[]> = Ensure<TComputed<'Required', [TComputed<Target, Parameters>]>>;
+type TFromRef<Ref extends string> = Ensure<TComputed<'Required', [TRef<Ref>]>>;
+type TFromProperties<Properties extends TProperties> = Evaluate<{
+    [K in keyof Properties]: Properties[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : Properties[K] extends (TReadonly<infer S>) ? TReadonly<S> : Properties[K] extends (TOptional<infer S>) ? S : Properties[K];
+}>;
+type TFromObject<_Type extends TObject, Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Properties>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TFromRest<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromRest<R, [...Result, TRequired<L>]> : Result);
+export type TRequired<Type extends TSchema> = (Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TRequired<Type>> : Type extends TComputed<infer Target extends string, infer Parameters extends TSchema[]> ? TFromComputed<Target, Parameters> : Type extends TRef<infer Ref extends string> ? TFromRef<Ref> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromRest<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromRest<Types>> : Type extends TObject<infer Properties extends TProperties> ? TFromObject<TObject, Properties> : Type extends TBigInt ? Type : Type extends TBoolean ? Type : Type extends TInteger ? Type : Type extends TLiteral ? Type : Type extends TNull ? Type : Type extends TNumber ? Type : Type extends TString ? Type : Type extends TSymbol ? Type : Type extends TUndefined ? Type : TObject<{}>);
+/** `[Json]` Constructs a type where all properties are required */
+export declare function Required<MappedResult extends TMappedResult>(type: MappedResult, options?: SchemaOptions): TRequiredFromMappedResult<MappedResult>;
+/** `[Json]` Constructs a type where all properties are required */
+export declare function Required<Type extends TSchema>(type: Type, options?: SchemaOptions): TRequired<Type>;
+export {};

package/build/esm/type/required/required.mjs

@@ -0,0 +1,73 @@
+import { CreateType } from '../create/type.mjs';
+import { Computed } from '../computed/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Ref } from '../ref/index.mjs';
+import { OptionalKind, TransformKind } from '../symbols/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import * as KindGuard from '../guard/kind.mjs';
+// prettier-ignore
+function FromComputed(target, parameters) {
+    return Computed('Required', [Computed(target, parameters)]);
+}
+// prettier-ignore
+function FromRef($ref) {
+    return Computed('Required', [Ref($ref)]);
+}
+// prettier-ignore
+function FromProperties(properties) {
+    const requiredProperties = {};
+    for (const K of globalThis.Object.getOwnPropertyNames(properties))
+        requiredProperties[K] = Discard(properties[K], [OptionalKind]);
+    return requiredProperties;
+}
+// prettier-ignore
+function FromObject(type, properties) {
+    const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
+    const mappedProperties = FromProperties(properties);
+    return Object(mappedProperties, options);
+}
+// prettier-ignore
+function FromRest(types) {
+    return types.map(type => RequiredResolve(type));
+}
+// ------------------------------------------------------------------
+// RequiredResolve
+// ------------------------------------------------------------------
+// prettier-ignore
+function RequiredResolve(type) {
+    return (
+    // Mappable
+    KindGuard.IsComputed(type) ? FromComputed(type.target, type.parameters) :
+        KindGuard.IsRef(type) ? FromRef(type.$ref) :
+            KindGuard.IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
+                KindGuard.IsUnion(type) ? Union(FromRest(type.anyOf)) :
+                    KindGuard.IsObject(type) ? FromObject(type, type.properties) :
+                        // Intrinsic
+                        KindGuard.IsBigInt(type) ? type :
+                            KindGuard.IsBoolean(type) ? type :
+                                KindGuard.IsInteger(type) ? type :
+                                    KindGuard.IsLiteral(type) ? type :
+                                        KindGuard.IsNull(type) ? type :
+                                            KindGuard.IsNumber(type) ? type :
+                                                KindGuard.IsString(type) ? type :
+                                                    KindGuard.IsSymbol(type) ? type :
+                                                        KindGuard.IsUndefined(type) ? type :
+                                                            // Passthrough
+                                                            Object({}));
+}
+/** `[Json]` Constructs a type where all properties are required */
+export function Required(type, options) {
+    if (KindGuard.IsMappedResult(type)) {
+        return RequiredFromMappedResult(type, options);
+    }
+    else {
+        // special: mapping types require overridable options
+        return CreateType({ ...RequiredResolve(type), ...options });
+    }
+}

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

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

package/build/esm/type/rest/index.mjs

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

package/build/esm/type/rest/rest.d.mts

@@ -0,0 +1,10 @@
+import type { TSchema } from '../schema/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+type TRestResolve<T extends TSchema> = T extends TIntersect<infer S extends TSchema[]> ? S : T extends TUnion<infer S extends TSchema[]> ? S : T extends TTuple<infer S extends TSchema[]> ? S : [
+];
+export type TRest<T extends TSchema> = TRestResolve<T>;
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+export declare function Rest<T extends TSchema>(T: T): TRest<T>;
+export {};

package/build/esm/type/rest/rest.mjs

@@ -0,0 +1,15 @@
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+import { IsIntersect, IsUnion, IsTuple } from '../guard/kind.mjs';
+// prettier-ignore
+function RestResolve(T) {
+    return (IsIntersect(T) ? T.allOf :
+        IsUnion(T) ? T.anyOf :
+            IsTuple(T) ? T.items ?? [] :
+                []);
+}
+/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+export function Rest(T) {
+    return RestResolve(T);
+}

package/build/esm/type/return-type/index.d.mts

@@ -0,0 +1 @@
+export * from './return-type.mjs';

package/build/esm/type/return-type/index.mjs

@@ -0,0 +1 @@
+export * from './return-type.mjs';

package/build/esm/type/return-type/return-type.d.mts

@@ -0,0 +1,6 @@
+import { type TSchema, type SchemaOptions } from '../schema/index.mjs';
+import { type TFunction } from '../function/index.mjs';
+import { type TNever } from '../never/index.mjs';
+export type TReturnType<Type extends TSchema, Result extends TSchema = Type extends TFunction<infer _Parameters extends TSchema[], infer ReturnType extends TSchema> ? ReturnType : TNever> = Result;
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
+export declare function ReturnType<Type extends TSchema>(schema: Type, options?: SchemaOptions): TReturnType<Type>;

package/build/esm/type/return-type/return-type.mjs

@@ -0,0 +1,7 @@
+import { CreateType } from '../create/type.mjs';
+import { Never } from '../never/index.mjs';
+import * as KindGuard from '../guard/kind.mjs';
+/** `[JavaScript]` Extracts the ReturnType from the given Function type */
+export function ReturnType(schema, options) {
+    return (KindGuard.IsFunction(schema) ? CreateType(schema.returns, options) : Never(options));
+}

package/build/esm/type/schema/anyschema.d.mts

@@ -0,0 +1,33 @@
+import type { TAny } from '../any/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TAsyncIterator } from '../async-iterator/index.mjs';
+import type { TBigInt } from '../bigint/index.mjs';
+import type { TBoolean } from '../boolean/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import type { TDate } from '../date/index.mjs';
+import type { TEnum } from '../enum/index.mjs';
+import type { TFunction } from '../function/index.mjs';
+import type { TInteger } from '../integer/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TIterator } from '../iterator/index.mjs';
+import type { TLiteral } from '../literal/index.mjs';
+import type { TNot } from '../not/index.mjs';
+import type { TNull } from '../null/index.mjs';
+import type { TNumber } from '../number/index.mjs';
+import type { TObject } from '../object/index.mjs';
+import type { TPromise } from '../promise/index.mjs';
+import type { TRecord } from '../record/index.mjs';
+import type { TThis } from '../recursive/index.mjs';
+import type { TRef } from '../ref/index.mjs';
+import type { TRegExp } from '../regexp/index.mjs';
+import type { TString } from '../string/index.mjs';
+import type { TSymbol } from '../symbol/index.mjs';
+import type { TTemplateLiteral } from '../template-literal/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+import type { TUint8Array } from '../uint8array/index.mjs';
+import type { TUndefined } from '../undefined/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TUnknown } from '../unknown/index.mjs';
+import type { TVoid } from '../void/index.mjs';
+import type { TSchema } from './schema.mjs';
+export type TAnySchema = TSchema | TAny | TArray | TAsyncIterator | TBigInt | TBoolean | TConstructor | TDate | TEnum | TFunction | TInteger | TIntersect | TIterator | TLiteral | TNot | TNull | TNumber | TObject | TPromise | TRecord | TRef | TRegExp | TString | TSymbol | TTemplateLiteral | TThis | TTuple | TUndefined | TUnion | TUint8Array | TUnknown | TVoid;

package/build/esm/type/schema/anyschema.mjs

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+export * from './anyschema.mjs';
+export * from './schema.mjs';

package/build/esm/type/schema/index.mjs

@@ -0,0 +1,2 @@
+export * from './anyschema.mjs';
+export * from './schema.mjs';

package/build/esm/type/schema/schema.d.mts

@@ -0,0 +1,29 @@
+import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
+export interface SchemaOptions {
+    $schema?: string;
+    /** Id for this schema */
+    $id?: string;
+    /** Title of this schema */
+    title?: string;
+    /** Description of this schema */
+    description?: string;
+    /** Default value for this schema */
+    default?: any;
+    /** Example values matching this schema */
+    examples?: any;
+    /** Optional annotation for readOnly */
+    readOnly?: boolean;
+    /** Optional annotation for writeOnly */
+    writeOnly?: boolean;
+    [prop: string]: any;
+}
+export interface TKind {
+    [Kind]: string;
+}
+export interface TSchema extends TKind, SchemaOptions {
+    [ReadonlyKind]?: string;
+    [OptionalKind]?: string;
+    [Hint]?: string;
+    params: unknown[];
+    static: unknown;
+}

package/build/esm/type/schema/schema.mjs

@@ -0,0 +1 @@
+import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';

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

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

package/build/esm/type/sets/index.mjs

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

package/build/esm/type/sets/set.d.mts

@@ -0,0 +1,28 @@
+export type TSetIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : TSetIncludes<R, S> : false);
+/** Returns true if element right is in the set of left */
+export declare function SetIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): TSetIncludes<T, S>;
+export type TSetIsSubset<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetIsSubset<R, S> : false : true);
+/** Returns true if left is a subset of right */
+export declare function SetIsSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIsSubset<T, S>;
+export type TSetDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<Acc, L> extends false ? TSetDistinct<R, [...Acc, L]> : TSetDistinct<R, [...Acc]> : Acc;
+/** Returns a distinct set of elements */
+export declare function SetDistinct<T extends PropertyKey[]>(T: [...T]): TSetDistinct<T>;
+export type TSetIntersect<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetIntersect<R, S, [...Acc, L]> : TSetIntersect<R, S, [...Acc]> : Acc);
+/** Returns the Intersect of the given sets */
+export declare function SetIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetIntersect<T, S>;
+export type TSetUnion<T extends PropertyKey[], S extends PropertyKey[]> = ([
+    ...T,
+    ...S
+]);
+/** Returns the Union of the given sets */
+export declare function SetUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetUnion<T, S>;
+export type TSetComplement<T extends PropertyKey[], S extends PropertyKey[], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? TSetIncludes<S, L> extends true ? TSetComplement<R, S, [...Acc]> : TSetComplement<R, S, [...Acc, L]> : Acc);
+/** Returns the Complement by omitting elements in T that are in S */
+export declare function SetComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): TSetComplement<T, S>;
+type TSetIntersectManyResolve<T extends PropertyKey[][], Acc extends PropertyKey[]> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetIntersectManyResolve<R, TSetIntersect<Acc, L>> : Acc);
+export type TSetIntersectMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetIntersectManyResolve<R, L> : []);
+export declare function SetIntersectMany<T extends PropertyKey[][]>(T: [...T]): TSetIntersectMany<T>;
+export type TSetUnionMany<T extends PropertyKey[][], Acc extends PropertyKey[] = []> = (T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? TSetUnionMany<R, TSetUnion<Acc, L>> : Acc);
+/** Returns the Union of multiple sets */
+export declare function SetUnionMany<T extends PropertyKey[][]>(T: [...T]): TSetUnionMany<T>;
+export {};

package/build/esm/type/sets/set.mjs

@@ -0,0 +1,48 @@
+/** Returns true if element right is in the set of left */
+// prettier-ignore
+export function SetIncludes(T, S) {
+    return T.includes(S);
+}
+/** Returns true if left is a subset of right */
+export function SetIsSubset(T, S) {
+    return T.every((L) => SetIncludes(S, L));
+}
+/** Returns a distinct set of elements */
+export function SetDistinct(T) {
+    return [...new Set(T)];
+}
+/** Returns the Intersect of the given sets */
+export function SetIntersect(T, S) {
+    return T.filter((L) => S.includes(L));
+}
+/** Returns the Union of the given sets */
+export function SetUnion(T, S) {
+    return [...T, ...S];
+}
+/** Returns the Complement by omitting elements in T that are in S */
+// prettier-ignore
+export function SetComplement(T, S) {
+    return T.filter(L => !S.includes(L));
+}
+// prettier-ignore
+function SetIntersectManyResolve(T, Init) {
+    return T.reduce((Acc, L) => {
+        return SetIntersect(Acc, L);
+    }, Init);
+}
+// prettier-ignore
+export function SetIntersectMany(T) {
+    return (T.length === 1
+        ? T[0]
+        // Use left to initialize the accumulator for resolve
+        : T.length > 1
+            ? SetIntersectManyResolve(T.slice(1), T[0])
+            : []);
+}
+/** Returns the Union of multiple sets */
+export function SetUnionMany(T) {
+    const Acc = [];
+    for (const L of T)
+        Acc.push(...L);
+    return Acc;
+}

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

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

package/build/esm/type/static/index.mjs

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

package/build/esm/type/static/static.d.mts

@@ -0,0 +1,39 @@
+import type { Evaluate } from '../helpers/index.mjs';
+import type { TOptional } from '../optional/index.mjs';
+import type { TReadonly } from '../readonly/index.mjs';
+import type { TArray } from '../array/index.mjs';
+import type { TAsyncIterator } from '../async-iterator/index.mjs';
+import type { TConstructor } from '../constructor/index.mjs';
+import type { TEnum } from '../enum/index.mjs';
+import type { TFunction } from '../function/index.mjs';
+import type { TIntersect } from '../intersect/index.mjs';
+import type { TImport } from '../module/index.mjs';
+import type { TIterator } from '../iterator/index.mjs';
+import type { TNot } from '../not/index.mjs';
+import type { TObject, TProperties } from '../object/index.mjs';
+import type { TPromise } from '../promise/index.mjs';
+import type { TRecursive } from '../recursive/index.mjs';
+import type { TRecord } from '../record/index.mjs';
+import type { TRef } from '../ref/index.mjs';
+import type { TTuple } from '../tuple/index.mjs';
+import type { TUnion } from '../union/index.mjs';
+import type { TUnsafe } from '../unsafe/index.mjs';
+import type { TSchema } from '../schema/index.mjs';
+import type { TTransform } from '../transform/index.mjs';
+import type { TNever } from '../never/index.mjs';
+type TDecodeImport<ModuleProperties extends TProperties, Key extends PropertyKey> = (Key extends keyof ModuleProperties ? TDecodeType<ModuleProperties[Key]> extends infer Type extends TSchema ? Type extends TRef<infer Ref extends string> ? TDecodeImport<ModuleProperties, Ref> : Type : TNever : TNever);
+type TDecodeProperties<Properties extends TProperties> = {
+    [Key in keyof Properties]: TDecodeType<Properties[Key]>;
+};
+type TDecodeTypes<Types extends TSchema[], Result extends TSchema[] = []> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TDecodeTypes<Right, [...Result, TDecodeType<Left>]> : Result);
+export type TDecodeType<Type extends TSchema> = (Type extends TOptional<infer Type extends TSchema> ? TOptional<TDecodeType<Type>> : Type extends TReadonly<infer Type extends TSchema> ? TReadonly<TDecodeType<Type>> : Type extends TTransform<infer _Input extends TSchema, infer Output> ? TUnsafe<Output> : Type extends TArray<infer Type extends TSchema> ? TArray<TDecodeType<Type>> : Type extends TAsyncIterator<infer Type extends TSchema> ? TAsyncIterator<TDecodeType<Type>> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TConstructor<TDecodeTypes<Parameters>, TDecodeType<InstanceType>> : Type extends TEnum<infer Values> ? TEnum<Values> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFunction<TDecodeTypes<Parameters>, TDecodeType<ReturnType>> : Type extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TDecodeTypes<Types>> : Type extends TImport<infer ModuleProperties extends TProperties, infer Key> ? TDecodeImport<ModuleProperties, Key> : Type extends TIterator<infer Type extends TSchema> ? TIterator<TDecodeType<Type>> : Type extends TNot<infer Type extends TSchema> ? TNot<TDecodeType<Type>> : Type extends TObject<infer Properties extends TProperties> ? TObject<Evaluate<TDecodeProperties<Properties>>> : Type extends TPromise<infer Type extends TSchema> ? TPromise<TDecodeType<Type>> : Type extends TRecord<infer Key extends TSchema, infer Value extends TSchema> ? TRecord<Key, TDecodeType<Value>> : Type extends TRecursive<infer Type extends TSchema> ? TRecursive<TDecodeType<Type>> : Type extends TRef<infer Ref extends string> ? TRef<Ref> : Type extends TTuple<infer Types extends TSchema[]> ? TTuple<TDecodeTypes<Types>> : Type extends TUnion<infer Types extends TSchema[]> ? TUnion<TDecodeTypes<Types>> : Type);
+export type StaticDecodeIsAny<Type> = boolean extends (Type extends TSchema ? true : false) ? true : false;
+/** Creates an decoded static type from a TypeBox type */
+export type StaticDecode<Type extends TSchema, Params extends unknown[] = [], Result = StaticDecodeIsAny<Type> extends true ? unknown : Static<TDecodeType<Type>, Params>> = Result;
+/** Creates an encoded static type from a TypeBox type */
+export type StaticEncode<Type extends TSchema, Params extends unknown[] = [], Result = Static<Type, Params>> = Result;
+/** Creates a static type from a TypeBox type */
+export type Static<Type extends TSchema, Params extends unknown[] = [], Result = (Type & {
+    params: Params;
+})['static']> = Result;
+export {};

package/build/esm/type/static/static.mjs

@@ -0,0 +1 @@
+export {};

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

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

package/build/esm/type/string/index.mjs

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

package/build/esm/type/string/string.d.mts

@@ -0,0 +1,25 @@
+import { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+export type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
+export interface StringOptions extends SchemaOptions {
+    /** The maximum string length */
+    maxLength?: number;
+    /** The minimum string length */
+    minLength?: number;
+    /** A regular expression pattern this string should match */
+    pattern?: string;
+    /** A format this string should match */
+    format?: StringFormatOption;
+    /** The content encoding for this string */
+    contentEncoding?: StringContentEncodingOption;
+    /** The content media type for this string */
+    contentMediaType?: string;
+}
+export interface TString extends TSchema, StringOptions {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+/** `[Json]` Creates a String type */
+export declare function String(options?: StringOptions): TString;

package/build/esm/type/string/string.mjs

@@ -0,0 +1,6 @@
+import { CreateType } from '../create/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+/** `[Json]` Creates a String type */
+export function String(options) {
+    return CreateType({ [Kind]: 'String', type: 'string' }, options);
+}

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

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

package/build/esm/type/symbol/index.mjs

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

package/build/esm/type/symbol/symbol.d.mts

@@ -0,0 +1,10 @@
+import { TSchema, SchemaOptions } from '../schema/index.mjs';
+import { Kind } from '../symbols/index.mjs';
+export type TSymbolValue = string | number | undefined;
+export interface TSymbol extends TSchema, SchemaOptions {
+    [Kind]: 'Symbol';
+    static: symbol;
+    type: 'symbol';
+}
+/** `[JavaScript]` Creates a Symbol type */
+export declare function Symbol(options?: SchemaOptions): TSymbol;