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

package/type/readonly-optional/index.d.ts

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

package/type/readonly-optional/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./readonly-optional"), exports);

package/type/readonly-optional/readonly-optional.d.ts

@@ -0,0 +1,5 @@
+import type { TSchema } from '../schema/index';
+import { type TReadonly } from '../readonly/index';
+import { type TOptional } from '../optional/index';
+export type TReadonlyOptional<T extends TSchema> = TOptional<T> & TReadonly<T>;
+export declare function ReadonlyOptional<T extends TSchema>(schema: T): TReadonly<TOptional<T>>;

package/type/readonly-optional/readonly-optional.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyOptional = void 0;
+const index_1 = require("../readonly/index");
+const index_2 = require("../optional/index");
+function ReadonlyOptional(schema) {
+    return (0, index_1.Readonly)((0, index_2.Optional)(schema));
+}
+exports.ReadonlyOptional = ReadonlyOptional;

package/type/record/index.d.ts

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

package/type/record/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./record"), exports);

package/type/record/record.d.ts

@@ -0,0 +1,54 @@
+import type { TSchema } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Evaluate, Ensure, Assert } from '../helpers/index';
+import { type TObject, type TProperties, type TAdditionalProperties, type ObjectOptions } from '../object/index';
+import { type TLiteral, TLiteralValue } from '../literal/index';
+import { type TNever } from '../never/index';
+import { type TUnion } from '../union/index';
+import { type TString } from '../string/index';
+import { type TInteger } from '../integer/index';
+import { type TNumber } from '../number/index';
+import { type TEnum } from '../enum/index';
+import { TTemplateLiteral, IsTemplateLiteralFinite } from '../template-literal/index';
+import { Kind } from '../symbols/index';
+type FromTemplateLiteralKeyInfinite<K extends TTemplateLiteral, T extends TSchema> = Ensure<TRecord<K, T>>;
+type FromTemplateLiteralKeyFinite<K extends TTemplateLiteral, T extends TSchema, I extends string = Static<K>> = (Ensure<TObject<Evaluate<{
+    [_ in I]: T;
+}>>>);
+type FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema> = IsTemplateLiteralFinite<K> extends false ? FromTemplateLiteralKeyInfinite<K, T> : FromTemplateLiteralKeyFinite<K, T>;
+declare function FromTemplateLiteralKey<K extends TTemplateLiteral, T extends TSchema>(K: K, T: T): FromTemplateLiteralKey<K, T>;
+type FromEnumKey<K extends Record<string, string | number>, T extends TSchema> = Ensure<TObject<{
+    [_ in K[keyof K]]: T;
+}>>;
+type FromUnionKeyLiteralString<K extends TLiteral<string>, T extends TSchema> = {
+    [_ in K['const']]: T;
+};
+type FromUnionKeyLiteralNumber<K extends TLiteral<number>, T extends TSchema> = {
+    [_ in K['const']]: T;
+};
+type FromUnionKeyRest<K extends TSchema[], T extends TSchema> = K extends [infer L extends TSchema, ...infer R extends TSchema[]] ? (L extends TUnion<infer S> ? FromUnionKeyRest<S, T> & FromUnionKeyRest<R, T> : L extends TLiteral<string> ? FromUnionKeyLiteralString<L, T> & FromUnionKeyRest<R, T> : L extends TLiteral<number> ? FromUnionKeyLiteralNumber<L, T> & FromUnionKeyRest<R, T> : {}) : {};
+type FromUnionKey<K extends TSchema[], T extends TSchema, P extends TProperties = FromUnionKeyRest<K, T>> = (Ensure<TObject<P>>);
+declare function FromUnionKey<K extends TSchema[], T extends TSchema>(K: K, T: T): FromUnionKey<K, T>;
+type FromLiteralKey<K extends TLiteralValue, T extends TSchema> = (Ensure<TObject<{
+    [_ in Assert<K, PropertyKey>]: T;
+}>>);
+declare function FromLiteralKey<K extends TLiteralValue, T extends TSchema>(K: K, T: T): FromLiteralKey<K, T>;
+type FromStringKey<_ extends TString, T extends TSchema> = (Ensure<TRecord<TString, T>>);
+declare function FromStringKey<K extends TString, T extends TSchema>(K: K, T: T): FromStringKey<K, T>;
+type FromIntegerKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
+declare function FromIntegerKey<K extends TInteger, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
+type FromNumberKey<_ extends TSchema, T extends TSchema> = (Ensure<TRecord<TNumber, T>>);
+declare function FromNumberKey<K extends TNumber, T extends TSchema>(_: K, T: T): FromIntegerKey<K, T>;
+export type RecordResolve<K extends TSchema, T extends TSchema> = K extends TEnum<infer S> ? FromEnumKey<S, T> : K extends TUnion<infer S> ? FromUnionKey<S, T> : K extends TTemplateLiteral ? FromTemplateLiteralKey<K, T> : K extends TLiteral<infer S> ? FromLiteralKey<S, T> : K extends TInteger ? FromIntegerKey<K, T> : K extends TNumber ? FromNumberKey<K, T> : K extends TString ? FromStringKey<K, T> : TNever;
+export declare function RecordResolve<K extends TSchema, T extends TSchema>(K: K, T: T): RecordResolve<K, T>;
+export interface TRecord<K extends TSchema = TSchema, T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Record';
+    static: Record<Assert<Static<K>, string | number>, Static<T, this['params']>>;
+    type: 'object';
+    patternProperties: {
+        [pattern: string]: T;
+    };
+    additionalProperties: TAdditionalProperties;
+}
+export declare function Record<K extends TSchema, T extends TSchema>(K: K, T: T, options?: ObjectOptions): RecordResolve<K, T>;
+export {};

