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

package/build/import/system/errors.mjs

@@ -0,0 +1,150 @@
+import { ValueErrorType } from '../errors/errors.mjs';
+import { Kind } from '../type/symbols/index.mjs';
+export var TypeSystemErrorFunction;
+(function (TypeSystemErrorFunction) {
+    let errorMessageFunction = DefaultErrorFunction;
+    function Reset() {
+        errorMessageFunction = DefaultErrorFunction;
+    }
+    TypeSystemErrorFunction.Reset = Reset;
+    function Set(callback) {
+        errorMessageFunction = callback;
+    }
+    TypeSystemErrorFunction.Set = Set;
+    function Get() {
+        return errorMessageFunction;
+    }
+    TypeSystemErrorFunction.Get = Get;
+})(TypeSystemErrorFunction || (TypeSystemErrorFunction = {}));
+export function DefaultErrorFunction(schema, errorType) {
+    switch (errorType) {
+        case ValueErrorType.ArrayContains:
+            return 'Expected array to contain at least one matching value';
+        case ValueErrorType.ArrayMaxContains:
+            return `Expected array to contain no more than ${schema.maxContains} matching values`;
+        case ValueErrorType.ArrayMinContains:
+            return `Expected array to contain at least ${schema.minContains} matching values`;
+        case ValueErrorType.ArrayMaxItems:
+            return `Expected array length to be less or equal to ${schema.maxItems}`;
+        case ValueErrorType.ArrayMinItems:
+            return `Expected array length to be greater or equal to ${schema.minItems}`;
+        case ValueErrorType.ArrayUniqueItems:
+            return 'Expected array elements to be unique';
+        case ValueErrorType.Array:
+            return 'Expected array';
+        case ValueErrorType.AsyncIterator:
+            return 'Expected AsyncIterator';
+        case ValueErrorType.BigIntExclusiveMaximum:
+            return `Expected bigint to be less than ${schema.exclusiveMaximum}`;
+        case ValueErrorType.BigIntExclusiveMinimum:
+            return `Expected bigint to be greater than ${schema.exclusiveMinimum}`;
+        case ValueErrorType.BigIntMaximum:
+            return `Expected bigint to be less or equal to ${schema.maximum}`;
+        case ValueErrorType.BigIntMinimum:
+            return `Expected bigint to be greater or equal to ${schema.minimum}`;
+        case ValueErrorType.BigIntMultipleOf:
+            return `Expected bigint to be a multiple of ${schema.multipleOf}`;
+        case ValueErrorType.BigInt:
+            return 'Expected bigint';
+        case ValueErrorType.Boolean:
+            return 'Expected boolean';
+        case ValueErrorType.DateExclusiveMinimumTimestamp:
+            return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`;
+        case ValueErrorType.DateExclusiveMaximumTimestamp:
+            return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`;
+        case ValueErrorType.DateMinimumTimestamp:
+            return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`;
+        case ValueErrorType.DateMaximumTimestamp:
+            return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`;
+        case ValueErrorType.DateMultipleOfTimestamp:
+            return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`;
+        case ValueErrorType.Date:
+            return 'Expected Date';
+        case ValueErrorType.Function:
+            return 'Expected function';
+        case ValueErrorType.IntegerExclusiveMaximum:
+            return `Expected integer to be less than ${schema.exclusiveMaximum}`;
+        case ValueErrorType.IntegerExclusiveMinimum:
+            return `Expected integer to be greater than ${schema.exclusiveMinimum}`;
+        case ValueErrorType.IntegerMaximum:
+            return `Expected integer to be less or equal to ${schema.maximum}`;
+        case ValueErrorType.IntegerMinimum:
+            return `Expected integer to be greater or equal to ${schema.minimum}`;
+        case ValueErrorType.IntegerMultipleOf:
+            return `Expected integer to be a multiple of ${schema.multipleOf}`;
+        case ValueErrorType.Integer:
+            return 'Expected integer';
+        case ValueErrorType.IntersectUnevaluatedProperties:
+            return 'Unexpected property';
+        case ValueErrorType.Intersect:
+            return 'Expected all values to match';
+        case ValueErrorType.Iterator:
+            return 'Expected Iterator';
+        case ValueErrorType.Literal:
+            return `Expected ${typeof schema.const === 'string' ? `'${schema.const}'` : schema.const}`;
+        case ValueErrorType.Never:
+            return 'Never';
+        case ValueErrorType.Not:
+            return 'Value should not match';
+        case ValueErrorType.Null:
+            return 'Expected null';
+        case ValueErrorType.NumberExclusiveMaximum:
+            return `Expected number to be less than ${schema.exclusiveMaximum}`;
+        case ValueErrorType.NumberExclusiveMinimum:
+            return `Expected number to be greater than ${schema.exclusiveMinimum}`;
+        case ValueErrorType.NumberMaximum:
+            return `Expected number to be less or equal to ${schema.maximum}`;
+        case ValueErrorType.NumberMinimum:
+            return `Expected number to be greater or equal to ${schema.minimum}`;
+        case ValueErrorType.NumberMultipleOf:
+            return `Expected number to be a multiple of ${schema.multipleOf}`;
+        case ValueErrorType.Number:
+            return 'Expected number';
+        case ValueErrorType.Object:
+            return 'Expected object';
+        case ValueErrorType.ObjectAdditionalProperties:
+            return 'Unexpected property';
+        case ValueErrorType.ObjectMaxProperties:
+            return `Expected object to have no more than ${schema.maxProperties} properties`;
+        case ValueErrorType.ObjectMinProperties:
+            return `Expected object to have at least ${schema.minProperties} properties`;
+        case ValueErrorType.ObjectRequiredProperty:
+            return 'Required property';
+        case ValueErrorType.Promise:
+            return 'Expected Promise';
+        case ValueErrorType.StringFormatUnknown:
+            return `Unknown format '${schema.format}'`;
+        case ValueErrorType.StringFormat:
+            return `Expected string to match '${schema.format}' format`;
+        case ValueErrorType.StringMaxLength:
+            return `Expected string length less or equal to ${schema.maxLength}`;
+        case ValueErrorType.StringMinLength:
+            return `Expected string length greater or equal to ${schema.minLength}`;
+        case ValueErrorType.StringPattern:
+            return `Expected string to match '${schema.pattern}'`;
+        case ValueErrorType.String:
+            return 'Expected string';
+        case ValueErrorType.Symbol:
+            return 'Expected symbol';
+        case ValueErrorType.TupleLength:
+            return `Expected tuple to have ${schema.maxItems || 0} elements`;
+        case ValueErrorType.Tuple:
+            return 'Expected tuple';
+        case ValueErrorType.Uint8ArrayMaxByteLength:
+            return `Expected byte length less or equal to ${schema.maxByteLength}`;
+        case ValueErrorType.Uint8ArrayMinByteLength:
+            return `Expected byte length greater or equal to ${schema.minByteLength}`;
+        case ValueErrorType.Uint8Array:
+            return 'Expected Uint8Array';
+        case ValueErrorType.Undefined:
+            return 'Expected undefined';
+        case ValueErrorType.Union:
+            return 'Expected union value';
+        case ValueErrorType.Void:
+            return 'Expected void';
+        case ValueErrorType.Kind:
+            return `Expected kind '${schema[Kind]}'`;
+        default:
+            return 'Unknown error type';
+    }
+}

package/build/import/system/index.mjs

@@ -0,0 +1,4 @@
+export { ValueErrorType } from '../errors/errors.mjs';
+export { DefaultErrorFunction, TypeSystemErrorFunction } from './errors.mjs';
+export { TypeSystemPolicy } from './policy.mjs';
+export { TypeSystem, TypeSystemDuplicateFormat, TypeSystemDuplicateTypeKind } from './system.mjs';

package/build/import/system/policy.mjs

@@ -0,0 +1,31 @@
+import { IsObject, IsArray, IsNumber, IsUndefined } from '../value/guard/index.mjs';
+export var TypeSystemPolicy;
+(function (TypeSystemPolicy) {
+    TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+    TypeSystemPolicy.AllowArrayObject = false;
+    TypeSystemPolicy.AllowNaN = false;
+    TypeSystemPolicy.AllowNullVoid = false;
+    function IsExactOptionalProperty(value, key) {
+        return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== undefined;
+    }
+    TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+    function IsObjectLike(value) {
+        const isObject = IsObject(value);
+        return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray(value);
+    }
+    TypeSystemPolicy.IsObjectLike = IsObjectLike;
+    function IsRecordLike(value) {
+        return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+    }
+    TypeSystemPolicy.IsRecordLike = IsRecordLike;
+    function IsNumberLike(value) {
+        const isNumber = IsNumber(value);
+        return TypeSystemPolicy.AllowNaN ? isNumber : isNumber && Number.isFinite(value);
+    }
+    TypeSystemPolicy.IsNumberLike = IsNumberLike;
+    function IsVoidLike(value) {
+        const isUndefined = IsUndefined(value);
+        return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
+    }
+    TypeSystemPolicy.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));

package/build/import/system/system.mjs

@@ -0,0 +1,30 @@
+import { TypeRegistry, FormatRegistry } from '../type/registry/index.mjs';
+import { Unsafe } from '../type/unsafe/index.mjs';
+import { Kind } from '../type/symbols/index.mjs';
+export class TypeSystemDuplicateTypeKind extends Error {
+    constructor(kind) {
+        super(`Duplicate type kind '${kind}' detected`);
+    }
+}
+export class TypeSystemDuplicateFormat extends Error {
+    constructor(kind) {
+        super(`Duplicate string format '${kind}' detected`);
+    }
+}
+export var TypeSystem;
+(function (TypeSystem) {
+    function Type(kind, check) {
+        if (TypeRegistry.Has(kind))
+            throw new TypeSystemDuplicateTypeKind(kind);
+        TypeRegistry.Set(kind, check);
+        return (options = {}) => Unsafe({ ...options, [Kind]: kind });
+    }
+    TypeSystem.Type = Type;
+    function Format(format, check) {
+        if (FormatRegistry.Has(format))
+            throw new TypeSystemDuplicateFormat(format);
+        FormatRegistry.Set(format, check);
+        return format;
+    }
+    TypeSystem.Format = Format;
+})(TypeSystem || (TypeSystem = {}));

package/build/import/type/any/any.mjs

@@ -0,0 +1,4 @@
+import { Kind } from '../symbols/index.mjs';
+export function Any(options = {}) {
+    return { ...options, [Kind]: 'Any' };
+}

package/build/import/type/any/index.mjs

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

package/build/import/type/array/array.mjs

@@ -0,0 +1,10 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Array(schema, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Array',
+        type: 'array',
+        items: CloneType(schema),
+    };
+}

package/build/import/type/array/index.mjs

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

package/build/import/type/async-iterator/async-iterator.mjs

@@ -0,0 +1,10 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function AsyncIterator(items, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'AsyncIterator',
+        type: 'AsyncIterator',
+        items: CloneType(items),
+    };
+}

package/build/import/type/async-iterator/index.mjs

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

package/build/import/type/awaited/awaited.mjs

@@ -0,0 +1,28 @@
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TPromise as IsPromiseType } from '../guard/type.mjs';
+function AwaitedUnwrap(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [Resolve(L), ...AwaitedUnwrap(R)]
+        : []);
+}
+function AwaitedIntersectRest(T) {
+    return Intersect(AwaitedUnwrap(T));
+}
+function AwaitedUnionRest(T) {
+    return Union(AwaitedUnwrap(T));
+}
+function AwaitedPromise(T) {
+    return Resolve(T);
+}
+export function Resolve(T) {
+    return (IsIntersectType(T) ? AwaitedIntersectRest(T.allOf) :
+        IsUnionType(T) ? AwaitedUnionRest(T.anyOf) :
+            IsPromiseType(T) ? AwaitedPromise(T.item) :
+                T);
+}
+export function Awaited(T, options = {}) {
+    return CloneType(Resolve(T), options);
+}

package/build/import/type/awaited/index.mjs

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

package/build/import/type/bigint/bigint.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function BigInt(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'BigInt',
+        type: 'bigint',
+    };
+}

package/build/import/type/bigint/index.mjs

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

package/build/import/type/boolean/boolean.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function Boolean(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Boolean',
+        type: 'boolean',
+    };
+}

package/build/import/type/boolean/index.mjs

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

package/build/import/type/clone/index.mjs

@@ -0,0 +1,2 @@
+export * as TypeClone from './type.mjs';
+export * as ValueClone from './value.mjs';

package/build/import/type/clone/type.mjs

@@ -0,0 +1,7 @@
+import { Clone } from './value.mjs';
+export function CloneRest(schemas) {
+    return schemas.map((schema) => CloneType(schema));
+}
+export function CloneType(schema, options = {}) {
+    return { ...Clone(schema), ...options };
+}

package/build/import/type/clone/value.mjs

@@ -0,0 +1,25 @@
+import * as ValueGuard from '../guard/value.mjs';
+function ArrayType(value) {
+    return value.map((value) => Visit(value));
+}
+function DateType(value) {
+    return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+    return new Uint8Array(value);
+}
+function ObjectType(value) {
+    const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+    const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+    return { ...clonedProperties, ...clonedSymbols };
+}
+function Visit(value) {
+    return (ValueGuard.IsArray(value) ? ArrayType(value) :
+        ValueGuard.IsDate(value) ? DateType(value) :
+            ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) :
+                ValueGuard.IsObject(value) ? ObjectType(value) :
+                    value);
+}
+export function Clone(value) {
+    return Visit(value);
+}

package/build/import/type/composite/composite.mjs

@@ -0,0 +1,14 @@
+import { Object } from '../object/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { KeyOfStringResolve } from '../keyof/index.mjs';
+import { Index } from '../indexed/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function CompositeResolve(T) {
+    const intersect = Intersect(T, {});
+    const keys = KeyOfStringResolve(intersect);
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: Index(intersect, [key]) }), {});
+    return Object(properties);
+}
+export function Composite(T, options) {
+    return CloneType(CompositeResolve(T), options);
+}

package/build/import/type/composite/index.mjs

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

package/build/import/type/const/const.mjs

@@ -0,0 +1,49 @@
+import { IsArray, IsNumber, IsBigInt, IsUint8Array, IsDate, IsIterator, IsObject, IsAsyncIterator, IsFunction, IsUndefined, IsNull, IsSymbol, IsBoolean, IsString } from '../guard/value.mjs';
+import { Any } from '../any/index.mjs';
+import { BigInt } from '../bigint/index.mjs';
+import { Date } from '../date/index.mjs';
+import { Function } from '../function/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Null } from '../null/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Symbol } from '../symbol/index.mjs';
+import { Tuple } from '../tuple/index.mjs';
+import { Readonly } from '../readonly/index.mjs';
+import { Undefined } from '../undefined/index.mjs';
+import { Uint8Array } from '../uint8array/index.mjs';
+import { Unknown } from '../unknown/index.mjs';
+import { TypeClone } from '../clone/index.mjs';
+function FromArray(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [FromValue(L, false), ...FromArray(R)]
+        : []);
+}
+function FromProperties(value) {
+    return globalThis.Object.getOwnPropertyNames(value).reduce((acc, key) => {
+        return { ...acc, [key]: Readonly(FromValue(value[key], false)) };
+    }, {});
+}
+function ConditionalReadonly(T, root) {
+    return (root === true ? T : Readonly(T));
+}
+function FromValue(value, root) {
+    return (IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) :
+        IsIterator(value) ? ConditionalReadonly(Any(), root) :
+            IsArray(value) ? Readonly(Tuple(FromArray(value))) :
+                IsUint8Array(value) ? Uint8Array() :
+                    IsDate(value) ? Date() :
+                        IsObject(value) ? ConditionalReadonly(Object(FromProperties(value)), root) :
+                            IsFunction(value) ? ConditionalReadonly(Function([], Unknown()), root) :
+                                IsUndefined(value) ? Undefined() :
+                                    IsNull(value) ? Null() :
+                                        IsSymbol(value) ? Symbol() :
+                                            IsBigInt(value) ? BigInt() :
+                                                IsNumber(value) ? Literal(value) :
+                                                    IsBoolean(value) ? Literal(value) :
+                                                        IsString(value) ? Literal(value) :
+                                                            Object({}));
+}
+export function Const(T, options = {}) {
+    return TypeClone.CloneType(FromValue(T, true), options);
+}

package/build/import/type/const/index.mjs

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

package/build/import/type/constructor/constructor.mjs

@@ -0,0 +1,11 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType, CloneRest } from '../clone/type.mjs';
+export function Constructor(parameters, returns, options) {
+    return {
+        ...options,
+        [Kind]: 'Constructor',
+        type: 'Constructor',
+        parameters: CloneRest(parameters),
+        returns: CloneType(returns),
+    };
+}

package/build/import/type/constructor/index.mjs

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

package/build/import/type/constructor-parameters/constructor-parameters.mjs

@@ -0,0 +1,5 @@
+import { Tuple } from '../tuple/index.mjs';
+import { CloneRest } from '../clone/type.mjs';
+export function ConstructorParameters(schema, options = {}) {
+    return Tuple(CloneRest(schema.parameters), { ...options });
+}

package/build/import/type/constructor-parameters/index.mjs

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

package/build/import/type/date/date.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function Date(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Date',
+        type: 'Date',
+    };
+}

package/build/import/type/date/index.mjs

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

package/build/import/type/deref/deref.mjs

@@ -0,0 +1,90 @@
+import { CloneType } from '../clone/type.mjs';
+import { Discard } from '../discard/index.mjs';
+import { IsUndefined } from '../guard/value.mjs';
+import { TConstructor as IsConstructorType, TFunction as IsFunctionType, TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TPromise as IsPromiseType, TAsyncIterator as IsAsyncIteratorType, TIterator as IsIteratorType, TRef as IsRefType, } from '../guard/type.mjs';
+function FromRest(schema, references) {
+    return schema.map((schema) => Deref(schema, references));
+}
+function FromProperties(properties, references) {
+    return globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
+        return { ...acc, [key]: Deref(properties[key], references) };
+    }, {});
+}
+function FromConstructor(schema, references) {
+    const clone = CloneType(schema);
+    clone.parameters = FromRest(clone.parameters, references);
+    clone.returns = Deref(clone.returns, references);
+    return clone;
+}
+function FromFunction(schema, references) {
+    const clone = CloneType(schema);
+    clone.parameters = FromRest(clone.parameters, references);
+    clone.returns = Deref(clone.returns, references);
+    return clone;
+}
+function FromIntersect(schema, references) {
+    const clone = CloneType(schema);
+    clone.allOf = FromRest(clone.allOf, references);
+    return clone;
+}
+function FromUnion(schema, references) {
+    const clone = CloneType(schema);
+    clone.anyOf = FromRest(clone.anyOf, references);
+    return clone;
+}
+function FromTuple(schema, references) {
+    const clone = CloneType(schema);
+    if (IsUndefined(clone.items))
+        return clone;
+    clone.items = FromRest(clone.items, references);
+    return clone;
+}
+function FromArray(schema, references) {
+    const clone = CloneType(schema);
+    clone.items = Deref(clone.items, references);
+    return clone;
+}
+function FromObject(schema, references) {
+    const clone = CloneType(schema);
+    clone.properties = FromProperties(clone.properties, references);
+    return clone;
+}
+function FromPromise(schema, references) {
+    const clone = CloneType(schema);
+    clone.item = Deref(clone.item, references);
+    return clone;
+}
+function FromAsyncIterator(schema, references) {
+    const clone = CloneType(schema);
+    clone.items = Deref(clone.items, references);
+    return clone;
+}
+function FromIterator(schema, references) {
+    const clone = CloneType(schema);
+    clone.items = Deref(clone.items, references);
+    return clone;
+}
+function FromRef(schema, references) {
+    const target = references.find(remote => remote.$id === schema.$ref);
+    if (target === undefined)
+        throw Error(`Unable to dereference schema with $id ${schema.$ref}`);
+    const discard = Discard(target, ['$id']);
+    return Deref(discard, references);
+}
+export function DerefResolve(schema, references) {
+    return (IsConstructorType(schema) ? FromConstructor(schema, references) :
+        IsFunctionType(schema) ? FromFunction(schema, references) :
+            IsIntersectType(schema) ? FromIntersect(schema, references) :
+                IsUnionType(schema) ? FromUnion(schema, references) :
+                    IsTupleType(schema) ? FromTuple(schema, references) :
+                        IsArrayType(schema) ? FromArray(schema, references) :
+                            IsObjectType(schema) ? FromObject(schema, references) :
+                                IsPromiseType(schema) ? FromPromise(schema, references) :
+                                    IsAsyncIteratorType(schema) ? FromAsyncIterator(schema, references) :
+                                        IsIteratorType(schema) ? FromIterator(schema, references) :
+                                            IsRefType(schema) ? FromRef(schema, references) :
+                                                schema);
+}
+export function Deref(schema, references) {
+    return DerefResolve(schema, references);
+}

package/build/import/type/deref/index.mjs

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

package/build/import/type/discard/discard.mjs

@@ -0,0 +1,7 @@
+function Key(value, key) {
+    const { [key]: _, ...rest } = value;
+    return rest;
+}
+export function Discard(value, keys) {
+    return keys.reduce((acc, key) => Key(acc, key), value);
+}

package/build/import/type/discard/index.mjs

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

package/build/import/type/enum/enum.mjs

@@ -0,0 +1,14 @@
+import { Literal } from '../literal/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+import { Union } from '../union/index.mjs';
+import { IsUndefined } from '../guard/value.mjs';
+export function Enum(item, options = {}) {
+    if (IsUndefined(item))
+        throw new Error('Enum undefined or empty');
+    const values1 = globalThis.Object.getOwnPropertyNames(item)
+        .filter((key) => isNaN(key))
+        .map((key) => item[key]);
+    const values2 = [...new Set(values1)];
+    const anyOf = values2.map((value) => Literal(value));
+    return Union(anyOf, { ...options, [Hint]: 'Enum' });
+}

package/build/import/type/enum/index.mjs

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

package/build/import/type/exclude/exclude.mjs

@@ -0,0 +1,20 @@
+import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Never } from '../never/index.mjs';
+import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType } from '../guard/type.mjs';
+export function ExcludeResolve(L, R) {
+    return (IsTemplateLiteralType(L) ? ExcludeResolve(TemplateLiteralToUnion(L), R) :
+        IsTemplateLiteralType(R) ? ExcludeResolve(L, TemplateLiteralToUnion(R)) :
+            IsUnionType(L) ? (() => {
+                const narrowed = L.anyOf.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+                return (narrowed.length === 1 ? narrowed[0] : Union(narrowed));
+            })() :
+                ExtendsCheck(L, R) !== ExtendsResult.False ? Never() :
+                    L);
+}
+export function Exclude(unionType, excludedMembers, options = {}) {
+    const E = ExcludeResolve(unionType, excludedMembers);
+    return CloneType(E, options);
+}

package/build/import/type/exclude/index.mjs

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