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

package/type/object/object.d.ts

@@ -0,0 +1,39 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Evaluate } from '../helpers/index';
+import type { TReadonly } from '../readonly/index';
+import type { TOptional } from '../optional/index';
+import { Kind } from '../symbols/index';
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
+type ReadonlyOptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? K : never) : never;
+}[keyof T];
+type ReadonlyPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TReadonly<TSchema> ? (T[K] extends TOptional<T[K]> ? never : K) : never;
+}[keyof T];
+type OptionalPropertyKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends TOptional<TSchema> ? (T[K] extends TReadonly<T[K]> ? never : K) : never;
+}[keyof T];
+type RequiredPropertyKeys<T extends TProperties> = keyof Omit<T, ReadonlyOptionalPropertyKeys<T> | ReadonlyPropertyKeys<T> | OptionalPropertyKeys<T>>;
+type PropertiesResolve<T extends TProperties, R extends Record<keyof any, unknown>> = Evaluate<(Readonly<Partial<Pick<R, ReadonlyOptionalPropertyKeys<T>>>> & Readonly<Pick<R, ReadonlyPropertyKeys<T>>> & Partial<Pick<R, OptionalPropertyKeys<T>>> & Required<Pick<R, RequiredPropertyKeys<T>>>)>;
+export type ObjectResolve<T extends TProperties, P extends unknown[]> = PropertiesResolve<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+export type TAdditionalProperties = undefined | TSchema | boolean;
+export interface ObjectOptions extends SchemaOptions {
+    additionalProperties?: TAdditionalProperties;
+    minProperties?: number;
+    maxProperties?: number;
+}
+export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
+    [Kind]: 'Object';
+    static: ObjectResolve<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required?: string[];
+}
+export declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+export declare const Object: typeof _Object;
+export {};

package/type/object/object.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Object = exports._Object = void 0;
+const type_1 = require("../clone/type");
+const index_1 = require("../symbols/index");
+const type_2 = require("../guard/type");
+function _Object(properties, options = {}) {
+    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
+    const optionalKeys = propertyKeys.filter((key) => (0, type_2.TOptional)(properties[key]));
+    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+    const clonedAdditionalProperties = (0, type_2.TSchema)(options.additionalProperties) ? { additionalProperties: (0, type_1.CloneType)(options.additionalProperties) } : {};
+    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: (0, type_1.CloneType)(properties[key]) }), {});
+    return (requiredKeys.length > 0
+        ? { ...options, ...clonedAdditionalProperties, [index_1.Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
+        : { ...options, ...clonedAdditionalProperties, [index_1.Kind]: 'Object', type: 'object', properties: clonedProperties });
+}
+exports._Object = _Object;
+exports.Object = _Object;

package/type/omit/index.d.ts

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

package/type/omit/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("./omit"), exports);

package/type/omit/omit.d.ts

@@ -0,0 +1,19 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TupleToUnion, Evaluate } from '../helpers/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';
+import { IndexedKeyResolve } from '../indexed/index';
+type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromIntersect<R, K>] : [];
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
+type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [OmitResolve<L, K>, ...FromUnion<R, K>] : [];
+declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
+type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Omit<T, I>>;
+declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): TProperties;
+export type OmitResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<OmitResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
+export declare function OmitResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): OmitResolve<T, K>;
+export type TOmit<T extends TSchema, K extends PropertyKey[]> = OmitResolve<T, K>;
+export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
+export {};

