@depup/sinclair__typebox 0.34.48-depup.0

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

@@ -0,0 +1,9 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface TNull extends TSchema {
+    [Kind]: 'Null';
+    static: null;
+    type: 'null';
+}
+/** `[Json]` Creates a Null type */
+export declare function Null(options?: SchemaOptions): TNull;

package/build/cjs/type/null/null.js

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

package/build/cjs/type/number/index.d.ts

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

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

@@ -0,0 +1,18 @@
+"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("./number"), exports);

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

@@ -0,0 +1,16 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import { Kind } from '../symbols/index';
+export interface NumberOptions extends SchemaOptions {
+    exclusiveMaximum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    minimum?: number;
+    multipleOf?: number;
+}
+export interface TNumber extends TSchema, NumberOptions {
+    [Kind]: 'Number';
+    static: number;
+    type: 'number';
+}
+/** `[Json]` Creates a Number type */
+export declare function Number(options?: NumberOptions): TNumber;

package/build/cjs/type/number/number.js

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

package/build/cjs/type/object/index.d.ts

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

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

@@ -0,0 +1,18 @@
+"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("./object"), exports);

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

@@ -0,0 +1,51 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { Static } from '../static/index';
+import type { Evaluate, UnionToTuple } from '../helpers/index';
+import type { TReadonly } from '../readonly/index';
+import type { TOptional } from '../optional/index';
+import { Kind } from '../symbols/index';
+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 ObjectStaticProperties<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>>>)>;
+type ObjectStatic<T extends TProperties, P extends unknown[]> = ObjectStaticProperties<T, {
+    [K in keyof T]: Static<T[K], P>;
+}>;
+export type TPropertyKey = string | number;
+export type TProperties = Record<TPropertyKey, TSchema>;
+type TIsLiteralString<Type extends string> = ([
+    Type
+] extends [string] ? [string] extends [Type] ? false : true : false);
+type IsRequiredArrayLiteralConstant<RequiredTuple extends string[]> = (RequiredTuple extends [infer Left extends string, ...infer _ extends string[]] ? TIsLiteralString<Left> : false);
+type TRequiredArray<Properties extends TProperties, RequiredProperties extends TProperties = {
+    [Key in keyof Properties as Properties[Key] extends TOptional<Properties[Key]> ? never : Key]: Properties[Key];
+}, RequiredUnion extends string = Extract<keyof RequiredProperties, string>, RequiredTuple extends string[] = UnionToTuple<RequiredUnion>, Result extends string[] | undefined = (IsRequiredArrayLiteralConstant<RequiredTuple> extends true ? RequiredTuple : string[] | undefined)> = Result;
+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 {
+    [Kind]: 'Object';
+    static: ObjectStatic<T, this['params']>;
+    additionalProperties?: TAdditionalProperties;
+    type: 'object';
+    properties: T;
+    required: TRequiredArray<T>;
+}
+/** `[Json]` Creates an Object type */
+declare function _Object<T extends TProperties>(properties: T, options?: ObjectOptions): TObject<T>;
+/** `[Json]` Creates an Object type */
+export declare var Object: typeof _Object;
+export {};

package/build/cjs/type/object/object.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Object = void 0;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+/** Creates a RequiredArray derived from the given TProperties value. */
+function RequiredArray(properties) {
+    return globalThis.Object.keys(properties).filter((key) => !(0, kind_1.IsOptional)(properties[key]));
+}
+/** `[Json]` Creates an Object type */
+function _Object(properties, options) {
+    const required = RequiredArray(properties);
+    const schema = required.length > 0 ? { [index_1.Kind]: 'Object', type: 'object', required, properties } : { [index_1.Kind]: 'Object', type: 'object', properties };
+    return (0, type_1.CreateType)(schema, options);
+}
+/** `[Json]` Creates an Object type */
+exports.Object = _Object;

package/build/cjs/type/omit/index.d.ts

@@ -0,0 +1,3 @@
+export * from './omit-from-mapped-key';
+export * from './omit-from-mapped-result';
+export * from './omit';

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

@@ -0,0 +1,20 @@
+"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-from-mapped-key"), exports);
+__exportStar(require("./omit-from-mapped-result"), exports);
+__exportStar(require("./omit"), exports);

package/build/cjs/type/omit/omit-from-mapped-key.d.ts