package/type/record/record.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Record = exports.RecordResolve = void 0;
+const index_1 = require("../object/index");
+const index_2 = require("../never/index");
+const index_3 = require("../union/index");
+const index_4 = require("../template-literal/index");
+const index_5 = require("../patterns/index");
+const index_6 = require("../indexed/index");
+const index_7 = require("../symbols/index");
+const type_1 = require("../clone/type");
+const value_1 = require("../guard/value");
+const type_2 = require("../guard/type");
+function FromPattern(pattern, T) {
+    return { [index_7.Kind]: 'Record', type: 'object', patternProperties: { [pattern]: (0, type_1.CloneType)(T) } };
+}
+function FromKeys(keys, T) {
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: (0, type_1.CloneType)(T) }), {});
+    return (0, index_1.Object)(properties, { [index_7.Hint]: 'Record' });
+}
+function FromTemplateLiteralKey(K, T) {
+    const expression = (0, index_4.TemplateLiteralParseExact)(K.pattern);
+    return ((0, index_4.IsTemplateLiteralFinite)(expression)
+        ? FromKeys((0, index_6.IndexedKeyResolve)(K), T)
+        : FromPattern(K.pattern, T));
+}
+function FromUnionKey(K, T) {
+    return FromKeys((0, index_6.IndexedKeyResolve)((0, index_3.Union)(K)), T);
+}
+function FromLiteralKey(K, T) {
+    return FromKeys([K.toString()], T);
+}
+function FromStringKey(K, T) {
+    const pattern = (0, value_1.IsUndefined)(K.pattern) ? index_5.PatternStringExact : K.pattern;
+    return FromPattern(pattern, T);
+}
+function FromIntegerKey(_, T) {
+    return FromPattern(index_5.PatternNumberExact, T);
+}
+function FromNumberKey(_, T) {
+    return FromPattern(index_5.PatternNumberExact, T);
+}
+function RecordResolve(K, T) {
+    return ((0, type_2.TUnion)(K) ? FromUnionKey(K.anyOf, T) :
+        (0, type_2.TTemplateLiteral)(K) ? FromTemplateLiteralKey(K, T) :
+            (0, type_2.TLiteral)(K) ? FromLiteralKey(K.const, T) :
+                (0, type_2.TString)(K) ? FromStringKey(K, T) :
+                    (0, type_2.TInteger)(K) ? FromIntegerKey(K, T) :
+                        (0, type_2.TNumber)(K) ? FromNumberKey(K, T) :
+                            (0, index_2.Never)());
+}
+exports.RecordResolve = RecordResolve;
+function Record(K, T, options = {}) {
+    return (0, type_1.CloneType)(RecordResolve(K, T), options);
+}
+exports.Record = Record;

