@sinclair/typebox 0.32.0-dev-16 → 0.32.0-dev-18

package/build/require/type/iterator/iterator.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Iterator = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+/** `[JavaScript]` Creates an Iterator type */
 function Iterator(items, options = {}) {
     return {
         ...options,

package/build/require/type/keyof/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/keyof/keyof-from-mapped-result.js

@@ -1,16 +1,20 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyOfFromMappedResult = void 0;
 const index_1 = require("../mapped/index");
 const keyof_1 = require("./keyof");
+// prettier-ignore
 function FromProperties(K, options) {
     return globalThis.Object.getOwnPropertyNames(K).reduce((Acc, K2) => {
         return { ...Acc, [K2]: (0, keyof_1.KeyOf)(K[K2], options) };
     }, {});
 }
+// prettier-ignore
 function FromMappedResult(K, options) {
     return FromProperties(K.properties, options);
 }
+// prettier-ignore
 function KeyOfFromMappedResult(T, options) {
     const P = FromMappedResult(T, options);
     return (0, index_1.MappedResult)(P);

package/build/require/type/keyof/keyof-property-keys.d.ts

@@ -23,6 +23,8 @@ type FromProperties<T extends TProperties> = (UnionToTuple<keyof T>);
 declare function FromProperties<T extends TProperties>(T: T): FromProperties<T>;
 export type KeyOfPropertyKeys<T extends TSchema> = (T extends TRecursive<infer S> ? KeyOfPropertyKeys<S> : T extends TIntersect<infer S> ? FromIntersect<S> : T extends TUnion<infer S> ? FromUnion<S> : T extends TTuple<infer S> ? FromTuple<S> : T extends TArray<infer S> ? FromArray<S> : T extends TObject<infer S> ? FromProperties<S> : [
 ]);
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
 export declare function KeyOfPropertyKeys<T extends TSchema>(T: T): KeyOfPropertyKeys<T>;
+/** Returns a regular expression pattern derived from the given TSchema */
 export declare function KeyOfPattern(schema: TSchema): string;
 export {};

package/build/require/type/keyof/keyof-property-keys.js

@@ -1,34 +1,49 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyOfPattern = exports.KeyOfPropertyKeys = void 0;
 const index_1 = require("../helpers/index");
 const index_2 = require("../operators/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_1 = require("../guard/type");
+// prettier-ignore
 function FromRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [KeyOfPropertyKeys(L), ...FromRest(R)]
         : []);
 }
+// prettier-ignore
 function FromIntersect(T, C = FromRest(T)) {
     return (0, index_2.OperatorUnionMany)(C);
 }
+// prettier-ignore
 function FromUnion(T) {
     const C = FromRest(T);
     return (0, index_2.OperatorIntersectMany)(C);
 }
+// prettier-ignore
 function FromTuple(T, I = '0') {
     const [_, ...R] = T;
     return (T.length > 0
         ? [I, ...FromTuple(R, (0, index_1.Increment)(I))]
         : []);
 }
+// prettier-ignore
 function FromArray(_) {
     return (['[number]']);
 }
+// prettier-ignore
 function FromProperties(T) {
     return (globalThis.Object.getOwnPropertyNames(T));
 }
+// ------------------------------------------------------------------
+// FromPatternProperties
+// ------------------------------------------------------------------
+// prettier-ignore
 function FromPatternProperties(patternProperties) {
     if (!includePatternProperties)
         return [];
@@ -39,6 +54,8 @@ function FromPatternProperties(patternProperties) {
             : key;
     });
 }
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
+// prettier-ignore
 function KeyOfPropertyKeys(T) {
     return ((0, type_1.TIntersect)(T) ? FromIntersect(T.allOf) :
         (0, type_1.TUnion)(T) ? FromUnion(T.anyOf) :
@@ -49,7 +66,11 @@ function KeyOfPropertyKeys(T) {
                             []);
 }
 exports.KeyOfPropertyKeys = KeyOfPropertyKeys;
+// ----------------------------------------------------------------
+// KeyOfPattern
+// ----------------------------------------------------------------
 let includePatternProperties = false;
+/** Returns a regular expression pattern derived from the given TSchema */
 function KeyOfPattern(schema) {
     includePatternProperties = true;
     const keys = KeyOfPropertyKeys(schema);

package/build/require/type/keyof/keyof.d.ts

@@ -10,6 +10,8 @@ import { type TKeyOfFromMappedResult } from './keyof-from-mapped-result';
 type FromLiterals<T extends TLiteralValue[]> = (T extends [infer L extends TLiteralValue, ...infer R extends TLiteralValue[]] ? L extends '[number]' ? [TNumber, ...FromLiterals<R>] : [TLiteral<L>, ...FromLiterals<R>] : []);
 declare function FromLiterals<T extends TLiteralValue[]>(T: [...T]): FromLiterals<T>;
 export type TKeyOf<T extends TSchema> = (Ensure<UnionEvaluated<FromLiterals<KeyOfPropertyKeys<T>>>>);
+/** `[Json]` Creates a KeyOf type */
 export declare function KeyOf<T extends TMappedResult>(T: T, options?: SchemaOptions): TKeyOfFromMappedResult<T>;
+/** `[Json]` Creates a KeyOf type */
 export declare function KeyOf<T extends TSchema>(T: T, options?: SchemaOptions): TKeyOf<T>;
 export {};

package/build/require/type/keyof/keyof.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyOf = void 0;
 const index_1 = require("../literal/index");
@@ -7,7 +8,12 @@ const keyof_property_keys_1 = require("./keyof-property-keys");
 const index_3 = require("../union/index");
 const type_1 = require("../clone/type");
 const keyof_from_mapped_result_1 = require("./keyof-from-mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function FromLiterals(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -16,6 +22,7 @@ function FromLiterals(T) {
             : [(0, index_1.Literal)(L), ...FromLiterals(R)]
         : []);
 }
+/** `[Json]` Creates a KeyOf type */
 function KeyOf(T, options = {}) {
     if ((0, type_2.TMappedResult)(T)) {
         return (0, keyof_from_mapped_result_1.KeyOfFromMappedResult)(T, options);

package/build/require/type/literal/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/literal/literal.d.ts

@@ -6,4 +6,5 @@ export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSche
     static: T;
     const: T;
 }
+/** `[Json]` Creates a Literal type */
 export declare function Literal<T extends TLiteralValue>(value: T, options?: SchemaOptions): TLiteral<T>;

package/build/require/type/literal/literal.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Literal = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Literal type */
 function Literal(value, options = {}) {
     return {
         ...options,

package/build/require/type/mapped/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/mapped/mapped-key.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MappedKey = void 0;
 const index_1 = require("../symbols/index");
+// prettier-ignore
 function MappedKey(T) {
     return {
         [index_1.Kind]: 'MappedKey',

package/build/require/type/mapped/mapped-result.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MappedResult = void 0;
 const index_1 = require("../symbols/index");
+// prettier-ignore
 function MappedResult(properties) {
     return {
         [index_1.Kind]: 'MappedResult',

package/build/require/type/mapped/mapped.d.ts

@@ -38,6 +38,8 @@ type FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema> =
 declare function FromMappedFunctionReturnType<K extends PropertyKey[], T extends TSchema>(K: [...K], T: T): FromMappedFunctionReturnType<K, T>;
 export type TMappedFunction<K extends PropertyKey[], I = TMappedKey<K>> = (T: I) => TSchema;
 export type TMapped<K extends PropertyKey[], F extends TMappedFunction<K>, R extends TProperties = Evaluate<FromMappedFunctionReturnType<K, ReturnType<F>>>> = Ensure<TObject<R>>;
+/** `[Json]` Creates a Mapped object type */
 export declare function Mapped<K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>, F extends TMappedFunction<I> = TMappedFunction<I>, R extends TMapped<I, F> = TMapped<I, F>>(key: K, map: F, options?: ObjectOptions): R;
+/** `[Json]` Creates a Mapped object type */
 export declare function Mapped<K extends PropertyKey[], F extends TMappedFunction<K> = TMappedFunction<K>, R extends TMapped<K, F> = TMapped<K, F>>(key: [...K], map: F, options?: ObjectOptions): R;
 export {};

package/build/require/type/mapped/mapped.js

@@ -1,9 +1,11 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Mapped = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const index_2 = require("../discard/index");
+// evaluation types
 const index_3 = require("../array/index");
 const index_4 = require("../async-iterator/index");
 const index_5 = require("../constructor/index");
@@ -18,39 +20,54 @@ const index_13 = require("../promise/index");
 const index_14 = require("../readonly/index");
 const index_15 = require("../tuple/index");
 const index_16 = require("../union/index");
+// mapping types
 const mapped_result_1 = require("./mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function FromMappedResult(K, P) {
     return (K in P
         ? FromSchemaType(K, P[K])
         : (0, mapped_result_1.MappedResult)(P));
 }
+// prettier-ignore
 function MappedKeyToMappedResultProperties(K, P) {
     const [L, ...R] = P;
     return (P.length > 0
         ? { [L]: (0, index_10.Literal)(L), ...MappedKeyToMappedResultProperties(K, R) }
         : {});
 }
+// prettier-ignore
 function FromMappedKey(K, P) {
     const R = MappedKeyToMappedResultProperties(K, P);
     return FromMappedResult(K, R);
 }
+// prettier-ignore
 function FromRest(K, T) {
     const [L, ...R] = T;
     return (T.length > 0
         ? [FromSchemaType(K, L), ...FromRest(K, R)]
         : []);
 }
+// prettier-ignore
 function FromProperties(K, T) {
     return globalThis.Object.getOwnPropertyNames(T).reduce((Acc, K2) => {
         return { ...Acc, [K2]: FromSchemaType(K, T[K2]) };
     }, {});
 }
+// prettier-ignore
 function FromSchemaType(K, T) {
-    return ((0, type_2.TOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
+    return (
+    // unevaluated modifier types
+    (0, type_2.TOptional)(T) ? (0, index_12.Optional)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.OptionalKind]))) :
         (0, type_2.TReadonly)(T) ? (0, index_14.Readonly)(FromSchemaType(K, (0, index_2.Discard)(T, [index_1.ReadonlyKind]))) :
+            // unevaluated mapped types
             (0, type_2.TMappedResult)(T) ? FromMappedResult(K, T.properties) :
                 (0, type_2.TMappedKey)(T) ? FromMappedKey(K, T.keys) :
+                    // unevaluated types
                     (0, type_2.TConstructor)(T) ? (0, index_5.Constructor)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
                         (0, type_2.TFunction)(T) ? (0, index_6.Function)(FromRest(K, T.parameters), FromSchemaType(K, T.returns)) :
                             (0, type_2.TAsyncIterator)(T) ? (0, index_4.AsyncIterator)(FromSchemaType(K, T.items)) :
@@ -63,12 +80,14 @@ function FromSchemaType(K, T) {
                                                         (0, type_2.TPromise)(T) ? (0, index_13.Promise)(FromSchemaType(K, T.item)) :
                                                             T);
 }
+// prettier-ignore
 function FromMappedFunctionReturnType(K, T) {
     const [L, ...R] = K;
     return (K.length > 0
         ? { [L]: FromSchemaType(L, T), ...FromMappedFunctionReturnType(R, T) }
         : {});
 }
+/** `[Json]` Creates a Mapped object type */
 function Mapped(key, map, options = {}) {
     const K = (0, type_2.TSchema)(key) ? (0, index_7.IndexPropertyKeys)(key) : key;
     const RT = map({ [index_1.Kind]: 'MappedKey', keys: K });

package/build/require/type/modifiers/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/modifiers/modifiers.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OptionalFromUnion = exports.OptionalFromIntersect = void 0;
 const index_1 = require("../intersect/index");
@@ -6,7 +7,12 @@ const index_2 = require("../union/index");
 const index_3 = require("../optional/index");
 const index_4 = require("../discard/index");
 const index_5 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_1 = require("../guard/type");
+// prettier-ignore
 function IsOptionalFromIntersect(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -15,6 +21,7 @@ function IsOptionalFromIntersect(T) {
             : false
         : true);
 }
+// prettier-ignore
 function IsOptionalFromUnion(T) {
     const [L, ...R] = T;
     return (T.length > 0
@@ -23,12 +30,15 @@ function IsOptionalFromUnion(T) {
             : IsOptionalFromUnion(R)
         : false);
 }
+// prettier-ignore
 function RemoveOptionalFromRest(T) {
     return (T.map(T => RemoveOptionalFromSchema(T)));
 }
+// prettier-ignore
 function RemoveOptionalFromSchema(T) {
     return ((0, index_4.Discard)(T, [index_5.OptionalKind]));
 }
+// prettier-ignore
 function OptionalFromIntersect(T) {
     const D = RemoveOptionalFromRest(T);
     return (IsOptionalFromIntersect(T)
@@ -36,6 +46,7 @@ function OptionalFromIntersect(T) {
         : (0, index_1.Intersect)(T));
 }
 exports.OptionalFromIntersect = OptionalFromIntersect;
+// prettier-ignore
 function OptionalFromUnion(T) {
     const D = RemoveOptionalFromRest(T);
     return (IsOptionalFromUnion(T)

package/build/require/type/never/index.js

@@ -14,4 +14,5 @@ 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("./never"), exports);

package/build/require/type/never/never.d.ts

@@ -5,4 +5,5 @@ export interface TNever extends TSchema {
     static: never;
     not: {};
 }
+/** `[Json]` Creates a Never type */
 export declare function Never(options?: SchemaOptions): TNever;

package/build/require/type/never/never.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Never = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Never type */
 function Never(options = {}) {
     return {
         ...options,

package/build/require/type/not/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/not/not.d.ts

@@ -6,4 +6,5 @@ export interface TNot<T extends TSchema = TSchema> extends TSchema {
     static: T extends TNot<infer U> ? Static<U> : unknown;
     not: T;
 }
+/** `[Json]` Creates a Not type */
 export declare function Not<T extends TSchema>(schema: T, options?: SchemaOptions): TNot<T>;

package/build/require/type/not/not.js

@@ -1,8 +1,10 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Not = void 0;
 const index_1 = require("../symbols/index");
 const type_1 = require("../clone/type");
+/** `[Json]` Creates a Not type */
 function Not(schema, options) {
     return {
         ...options,

package/build/require/type/null/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/null/null.d.ts

@@ -5,4 +5,5 @@ export interface TNull extends TSchema {
     static: null;
     type: 'null';
 }
+/** `[Json]` Creates a Null type */
 export declare function Null(options?: SchemaOptions): TNull;

package/build/require/type/null/null.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Null = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Null type */
 function Null(options = {}) {
     return {
         ...options,

package/build/require/type/number/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/number/number.d.ts

@@ -12,4 +12,5 @@ export interface TNumber extends TSchema, NumberOptions {
     static: number;
     type: 'number';
 }
+/** `[Json]` Creates a Number type */
 export declare function Number(options?: NumberOptions): TNumber;

package/build/require/type/number/number.js

@@ -1,7 +1,9 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Number = void 0;
 const index_1 = require("../symbols/index");
+/** `[Json]` Creates a Number type */
 function Number(options = {}) {
     return {
         ...options,

package/build/require/type/object/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/object/object.d.ts

@@ -22,8 +22,11 @@ export type TPropertyKey = string | number;
 export type TProperties = Record<TPropertyKey, TSchema>;
 export type TAdditionalProperties = undefined | TSchema | boolean;
 export interface ObjectOptions extends SchemaOptions {
+    /** Additional property constraints for this object */
     additionalProperties?: TAdditionalProperties;
+    /** The minimum number of properties allowed on this object */
     minProperties?: number;
+    /** The maximum number of properties allowed on this object */
     maxProperties?: number;
 }
 export interface TObject<T extends TProperties = TProperties> extends TSchema, ObjectOptions {
@@ -34,6 +37,8 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     properties: T;
     required?: string[];
 }
+/** `[Json]` Creates an Object type */
 export declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+/** `[Json]` Creates an Object type */
 export declare const Object: typeof _Object;
 export {};

package/build/require/type/object/object.js

@@ -1,9 +1,15 @@
 "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");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+/** `[Json]` Creates an Object type */
 function _Object(properties, options = {}) {
     const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
     const optionalKeys = propertyKeys.filter((key) => (0, type_2.TOptional)(properties[key]));
@@ -15,4 +21,5 @@ function _Object(properties, options = {}) {
         : { ...options, ...clonedAdditionalProperties, [index_1.Kind]: 'Object', type: 'object', properties: clonedProperties });
 }
 exports._Object = _Object;
+/** `[Json]` Creates an Object type */
 exports.Object = _Object;

package/build/require/type/omit/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/omit/omit-from-mapped-key.js

@@ -1,22 +1,27 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OmitFromMappedKey = void 0;
 const index_1 = require("../mapped/index");
 const omit_1 = require("./omit");
+// prettier-ignore
 function FromPropertyKey(T, K, options) {
     return {
         [K]: (0, omit_1.Omit)(T, [K], options)
     };
 }
+// prettier-ignore
 function FromPropertyKeys(T, K, options) {
     const [LK, ...RK] = K;
     return (K.length > 0
         ? { ...FromPropertyKey(T, LK, options), ...FromPropertyKeys(T, RK, options) }
         : {});
 }
+// prettier-ignore
 function FromMappedKey(T, K, options) {
     return FromPropertyKeys(T, K.keys, options);
 }
+// prettier-ignore
 function OmitFromMappedKey(T, K, options) {
     const P = FromMappedKey(T, K, options);
     return (0, index_1.MappedResult)(P);

package/build/require/type/omit/omit.d.ts

@@ -16,7 +16,10 @@ declare function FromProperties<T extends TProperties, K extends PropertyKey[]>(
 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>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
 export declare function Omit<T extends TSchema, K extends TMappedKey>(T: T, K: K): TOmitFromMappedKey<T, K>;
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function Omit<T extends TSchema, K extends TSchema, I extends PropertyKey[] = TIndexPropertyKeys<K>>(T: T, K: K, options?: SchemaOptions): TOmit<T, I>;
+/** `[Json]` Constructs a type whose keys are omitted from the given type */
 export declare function Omit<T extends TSchema, K extends PropertyKey[]>(T: T, K: readonly [...K], options?: SchemaOptions): TOmit<T, K>;
 export {};

package/build/require/type/omit/omit.js

@@ -1,4 +1,5 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Omit = exports.OmitResolve = void 0;
 const index_1 = require("../intersect/index");
@@ -9,22 +10,34 @@ const index_5 = require("../discard/index");
 const index_6 = require("../symbols/index");
 const type_1 = require("../clone/type");
 const omit_from_mapped_key_1 = require("./omit-from-mapped-key");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+// prettier-ignore
 const type_2 = require("../guard/type");
+// prettier-ignore
 function FromIntersect(T, K) {
     return T.map((T) => OmitResolve(T, K));
 }
+// prettier-ignore
 function FromUnion(T, K) {
     return T.map((T) => OmitResolve(T, K));
 }
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+// prettier-ignore
 function FromProperty(T, K) {
     const { [K]: _, ...R } = T;
     return R;
 }
+// prettier-ignore
 function FromProperties(T, K) {
     return K.reduce((T, K2) => {
         return FromProperty(T, K2);
     }, T);
 }
+// prettier-ignore
 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)) :

package/build/require/type/operators/index.js

@@ -1,4 +1,5 @@
 "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);

package/build/require/type/operators/operators.d.ts

@@ -1,16 +1,24 @@
 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);
+/** Returns true if element S is in the set of T */
 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;
+/** Returns true if T is a subset of S */
 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;
+/** Returns a distinct set of elements */
 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>] : []);
+/** Returns the Intersect of the given sets */
 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);
+/** Returns the Union of the given sets */
 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>] : []);
+/** Returns the Complement by omitting elements in T that are in 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>> : []);
+/** Returns the Intersect of multiple sets */
 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>> : []);
+/** Returns the Union of multiple sets */
 export declare function OperatorUnionMany<T extends PropertyKey[][]>(T: [...T]): OperatorUnionMany<T>;