@@ -0,0 +1,12 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult, type TMappedKey } from '../mapped/index';
+import { type TOmit } from './omit';
+type TFromPropertyKey<Type extends TSchema, Key extends PropertyKey> = {
+    [_ in Key]: TOmit<Type, [Key]>;
+};
+type TFromPropertyKeys<Type extends TSchema, PropertyKeys extends PropertyKey[], Result extends TProperties = {}> = (PropertyKeys extends [infer LK extends PropertyKey, ...infer RK extends PropertyKey[]] ? TFromPropertyKeys<Type, RK, Result & TFromPropertyKey<Type, LK>> : Result);
+type TFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey> = (TFromPropertyKeys<Type, MappedKey['keys']>);
+export type TOmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>> = (TMappedResult<Properties>);
+export declare function OmitFromMappedKey<Type extends TSchema, MappedKey extends TMappedKey, Properties extends TProperties = TFromMappedKey<Type, MappedKey>>(type: Type, mappedKey: MappedKey, options?: SchemaOptions): TMappedResult<Properties>;
+export {};

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitFromMappedKey = OmitFromMappedKey;
+const index_1 = require("../mapped/index");
+const omit_1 = require("./omit");
+const value_1 = require("../clone/value");
+// prettier-ignore
+function FromPropertyKey(type, key, options) {
+    return { [key]: (0, omit_1.Omit)(type, [key], (0, value_1.Clone)(options)) };
+}
+// prettier-ignore
+function FromPropertyKeys(type, propertyKeys, options) {
+    return propertyKeys.reduce((Acc, LK) => {
+        return { ...Acc, ...FromPropertyKey(type, LK, options) };
+    }, {});
+}
+// prettier-ignore
+function FromMappedKey(type, mappedKey, options) {
+    return FromPropertyKeys(type, mappedKey.keys, options);
+}
+// prettier-ignore
+function OmitFromMappedKey(type, mappedKey, options) {
+    const properties = FromMappedKey(type, mappedKey, options);
+    return (0, index_1.MappedResult)(properties);
+}

package/build/cjs/type/omit/omit-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index';
+import type { Ensure, Evaluate } from '../helpers/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TOmit } from './omit';
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = ({
+    [K2 in keyof Properties]: TOmit<Properties[K2], PropertyKeys>;
+});
+type TFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[]> = (Evaluate<TFromProperties<MappedResult['properties'], PropertyKeys>>);
+export type TOmitFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>> = (Ensure<TMappedResult<Properties>>);
+export declare function OmitFromMappedResult<MappedResult extends TMappedResult, PropertyKeys extends PropertyKey[], Properties extends TProperties = TFromMappedResult<MappedResult, PropertyKeys>>(mappedResult: MappedResult, propertyKeys: [...PropertyKeys], options?: SchemaOptions): TMappedResult<Properties>;
+export {};

package/build/cjs/type/omit/omit-from-mapped-result.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmitFromMappedResult = OmitFromMappedResult;
+const index_1 = require("../mapped/index");
+const omit_1 = require("./omit");
+const value_1 = require("../clone/value");
+// prettier-ignore
+function FromProperties(properties, propertyKeys, options) {
+    const result = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+        result[K2] = (0, omit_1.Omit)(properties[K2], propertyKeys, (0, value_1.Clone)(options));
+    return result;
+}
+// prettier-ignore
+function FromMappedResult(mappedResult, propertyKeys, options) {
+    return FromProperties(mappedResult.properties, propertyKeys, options);
+}
+// prettier-ignore
+function OmitFromMappedResult(mappedResult, propertyKeys, options) {
+    const properties = FromMappedResult(mappedResult, propertyKeys, options);
+    return (0, index_1.MappedResult)(properties);
+}

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