package/type/recursive/index.d.ts

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

package/type/recursive/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./recursive"), exports);

package/type/recursive/recursive.d.ts

@@ -0,0 +1,14 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind, Hint } from '../symbols/index';
+import { Static } from '../static/index';
+export interface TThis extends TSchema {
+    [Kind]: 'This';
+    static: this['params'][0];
+    $ref: string;
+}
+export type RecursiveResolve<T extends TSchema> = Static<T, [RecursiveResolve<T>]>;
+export interface TRecursive<T extends TSchema> extends TSchema {
+    [Hint]: 'Recursive';
+    static: RecursiveResolve<T>;
+}
+export declare function Recursive<T extends TSchema>(callback: (thisType: TThis) => T, options?: SchemaOptions): TRecursive<T>;

package/type/recursive/recursive.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Recursive = void 0;
+const type_1 = require("../clone/type");
+const value_1 = require("../guard/value");
+const index_1 = require("../symbols/index");
+let Ordinal = 0;
+function Recursive(callback, options = {}) {
+    if ((0, value_1.IsUndefined)(options.$id))
+        options.$id = `T${Ordinal++}`;
+    const thisType = callback({ [index_1.Kind]: 'This', $ref: `${options.$id}` });
+    thisType.$id = options.$id;
+    return (0, type_1.CloneType)({
+        ...options,
+        [index_1.Hint]: 'Recursive',
+        ...thisType,
+    });
+}
+exports.Recursive = Recursive;

package/type/ref/index.d.ts

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

package/type/ref/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ref"), exports);

package/type/ref/ref.d.ts

@@ -0,0 +1,10 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import { Kind } from '../symbols/index';
+export interface TRef<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Ref';
+    static: Static<T, this['params']>;
+    $ref: string;
+}
+export declare function Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
+export declare function Ref<T extends TSchema>($ref: string, options?: SchemaOptions): TRef<T>;

package/type/ref/ref.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ref = void 0;
+const index_1 = require("../symbols/index");
+const value_1 = require("../guard/value");
+function Ref(unresolved, options = {}) {
+    if ((0, value_1.IsString)(unresolved))
+        return { ...options, [index_1.Kind]: 'Ref', $ref: unresolved };
+    if ((0, value_1.IsUndefined)(unresolved.$id))
+        throw new Error('Reference target type must specify an $id');
+    return {
+        ...options,
+        [index_1.Kind]: 'Ref',
+        $ref: unresolved.$id,
+    };
+}
+exports.Ref = Ref;

package/type/regexp/index.d.ts

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

package/type/regexp/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./regexp"), exports);

package/type/regexp/regexp.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TString } from '../string/index';
+export type TRegExp = TString;
+export declare function RegExp(pattern: string, options?: SchemaOptions): TRegExp;
+export declare function RegExp(regex: RegExp, options?: SchemaOptions): TRegExp;

package/type/regexp/regexp.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegExp = void 0;
+const value_1 = require("../guard/value");
+const index_1 = require("../symbols/index");
+function RegExp(unresolved, options = {}) {
+    const pattern = (0, value_1.IsString)(unresolved) ? unresolved : unresolved.source;
+    return { ...options, [index_1.Kind]: 'String', type: 'string', pattern };
+}
+exports.RegExp = RegExp;