package/type/omit/omit.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Omit = exports.OmitResolve = void 0;
+const index_1 = require("../intersect/index");
+const index_2 = require("../union/index");
+const index_3 = require("../object/index");
+const index_4 = require("../indexed/index");
+const index_5 = require("../discard/index");
+const index_6 = require("../symbols/index");
+const type_1 = require("../clone/type");
+const type_2 = require("../guard/type");
+function FromIntersect(T, K) {
+    return T.map((T) => OmitResolve(T, K));
+}
+function FromUnion(T, K) {
+    return T.map((T) => OmitResolve(T, K));
+}
+function FromProperty(T, K) {
+    const { [K]: _, ...R } = T;
+    return R;
+}
+function FromProperties(T, K) {
+    return K.reduce((T, K2) => {
+        return FromProperty(T, K2);
+    }, T);
+}
+function OmitResolve(T, K) {
+    return ((0, type_2.TIntersect)(T) ? (0, index_1.Intersect)(FromIntersect(T.allOf, K)) :
+        (0, type_2.TUnion)(T) ? (0, index_2.Union)(FromUnion(T.anyOf, K)) :
+            (0, type_2.TObject)(T) ? (0, index_3.Object)(FromProperties(T.properties, K)) :
+                (0, index_3.Object)({}));
+}
+exports.OmitResolve = OmitResolve;
+function Omit(T, K, options = {}) {
+    const I = (0, type_2.TSchema)(K) ? (0, index_4.IndexedKeyResolve)(K) : K;
+    const D = (0, index_5.Discard)(T, [index_6.TransformKind, '$id', 'required']);
+    const R = (0, type_1.CloneType)(OmitResolve(T, I), options);
+    return { ...D, ...R };
+}
+exports.Omit = Omit;

package/type/operators/index.d.ts

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

package/type/operators/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("./operators"), exports);

package/type/operators/operators.d.ts

@@ -0,0 +1,16 @@
+export type OperatorIncludes<T extends PropertyKey[], S extends PropertyKey> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? S extends L ? true : OperatorIncludes<R, S> : false);
+export declare function OperatorIncludes<T extends PropertyKey[], S extends PropertyKey>(T: [...T], S: S): OperatorIncludes<T, S>;
+export type OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? OperatorSubset<R, S> : false : true;
+export declare function OperatorSubset<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorSubset<T, S>;
+export type OperatorDistinct<T extends PropertyKey[], Acc extends PropertyKey[] = []> = T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<Acc, L> extends false ? OperatorDistinct<R, [...Acc, L]> : OperatorDistinct<R, [...Acc]> : Acc;
+export declare function OperatorDistinct<T extends PropertyKey[]>(T: [...T], Acc?: PropertyKey[]): OperatorDistinct<T>;
+export type OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [L, ...OperatorIntersect<R, S>] : [...OperatorIntersect<R, S>] : []);
+export declare function OperatorIntersect<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorIntersect<T, S>;
+export type OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorUnion<R, S>] : [L, ...OperatorUnion<R, S>] : S);
+export declare function OperatorUnion<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorUnion<T, S>;
+export type OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]> = (T extends [infer L extends PropertyKey, ...infer R extends PropertyKey[]] ? OperatorIncludes<S, L> extends true ? [...OperatorComplement<R, S>] : [L, ...OperatorComplement<R, S>] : []);
+export declare function OperatorComplement<T extends PropertyKey[], S extends PropertyKey[]>(T: [...T], S: [...S]): OperatorComplement<T, S>;
+export type OperatorIntersectMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorIntersect<L, OperatorIntersectMany<R>> : []);
+export declare function OperatorIntersectMany<T extends PropertyKey[][]>(T: [...T]): OperatorIntersectMany<T>;
+export type OperatorUnionMany<T extends PropertyKey[][]> = (T extends [infer L extends PropertyKey[]] ? L : T extends [infer L extends PropertyKey[], ...infer R extends PropertyKey[][]] ? OperatorUnion<L, OperatorUnionMany<R>> : []);
+export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T]): OperatorUnionMany<T>;