@@ -0,0 +1,36 @@
+import type { SchemaOptions, TSchema } from '../schema/index';
+import type { TupleToUnion, Evaluate } from '../helpers/index';
+import { type TRecursive } from '../recursive/index';
+import type { TMappedKey, TMappedResult } from '../mapped/index';
+import { TComputed } from '../computed/index';
+import { TLiteral, TLiteralValue } from '../literal/index';
+import { type TIndexPropertyKeys } from '../indexed/index';
+import { type TIntersect } from '../intersect/index';
+import { type TUnion } from '../union/index';
+import { type TObject, type TProperties } from '../object/index';
+import { type TRef } from '../ref/index';
+import { type TOmitFromMappedKey } from './omit-from-mapped-key';
+import { type TOmitFromMappedResult } from './omit-from-mapped-result';
+type TFromIntersect<Types extends TSchema[], PropertyKeys extends PropertyKey[], Result extends TSchema[] = []> = (Types extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromIntersect<R, PropertyKeys, [...Result, TOmit<L, PropertyKeys>]> : Result);
+type TFromUnion<T extends TSchema[], K extends PropertyKey[], Result extends TSchema[] = []> = (T extends [infer L extends TSchema, ...infer R extends TSchema[]] ? TFromUnion<R, K, [...Result, TOmit<L, K>]> : Result);
+type TFromProperties<Properties extends TProperties, PropertyKeys extends PropertyKey[], UnionKey extends PropertyKey = TupleToUnion<PropertyKeys>> = (Evaluate<Omit<Properties, UnionKey>>);
+type TFromObject<_Type extends TObject, PropertyKeys extends PropertyKey[], Properties extends TProperties, MappedProperties extends TProperties = TFromProperties<Properties, PropertyKeys>, Result extends TSchema = TObject<MappedProperties>> = Result;
+type TUnionFromPropertyKeys<PropertyKeys extends PropertyKey[], Result extends TLiteral[] = []> = (PropertyKeys extends [infer Key extends PropertyKey, ...infer Rest extends PropertyKey[]] ? Key extends TLiteralValue ? TUnionFromPropertyKeys<Rest, [...Result, TLiteral<Key>]> : TUnionFromPropertyKeys<Rest, [...Result]> : TUnion<Result>);
+export type TOmitResolve<Properties extends TProperties, PropertyKeys extends PropertyKey[]> = (Properties extends TRecursive<infer Types extends TSchema> ? TRecursive<TOmitResolve<Types, PropertyKeys>> : Properties extends TIntersect<infer Types extends TSchema[]> ? TIntersect<TFromIntersect<Types, PropertyKeys>> : Properties extends TUnion<infer Types extends TSchema[]> ? TUnion<TFromUnion<Types, PropertyKeys>> : Properties extends TObject<infer Properties extends TProperties> ? TFromObject<TObject, PropertyKeys, Properties> : TObject<{}>);
+type TResolvePropertyKeys<Key extends TSchema | PropertyKey[]> = Key extends TSchema ? TIndexPropertyKeys<Key> : Key;
+type TResolveTypeKey<Key extends TSchema | PropertyKey[]> = Key extends PropertyKey[] ? TUnionFromPropertyKeys<Key> : Key;
+export type TOmit<Type extends TSchema, Key extends TSchema | PropertyKey[], IsTypeRef extends boolean = Type extends TRef ? true : false, IsKeyRef extends boolean = Key extends TRef ? true : false> = (Type extends TMappedResult ? TOmitFromMappedResult<Type, TResolvePropertyKeys<Key>> : Key extends TMappedKey ? TOmitFromMappedKey<Type, Key> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [false, true] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : [
+    IsTypeRef,
+    IsKeyRef
+] extends [true, false] ? TComputed<'Omit', [Type, TResolveTypeKey<Key>]> : TOmitResolve<Type, TResolvePropertyKeys<Key>>);
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Omit<Type extends TSchema, Key extends PropertyKey[]>(type: Type, key: readonly [...Key], options?: SchemaOptions): TOmit<Type, Key>;
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+export declare function Omit<Type extends TSchema, Key extends TSchema>(type: Type, key: Key, options?: SchemaOptions): TOmit<Type, Key>;
+export {};