package/type/registry/format.d.ts

@@ -0,0 +1,7 @@
+export type FormatRegistryValidationFunction = (value: string) => boolean;
+export declare function Entries(): Map<string, FormatRegistryValidationFunction>;
+export declare function Clear(): void;
+export declare function Delete(format: string): boolean;
+export declare function Has(format: string): boolean;
+export declare function Set(format: string, func: FormatRegistryValidationFunction): void;
+export declare function Get(format: string): FormatRegistryValidationFunction | undefined;

package/type/registry/format.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Get = exports.Set = exports.Has = exports.Delete = exports.Clear = exports.Entries = void 0;
+const map = new Map();
+function Entries() {
+    return new Map(map);
+}
+exports.Entries = Entries;
+function Clear() {
+    return map.clear();
+}
+exports.Clear = Clear;
+function Delete(format) {
+    return map.delete(format);
+}
+exports.Delete = Delete;
+function Has(format) {
+    return map.has(format);
+}
+exports.Has = Has;
+function Set(format, func) {
+    map.set(format, func);
+}
+exports.Set = Set;
+function Get(format) {
+    return map.get(format);
+}
+exports.Get = Get;

package/type/registry/index.d.ts

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

package/type/registry/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeRegistry = exports.FormatRegistry = void 0;
+exports.FormatRegistry = require("./format");
+exports.TypeRegistry = require("./type");

package/type/registry/type.d.ts

@@ -0,0 +1,7 @@
+export type TypeRegistryValidationFunction<TSchema> = (schema: TSchema, value: unknown) => boolean;
+export declare function Entries(): Map<string, TypeRegistryValidationFunction<any>>;
+export declare function Clear(): void;
+export declare function Delete(kind: string): boolean;
+export declare function Has(kind: string): boolean;
+export declare function Set<TSchema = unknown>(kind: string, func: TypeRegistryValidationFunction<TSchema>): void;
+export declare function Get(kind: string): TypeRegistryValidationFunction<any> | undefined;

package/type/registry/type.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Get = exports.Set = exports.Has = exports.Delete = exports.Clear = exports.Entries = void 0;
+const map = new Map();
+function Entries() {
+    return new Map(map);
+}
+exports.Entries = Entries;
+function Clear() {
+    return map.clear();
+}
+exports.Clear = Clear;
+function Delete(kind) {
+    return map.delete(kind);
+}
+exports.Delete = Delete;
+function Has(kind) {
+    return map.has(kind);
+}
+exports.Has = Has;
+function Set(kind, func) {
+    map.set(kind, func);
+}
+exports.Set = Set;
+function Get(kind) {
+    return map.get(kind);
+}
+exports.Get = Get;

package/type/required/index.d.ts

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

package/type/required/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./required"), exports);

package/type/required/required.d.ts

@@ -0,0 +1,22 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Evaluate } from '../helpers/index';
+import { type TReadonlyOptional } from '../readonly-optional/index';
+import { type TOptional } from '../optional/index';
+import { type TReadonly } from '../readonly/index';
+import { type TRecursive } from '../recursive/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TObject, type TProperties } from '../object/index';
+type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromIntersect<R>] : []);
+declare function FromIntersect<T extends TSchema[]>(T: [...T]): FromIntersect<T>;
+type FromUnion<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [RequiredResolve<L>, ...FromUnion<R>] : []);
+declare function FromUnion<T extends TSchema[]>(T: [...T]): FromUnion<T>;
+type FromProperties<T extends TProperties> = Evaluate<{
+    [K in keyof T]: T[K] extends (TReadonlyOptional<infer S>) ? TReadonly<S> : T[K] extends (TReadonly<infer S>) ? TReadonly<S> : T[K] extends (TOptional<infer S>) ? S : T[K];
+}>;
+declare function FromProperties<T extends TProperties>(T: T): TProperties;
+export type RequiredResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<RequiredResolve<S>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S>> : T extends TUnion<infer S> ? TUnion<FromUnion<S>> : T extends TObject<infer S> ? TObject<FromProperties<S>> : TObject<{}>);
+export declare function RequiredResolve<T extends TSchema>(T: T): RequiredResolve<T>;
+export type TRequired<T extends TSchema> = RequiredResolve<T>;
+export declare function Required<T extends TSchema>(T: T, options?: SchemaOptions): TRequired<T>;
+export {};

