@sinclair/typebox 0.32.0-dev-1 → 0.32.0-dev-2

package/type/constructor/constructor.js

@@ -1,43 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Constructor = void 0;
-const index_1 = require("../symbols/index");
-const type_1 = require("../clone/type");
-/** `[JavaScript]` Creates a Constructor type */
-function Constructor(parameters, returns, options) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Constructor',
-        type: 'Constructor',
-        parameters: (0, type_1.CloneRest)(parameters),
-        returns: (0, type_1.CloneType)(returns),
-    };
-}
-exports.Constructor = Constructor;

package/type/constructor/index.d.ts

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

package/type/constructor-parameters/constructor-parameters.d.ts

@@ -1,7 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import type { Ensure } from '../helpers/index';
-import type { TConstructor } from '../constructor/index';
-import { type TTuple } from '../tuple/index';
-export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = (Ensure<TTuple<T['parameters']>>);
-/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-export declare function ConstructorParameters<T extends TConstructor<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;

package/type/constructor-parameters/constructor-parameters.js

@@ -1,37 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConstructorParameters = void 0;
-const index_1 = require("../tuple/index");
-const type_1 = require("../clone/type");
-/** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-function ConstructorParameters(schema, options = {}) {
-    return (0, index_1.Tuple)((0, type_1.CloneRest)(schema.parameters), { ...options });
-}
-exports.ConstructorParameters = ConstructorParameters;

package/type/constructor-parameters/index.d.ts

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

package/type/date/date.d.ts

@@ -1,21 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import { Kind } from '../symbols/index';
-export interface DateOptions extends SchemaOptions {
-    /** The exclusive maximum timestamp value */
-    exclusiveMaximumTimestamp?: number;
-    /** The exclusive minimum timestamp value */
-    exclusiveMinimumTimestamp?: number;
-    /** The maximum timestamp value */
-    maximumTimestamp?: number;
-    /** The minimum timestamp value */
-    minimumTimestamp?: number;
-    /** The multiple of timestamp value */
-    multipleOfTimestamp?: number;
-}
-export interface TDate extends TSchema, DateOptions {
-    [Kind]: 'Date';
-    static: Date;
-    type: 'date';
-}
-/** `[JavaScript]` Creates a Date type */
-export declare function Date(options?: DateOptions): TDate;

package/type/date/date.js

@@ -1,40 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Date = void 0;
-const index_1 = require("../symbols/index");
-/** `[JavaScript]` Creates a Date type */
-function Date(options = {}) {
-    return {
-        ...options,
-        [index_1.Kind]: 'Date',
-        type: 'Date',
-    };
-}
-exports.Date = Date;

package/type/date/index.d.ts

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

package/type/deref/deref.d.ts

@@ -1,24 +0,0 @@
-import type { TSchema } from '../schema/index';
-import type { Evaluate } from '../helpers/index';
-import type { TTuple } from '../tuple/index';
-import type { TIntersect } from '../intersect/index';
-import type { TUnion } from '../union/index';
-import type { TPromise } from '../promise/index';
-import type { TAsyncIterator } from '../async-iterator/index';
-import type { TIterator } from '../iterator/index';
-import type { TArray } from '../array/index';
-import type { TConstructor } from '../constructor/index';
-import type { TFunction } from '../function/index';
-import type { TRef } from '../ref/index';
-import type { TObject, TProperties } from '../object/index';
-export type FromRest<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [DerefResolve<L>, ...FromRest<R>] : []);
-type FromProperties<T extends TProperties> = Evaluate<{
-    [K in keyof T]: DerefResolve<T[K]>;
-}>;
-declare function FromProperties(properties: TProperties, references: TSchema[]): TProperties;
-export type DerefResolve<T extends TSchema> = T extends TConstructor<infer S extends TSchema[], infer R extends TSchema> ? TConstructor<FromRest<S>, DerefResolve<R>> : T extends TFunction<infer S extends TSchema[], infer R extends TSchema> ? TFunction<FromRest<S>, DerefResolve<R>> : T extends TIntersect<infer S extends TSchema[]> ? TIntersect<FromRest<S>> : T extends TUnion<infer S extends TSchema[]> ? TUnion<FromRest<S>> : T extends TTuple<infer S extends TSchema[]> ? TTuple<FromRest<S>> : T extends TObject<infer S extends TProperties> ? TObject<FromProperties<S>> : T extends TArray<infer S extends TSchema> ? TArray<DerefResolve<S>> : T extends TPromise<infer S extends TSchema> ? TPromise<DerefResolve<S>> : T extends TAsyncIterator<infer S extends TSchema> ? TAsyncIterator<DerefResolve<S>> : T extends TIterator<infer S extends TSchema> ? TIterator<DerefResolve<S>> : T extends TRef<infer S extends TSchema> ? DerefResolve<S> : T;
-export declare function DerefResolve<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-export type TDeref<T extends TSchema> = DerefResolve<T>;
-/** `[Json]` Creates a dereferenced type */
-export declare function Deref<T extends TSchema>(schema: T, references: TSchema[]): TDeref<T>;
-export {};