package/build/cjs/type/omit/omit.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Omit = Omit;
+const type_1 = require("../create/type");
+const discard_1 = require("../discard/discard");
+const symbols_1 = require("../symbols/symbols");
+const index_1 = require("../computed/index");
+const index_2 = require("../literal/index");
+const index_3 = require("../indexed/index");
+const index_4 = require("../intersect/index");
+const index_5 = require("../union/index");
+const index_6 = require("../object/index");
+// ------------------------------------------------------------------
+// Mapped
+// ------------------------------------------------------------------
+const omit_from_mapped_key_1 = require("./omit-from-mapped-key");
+const omit_from_mapped_result_1 = require("./omit-from-mapped-result");
+// ------------------------------------------------------------------
+// TypeGuard
+// ------------------------------------------------------------------
+const kind_1 = require("../guard/kind");
+const value_1 = require("../guard/value");
+// prettier-ignore
+function FromIntersect(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
+}
+// prettier-ignore
+function FromUnion(types, propertyKeys) {
+    return types.map((type) => OmitResolve(type, propertyKeys));
+}
+// ------------------------------------------------------------------
+// FromProperty
+// ------------------------------------------------------------------
+// prettier-ignore
+function FromProperty(properties, key) {
+    const { [key]: _, ...R } = properties;
+    return R;
+}
+// prettier-ignore
+function FromProperties(properties, propertyKeys) {
+    return propertyKeys.reduce((T, K2) => FromProperty(T, K2), properties);
+}
+// prettier-ignore
+function FromObject(type, propertyKeys, properties) {
+    const options = (0, discard_1.Discard)(type, [symbols_1.TransformKind, '$id', 'required', 'properties']);
+    const mappedProperties = FromProperties(properties, propertyKeys);
+    return (0, index_6.Object)(mappedProperties, options);
+}
+// prettier-ignore
+function UnionFromPropertyKeys(propertyKeys) {
+    const result = propertyKeys.reduce((result, key) => (0, kind_1.IsLiteralValue)(key) ? [...result, (0, index_2.Literal)(key)] : result, []);
+    return (0, index_5.Union)(result);
+}
+// prettier-ignore
+function OmitResolve(type, propertyKeys) {
+    return ((0, kind_1.IsIntersect)(type) ? (0, index_4.Intersect)(FromIntersect(type.allOf, propertyKeys)) :
+        (0, kind_1.IsUnion)(type) ? (0, index_5.Union)(FromUnion(type.anyOf, propertyKeys)) :
+            (0, kind_1.IsObject)(type) ? FromObject(type, propertyKeys, type.properties) :
+                (0, index_6.Object)({}));
+}
+/** `[Json]` Constructs a type whose keys are picked from the given type */
+// prettier-ignore
+function Omit(type, key, options) {
+    const typeKey = (0, value_1.IsArray)(key) ? UnionFromPropertyKeys(key) : key;
+    const propertyKeys = (0, kind_1.IsSchema)(key) ? (0, index_3.IndexPropertyKeys)(key) : key;
+    const isTypeRef = (0, kind_1.IsRef)(type);
+    const isKeyRef = (0, kind_1.IsRef)(key);
+    return ((0, kind_1.IsMappedResult)(type) ? (0, omit_from_mapped_result_1.OmitFromMappedResult)(type, propertyKeys, options) :
+        (0, kind_1.IsMappedKey)(key) ? (0, omit_from_mapped_key_1.OmitFromMappedKey)(type, key, options) :
+            (isTypeRef && isKeyRef) ? (0, index_1.Computed)('Omit', [type, typeKey], options) :
+                (!isTypeRef && isKeyRef) ? (0, index_1.Computed)('Omit', [type, typeKey], options) :
+                    (isTypeRef && !isKeyRef) ? (0, index_1.Computed)('Omit', [type, typeKey], options) :
+                        (0, type_1.CreateType)({ ...OmitResolve(type, propertyKeys), ...options }));
+}

package/build/cjs/type/optional/index.d.ts

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

package/build/cjs/type/optional/index.js

@@ -0,0 +1,19 @@
+"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-from-mapped-result"), exports);
+__exportStar(require("./optional"), exports);

package/build/cjs/type/optional/optional-from-mapped-result.d.ts

@@ -0,0 +1,10 @@
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TOptionalWithFlag } from './optional';
+type TFromProperties<P extends TProperties, F extends boolean> = ({
+    [K2 in keyof P]: TOptionalWithFlag<P[K2], F>;
+});
+type TFromMappedResult<R extends TMappedResult, F extends boolean> = (TFromProperties<R['properties'], F>);
+export type TOptionalFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>> = (TMappedResult<P>);
+export declare function OptionalFromMappedResult<R extends TMappedResult, F extends boolean, P extends TProperties = TFromMappedResult<R, F>>(R: R, F: F): TMappedResult<P>;
+export {};

package/build/cjs/type/optional/optional-from-mapped-result.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalFromMappedResult = OptionalFromMappedResult;
+const index_1 = require("../mapped/index");
+const optional_1 = require("./optional");
+// prettier-ignore
+function FromProperties(P, F) {
+    const Acc = {};
+    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+        Acc[K2] = (0, optional_1.Optional)(P[K2], F);
+    return Acc;
+}
+// prettier-ignore
+function FromMappedResult(R, F) {
+    return FromProperties(R.properties, F);
+}
+// prettier-ignore
+function OptionalFromMappedResult(R, F) {
+    const P = FromMappedResult(R, F);
+    return (0, index_1.MappedResult)(P);
+}

package/build/cjs/type/optional/optional.d.ts