package/type/operators/operators.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorUnionMany = exports.OperatorIntersectMany = exports.OperatorComplement = exports.OperatorUnion = exports.OperatorIntersect = exports.OperatorDistinct = exports.OperatorSubset = exports.OperatorIncludes = void 0;
+function OperatorIncludes(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? S === L
+            ? true
+            : OperatorIncludes(R, S)
+        : false);
+}
+exports.OperatorIncludes = OperatorIncludes;
+function OperatorSubset(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? OperatorSubset(R, S)
+            : false
+        : true);
+}
+exports.OperatorSubset = OperatorSubset;
+function OperatorDistinct(T, Acc = []) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(Acc, L) === false
+            ? OperatorDistinct(R, [...Acc, L])
+            : OperatorDistinct(R, [...Acc])
+        : Acc);
+}
+exports.OperatorDistinct = OperatorDistinct;
+function OperatorIntersect(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? [L, ...OperatorIntersect(R, S)]
+            : [...OperatorIntersect(R, S)]
+        : []);
+}
+exports.OperatorIntersect = OperatorIntersect;
+function OperatorUnion(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? [...OperatorUnion(R, S)]
+            : [L, ...OperatorUnion(R, S)]
+        : S);
+}
+exports.OperatorUnion = OperatorUnion;
+function OperatorComplement(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? [...OperatorComplement(R, S)]
+            : [L, ...OperatorComplement(R, S)]
+        : []);
+}
+exports.OperatorComplement = OperatorComplement;
+function OperatorIntersectMany(T) {
+    return (T.length === 1
+        ? T[0]
+        : (() => {
+            const [L, ...R] = T;
+            return (L.length > 0
+                ? OperatorIntersect(L, OperatorIntersectMany(R))
+                : []);
+        })());
+}
+exports.OperatorIntersectMany = OperatorIntersectMany;
+function OperatorUnionMany(T) {
+    return (T.length === 1
+        ? T[0]
+        : (() => {
+            const [L, ...R] = T;
+            return T.length > 0 ? OperatorUnion(L, OperatorUnionMany(R)) : [];
+        })());
+}
+exports.OperatorUnionMany = OperatorUnionMany;

package/type/optional/index.d.ts

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

package/type/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("./optional"), exports);

package/type/optional/optional.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema } from '../schema/index';
+import { OptionalKind } from '../symbols/index';
+export type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+export declare function Optional<T extends TSchema>(schema: T): TOptional<T>;

package/type/optional/optional.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+function Optional(schema) {
+    return { ...(0, type_1.CloneType)(schema), [index_1.OptionalKind]: 'Optional' };
+}
+exports.Optional = Optional;

package/type/parameters/index.d.ts

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

package/type/parameters/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("./parameters"), exports);

package/type/parameters/parameters.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TFunction } from '../function/index';
+import type { Ensure } from '../helpers/index';
+import { type TTuple } from '../tuple/index';
+export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
+export declare function Parameters<T extends TFunction<TSchema[], TSchema>>(schema: T, options?: SchemaOptions): TParameters<T>;

package/type/parameters/parameters.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parameters = void 0;
+const index_1 = require("../tuple/index");
+const type_1 = require("../clone/type");
+function Parameters(schema, options = {}) {
+    return (0, index_1.Tuple)((0, type_1.CloneRest)(schema.parameters), { ...options });
+}
+exports.Parameters = Parameters;

package/type/partial/index.d.ts

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

package/type/partial/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("./partial"), exports);

package/type/partial/partial.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 TObject, type TProperties } from '../object/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+type FromIntersect<T extends TSchema[]> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PartialResolve<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[]] ? [PartialResolve<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>) ? TReadonlyOptional<S> : T[K] extends (TReadonly<infer S>) ? TReadonlyOptional<S> : T[K] extends (TOptional<infer S>) ? TOptional<S> : TOptional<T[K]>;
+}>;
+declare function FromProperties<T extends TProperties>(T: T): TProperties;
+export type PartialResolve<T extends TSchema> = (T extends TRecursive<infer S> ? TRecursive<PartialResolve<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 PartialResolve<T extends TSchema>(T: T): PartialResolve<T>;
+export type TPartial<T extends TSchema> = PartialResolve<T>;
+export declare function Partial<T extends TSchema>(T: T, options?: SchemaOptions): TPartial<T>;
+export {};

package/type/partial/partial.js

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

package/type/patterns/index.d.ts

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

package/type/patterns/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("./patterns"), exports);