package/type/deref/deref.js

@@ -1,136 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deref = exports.DerefResolve = void 0;
-const type_1 = require("../clone/type");
-const index_1 = require("../discard/index");
-const value_1 = require("../guard/value");
-const type_2 = require("../guard/type");
-function FromRest(schema, references) {
-    return schema.map((schema) => Deref(schema, references));
-}
-// prettier-ignore
-function FromProperties(properties, references) {
-    return globalThis.Object.getOwnPropertyNames(properties).reduce((acc, key) => {
-        return { ...acc, [key]: Deref(properties[key], references) };
-    }, {});
-}
-// prettier-ignore
-function FromConstructor(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.parameters = FromRest(clone.parameters, references);
-    clone.returns = Deref(clone.returns, references);
-    return clone;
-}
-// prettier-ignore
-function FromFunction(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.parameters = FromRest(clone.parameters, references);
-    clone.returns = Deref(clone.returns, references);
-    return clone;
-}
-// prettier-ignore
-function FromIntersect(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.allOf = FromRest(clone.allOf, references);
-    return clone;
-}
-// prettier-ignore
-function FromUnion(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.anyOf = FromRest(clone.anyOf, references);
-    return clone;
-}
-// prettier-ignore
-function FromTuple(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    if ((0, value_1.IsUndefined)(clone.items))
-        return clone;
-    clone.items = FromRest(clone.items, references);
-    return clone;
-}
-// prettier-ignore
-function FromArray(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
-}
-// prettier-ignore
-function FromObject(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.properties = FromProperties(clone.properties, references);
-    return clone;
-}
-// prettier-ignore
-function FromPromise(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.item = Deref(clone.item, references);
-    return clone;
-}
-// prettier-ignore
-function FromAsyncIterator(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
-}
-// prettier-ignore
-function FromIterator(schema, references) {
-    const clone = (0, type_1.CloneType)(schema);
-    clone.items = Deref(clone.items, references);
-    return clone;
-}
-// prettier-ignore
-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 = (0, index_1.Discard)(target, ['$id']);
-    return Deref(discard, references);
-}
-// prettier-ignore
-function DerefResolve(schema, references) {
-    return ((0, type_2.TConstructor)(schema) ? FromConstructor(schema, references) :
-        (0, type_2.TFunction)(schema) ? FromFunction(schema, references) :
-            (0, type_2.TIntersect)(schema) ? FromIntersect(schema, references) :
-                (0, type_2.TUnion)(schema) ? FromUnion(schema, references) :
-                    (0, type_2.TTuple)(schema) ? FromTuple(schema, references) :
-                        (0, type_2.TArray)(schema) ? FromArray(schema, references) :
-                            (0, type_2.TObject)(schema) ? FromObject(schema, references) :
-                                (0, type_2.TPromise)(schema) ? FromPromise(schema, references) :
-                                    (0, type_2.TAsyncIterator)(schema) ? FromAsyncIterator(schema, references) :
-                                        (0, type_2.TIterator)(schema) ? FromIterator(schema, references) :
-                                            (0, type_2.TRef)(schema) ? FromRef(schema, references) :
-                                                schema);
-}
-exports.DerefResolve = DerefResolve;
-/** `[Json]` Creates a dereferenced type */
-function Deref(schema, references) {
-    return DerefResolve(schema, references);
-}
-exports.Deref = Deref;

package/type/deref/index.d.ts

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

package/type/discard/index.d.ts

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

package/type/enum/enum.d.ts