package/type/required/required.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Required = exports.RequiredResolve = void 0;
+const index_1 = require("../intersect/index");
+const index_2 = require("../union/index");
+const index_3 = require("../object/index");
+const index_4 = require("../symbols/index");
+const type_1 = require("../clone/type");
+const index_5 = require("../discard/index");
+const type_2 = require("../guard/type");
+function FromIntersect(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [RequiredResolve(L), ...FromIntersect(R)]
+        : []);
+}
+function FromUnion(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [RequiredResolve(L), ...FromUnion(R)]
+        : []);
+}
+function FromProperties(T) {
+    return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K) => {
+        return { ...Acc, [K]: (0, index_5.Discard)(T[K], [index_4.OptionalKind]) };
+    }, {});
+}
+function RequiredResolve(T) {
+    return ((0, type_2.TIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf)) :
+        (0, type_2.TUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf)) :
+            (0, type_2.TObject)(T) ? (0, index_3.Object)(FromProperties(T.properties)) :
+                (0, index_3.Object)({}));
+}
+exports.RequiredResolve = RequiredResolve;
+function Required(T, options = {}) {
+    const D = (0, index_5.Discard)(T, [index_4.TransformKind, '$id', 'required']);
+    const R = (0, type_1.CloneType)(RequiredResolve(T), options);
+    return { ...D, ...R };
+}
+exports.Required = Required;

package/type/rest/index.d.ts

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

package/type/rest/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rest"), exports);

package/type/rest/rest.d.ts

@@ -0,0 +1,9 @@
+import type { TSchema } from '../schema/index';
+import type { TIntersect } from '../intersect/index';
+import type { TUnion } from '../union/index';
+import type { TTuple } from '../tuple/index';
+export type RestResolve<T extends TSchema> = T extends TIntersect<infer S> ? [...S] : T extends TUnion<infer S> ? [...S] : T extends TTuple<infer S> ? [...S] : [
+];
+export declare function RestResolve<T extends TSchema>(T: T): RestResolve<T>;
+export type TRest<T extends TSchema> = RestResolve<T>;
+export declare function Rest<T extends TSchema>(T: T): TRest<T>;

package/type/rest/rest.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rest = exports.RestResolve = void 0;
+const type_1 = require("../clone/type");
+const type_2 = require("../guard/type");
+function RestResolve(T) {
+    return ((0, type_2.TIntersect)(T) ? [...T.allOf] : (0, type_2.TUnion)(T) ? [...T.anyOf] : (0, type_2.TTuple)(T) ? [...(T.items ?? [])] : []);
+}
+exports.RestResolve = RestResolve;
+function Rest(T) {
+    return (0, type_1.CloneRest)(RestResolve(T));
+}
+exports.Rest = Rest;

package/type/return-type/index.d.ts

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

package/type/return-type/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./return-type"), exports);

package/type/return-type/return-type.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaOptions } from '../schema/index';
+import type { TFunction } from '../function/index';
+export type TReturnType<T extends TFunction> = T['returns'];
+export declare function ReturnType<T extends TFunction<any[], any>>(schema: T, options?: SchemaOptions): TReturnType<T>;

package/type/return-type/return-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnType = void 0;
+const type_1 = require("../clone/type");
+function ReturnType(schema, options = {}) {
+    return (0, type_1.CloneType)(schema.returns, options);
+}
+exports.ReturnType = ReturnType;

package/type/schema/anyschema.d.ts

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

package/type/schema/anyschema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/type/schema/index.d.ts

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