package/type/patterns/patterns.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = void 0;
+exports.PatternBoolean = '(true|false)';
+exports.PatternNumber = '(0|[1-9][0-9]*)';
+exports.PatternString = '(.*)';
+exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
+exports.PatternNumberExact = `^${exports.PatternNumber}$`;
+exports.PatternStringExact = `^${exports.PatternString}$`;

package/type/pick/index.d.ts

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

package/type/pick/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("./pick"), exports);

package/type/pick/pick.d.ts

@@ -0,0 +1,19 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TupleToUnion, Evaluate } from '../helpers/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';
+import { IndexedKeyResolve } from '../indexed/index';
+type FromIntersect<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromIntersect<R, K>] : [];
+declare function FromIntersect<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromIntersect<T, K>;
+type FromUnion<T extends TSchema[], K extends PropertyKey[]> = T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? [PickResolve<L, K>, ...FromUnion<R, K>] : [];
+declare function FromUnion<T extends TSchema[], K extends PropertyKey[]>(T: T, K: K): FromUnion<T, K>;
+type FromProperties<T extends TProperties, K extends PropertyKey[], I extends PropertyKey = TupleToUnion<K>> = Evaluate<Pick<T, I & keyof T>>;
+declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(T: T, K: K): {};
+export type PickResolve<T extends TProperties, K extends PropertyKey[]> = T extends TRecursive<infer S> ? TRecursive<PickResolve<S, K>> : T extends TIntersect<infer S> ? TIntersect<FromIntersect<S, K>> : T extends TUnion<infer S> ? TUnion<FromUnion<S, K>> : T extends TObject<infer S> ? TObject<FromProperties<S, K>> : TObject<{}>;
+export declare function PickResolve<T extends TSchema, K extends PropertyKey[]>(T: T, K: [...K]): PickResolve<T, K>;
+export type TPick<T extends TSchema, K extends PropertyKey[]> = PickResolve<T, K>;
+export declare function Pick<T extends TSchema, K extends TSchema, I extends PropertyKey[] = IndexedKeyResolve<K>>(T: T, K: K, options?: SchemaOptions): TPick<T, I>;
+export declare function Pick<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TPick<T, K>;
+export {};

package/type/pick/pick.js

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

package/type/promise/index.d.ts

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

package/type/promise/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("./promise"), exports);

package/type/promise/promise.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 TPromise<T extends TSchema = TSchema> extends TSchema {
+    [Kind]: 'Promise';
+    static: Promise<Static<T, this['params']>>;
+    type: 'Promise';
+    item: TSchema;
+}
+export declare function Promise<T extends TSchema>(item: T, options?: SchemaOptions): TPromise<T>;

package/type/promise/promise.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Promise = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+function Promise(item, options = {}) {
+    return {
+        ...options,
+        [index_1.Kind]: 'Promise',
+        type: 'Promise',
+        item: (0, type_1.CloneType)(item),
+    };
+}
+exports.Promise = Promise;

package/type/readonly/index.d.ts

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

package/type/readonly/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"), exports);

package/type/readonly/readonly.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema } from '../schema/index';
+import { ReadonlyKind } from '../symbols/index';
+export type TReadonly<T extends TSchema> = T & {
+    [ReadonlyKind]: 'Readonly';
+};
+export declare function Readonly<T extends TSchema>(schema: T): TReadonly<T>;

package/type/readonly/readonly.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Readonly = void 0;
+const index_1 = require("../symbols/index");
+const type_1 = require("../clone/type");
+function Readonly(schema) {
+    return { ...(0, type_1.CloneType)(schema), [index_1.ReadonlyKind]: 'Readonly' };
+}
+exports.Readonly = Readonly;