@@ -0,0 +1,20 @@
+import type { TSchema } from '../schema/index';
+import type { Ensure } from '../helpers/index';
+import { OptionalKind } from '../symbols/index';
+import type { TMappedResult } from '../mapped/index';
+import { type TOptionalFromMappedResult } from './optional-from-mapped-result';
+type TRemoveOptional<T extends TSchema> = T extends TOptional<infer S> ? S : T;
+type TAddOptional<T extends TSchema> = T extends TOptional<infer S> ? TOptional<S> : Ensure<TOptional<T>>;
+export type TOptionalWithFlag<T extends TSchema, F extends boolean> = F extends false ? TRemoveOptional<T> : TAddOptional<T>;
+export type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult, F extends boolean>(schema: T, enable: F): TOptionalFromMappedResult<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema, F extends boolean>(schema: T, enable: F): TOptionalWithFlag<T, F>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TMappedResult>(schema: T): TOptionalFromMappedResult<T, true>;
+/** `[Json]` Creates a Optional property */
+export declare function Optional<T extends TSchema>(schema: T): TOptionalWithFlag<T, true>;
+export {};

package/build/cjs/type/optional/optional.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Optional = Optional;
+const type_1 = require("../create/type");
+const index_1 = require("../symbols/index");
+const index_2 = require("../discard/index");
+const optional_from_mapped_result_1 = require("./optional-from-mapped-result");
+const kind_1 = require("../guard/kind");
+function RemoveOptional(schema) {
+    return (0, type_1.CreateType)((0, index_2.Discard)(schema, [index_1.OptionalKind]));
+}
+function AddOptional(schema) {
+    return (0, type_1.CreateType)({ ...schema, [index_1.OptionalKind]: 'Optional' });
+}
+// prettier-ignore
+function OptionalWithFlag(schema, F) {
+    return (F === false
+        ? RemoveOptional(schema)
+        : AddOptional(schema));
+}
+/** `[Json]` Creates a Optional property */
+function Optional(schema, enable) {
+    const F = enable ?? true;
+    return (0, kind_1.IsMappedResult)(schema) ? (0, optional_from_mapped_result_1.OptionalFromMappedResult)(schema, F) : OptionalWithFlag(schema, F);
+}

package/build/cjs/type/parameters/index.d.ts

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

package/build/cjs/type/parameters/index.js

@@ -0,0 +1,18 @@
+"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/build/cjs/type/parameters/parameters.d.ts

@@ -0,0 +1,7 @@
+import type { TSchema, SchemaOptions } from '../schema/index';
+import type { TFunction } from '../function/index';
+import { type TTuple } from '../tuple/index';
+import { type TNever } from '../never/index';
+export type TParameters<Type extends TSchema> = (Type extends TFunction<infer Parameters extends TSchema[], infer _ReturnType extends TSchema> ? TTuple<Parameters> : TNever);
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+export declare function Parameters<Type extends TSchema>(schema: Type, options?: SchemaOptions): TParameters<Type>;

package/build/cjs/type/parameters/parameters.js

@@ -0,0 +1,44 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parameters = Parameters;
+const index_1 = require("../tuple/index");
+const index_2 = require("../never/index");
+const KindGuard = __importStar(require("../guard/kind"));
+/** `[JavaScript]` Extracts the Parameters from the given Function type */
+function Parameters(schema, options) {
+    return (KindGuard.IsFunction(schema) ? (0, index_1.Tuple)(schema.parameters, options) : (0, index_2.Never)());
+}

package/build/cjs/type/partial/index.d.ts

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

package/build/cjs/type/partial/index.js

@@ -0,0 +1,19 @@
+"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-from-mapped-result"), exports);
+__exportStar(require("./partial"), exports);

package/build/cjs/type/partial/partial-from-mapped-result.d.ts

@@ -0,0 +1,12 @@
+import type { SchemaOptions } from '../schema/index';
+import type { Ensure, Evaluate } from '../helpers/index';
+import type { TProperties } from '../object/index';
+import { type TMappedResult } from '../mapped/index';
+import { type TPartial } from './partial';
+type TFromProperties<P extends TProperties> = ({
+    [K2 in keyof P]: TPartial<P[K2]>;
+});
+type TFromMappedResult<R extends TMappedResult> = (Evaluate<TFromProperties<R['properties']>>);
+export type TPartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>> = (Ensure<TMappedResult<P>>);
+export declare function PartialFromMappedResult<R extends TMappedResult, P extends TProperties = TFromMappedResult<R>>(R: R, options?: SchemaOptions): TMappedResult<P>;
+export {};