@@ -1,14 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import { type TLiteral } from '../literal/index';
-import { Kind, Hint } from '../symbols/index';
-export type TEnumRecord = Record<TEnumKey, TEnumValue>;
-export type TEnumValue = string | number;
-export type TEnumKey = string;
-export interface TEnum<T extends Record<string, string | number> = Record<string, string | number>> extends TSchema {
-    [Kind]: 'Union';
-    [Hint]: 'Enum';
-    static: T[keyof T];
-    anyOf: TLiteral<T[keyof T]>[];
-}
-/** `[Json]` Creates a Enum type */
-export declare function Enum<V extends TEnumValue, T extends Record<TEnumKey, V>>(item: T, options?: SchemaOptions): TEnum<T>;

package/type/enum/enum.js

@@ -1,46 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Enum = void 0;
-const index_1 = require("../literal/index");
-const index_2 = require("../symbols/index");
-const index_3 = require("../union/index");
-const value_1 = require("../guard/value");
-/** `[Json]` Creates a Enum type */
-function Enum(item, options = {}) {
-    if ((0, value_1.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) => (0, index_1.Literal)(value));
-    return (0, index_3.Union)(anyOf, { ...options, [index_2.Hint]: 'Enum' });
-}
-exports.Enum = Enum;

package/type/enum/index.d.ts

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

package/type/exclude/exclude.d.ts

@@ -1,21 +0,0 @@
-import type { TSchema, SchemaOptions } from '../schema/index';
-import type { UnionToTuple, AssertRest, AssertType, Assert } from '../helpers/index';
-import { type TTemplateLiteral } from '../template-literal/index';
-import { type TUnion } from '../union/index';
-import { type TNever } from '../never/index';
-import { type TLiteral } from '../literal/index';
-import { type Static } from '../static/index';
-import { UnionResolve } from '../union/index';
-type ExcludeTemplateLiteralResult<T extends string> = UnionResolve<AssertRest<UnionToTuple<{
-    [K in T]: TLiteral<K>;
-}[T]>>>;
-type ExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = (Exclude<Static<T>, Static<U>> extends infer S ? ExcludeTemplateLiteralResult<Assert<S, string>> : never);
-type ExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
-    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
-}[number]>> extends infer R extends TSchema[] ? UnionResolve<R> : never;
-type ExcludeResolve<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? ExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? ExcludeArray<S, U> : T extends U ? TNever : T;
-export declare function ExcludeResolve<L extends TSchema, R extends TSchema>(L: L, R: R): ExcludeResolve<L, R>;
-export type TExclude<T extends TSchema, U extends TSchema> = ExcludeResolve<T, U>;
-/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-export declare function Exclude<L extends TSchema, R extends TSchema>(unionType: L, excludedMembers: R, options?: SchemaOptions): TExclude<L, R>;
-export {};

package/type/exclude/exclude.js

@@ -1,54 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@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.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Exclude = exports.ExcludeResolve = void 0;
-const index_1 = require("../template-literal/index");
-const index_2 = require("../union/index");
-const index_3 = require("../never/index");
-const index_4 = require("../extends/index");
-const type_1 = require("../clone/type");
-const type_2 = require("../guard/type");
-// prettier-ignore
-function ExcludeResolve(L, R) {
-    return ((0, type_2.TTemplateLiteral)(L) ? ExcludeResolve((0, index_1.TemplateLiteralToUnion)(L), R) :
-        (0, type_2.TTemplateLiteral)(R) ? ExcludeResolve(L, (0, index_1.TemplateLiteralToUnion)(R)) :
-            (0, type_2.TUnion)(L) ? (() => {
-                const narrowed = L.anyOf.filter((inner) => (0, index_4.ExtendsCheck)(inner, R) === index_4.ExtendsResult.False);
-                return (narrowed.length === 1 ? narrowed[0] : (0, index_2.Union)(narrowed));
-            })() :
-                (0, index_4.ExtendsCheck)(L, R) !== index_4.ExtendsResult.False ? (0, index_3.Never)() :
-                    L);
-}
-exports.ExcludeResolve = ExcludeResolve;
-/** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
-function Exclude(unionType, excludedMembers, options = {}) {
-    const E = ExcludeResolve(unionType, excludedMembers);
-    return (0, type_1.CloneType)(E, options);
-}
-exports.Exclude = Exclude;

package/type/exclude/index.d.ts

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

package/type/extends/extends-check.d.ts

@@ -1,9 +0,0 @@
-import { type TSchema } from '../schema/index';
-export declare class ExtendsResolverError extends Error {
-}
-export declare enum ExtendsResult {
-    Union = 0,
-    True = 1,
-    False = 2
-}
-export declare function ExtendsCheck(left: TSchema, right: TSchema): ExtendsResult;