typebox 1.0.31 → 1.0.33

package/build/cjs/type/types/function.js

@@ -0,0 +1,29 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Function = Function;
+exports.IsFunction = IsFunction;
+exports.FunctionOptions = FunctionOptions;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Function type. */
+function Function(parameters, returnType, options = {}) {
+    return index_1.Memory.Create({ ['~kind']: 'Function' }, { type: 'function', parameters, returnType }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TFunction. */
+function IsFunction(value) {
+    return (0, schema_1.IsKind)(value, 'Function');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TFunction. */
+function FunctionOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'type', 'parameters', 'returnType']);
+}

package/build/cjs/type/types/generic.d.ts

@@ -0,0 +1,13 @@
+import { type TSchema } from '../types/schema';
+import { type TParameter } from './parameter';
+/** Represents a callable Generic type. */
+export interface TGeneric<Parameters extends TParameter[] = TParameter[], Expression extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Generic';
+    type: 'generic';
+    parameters: Parameters;
+    expression: Expression;
+}
+/** Creates a Generic type. */
+export declare function Generic<Parameters extends TParameter[], Expression extends TSchema>(parameters: [...Parameters], expression: Expression): TGeneric<Parameters, Expression>;
+/** Returns true if the given value is a TGeneric. */
+export declare function IsGeneric(value: unknown): value is TGeneric;

package/build/cjs/type/types/generic.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generic = Generic;
+exports.IsGeneric = IsGeneric;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("../types/schema");
+// ------------------------------------------------------------------
+// Type
+// ------------------------------------------------------------------
+/** Creates a Generic type. */
+function Generic(parameters, expression) {
+    return index_1.Memory.Create({ '~kind': 'Generic' }, { type: 'generic', parameters, expression });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TGeneric. */
+function IsGeneric(value) {
+    return (0, schema_1.IsKind)(value, 'Generic');
+}

package/build/cjs/type/types/identifier.d.ts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema';
+/** Represents a Identifier. */
+export interface TIdentifier<Name extends string = string> extends TSchema {
+    '~kind': 'Identifier';
+    type: 'identifier';
+    name: Name;
+}
+/** Creates an Identifier. */
+export declare function Identifier<Name extends string>(name: Name): TIdentifier<Name>;
+/** Returns true if the given value is a TIdentifier. */
+export declare function IsIdentifier(value: unknown): value is TIdentifier;

package/build/cjs/type/types/identifier.js

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Identifier = Identifier;
+exports.IsIdentifier = IsIdentifier;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("../types/schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Identifier. */
+function Identifier(name) {
+    return index_1.Memory.Create({ '~kind': 'Identifier' }, { name });
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TIdentifier. */
+function IsIdentifier(value) {
+    return (0, schema_1.IsKind)(value, 'Identifier');
+}

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

@@ -0,0 +1,47 @@
+export * from './_codec';
+export * from './_optional';
+export * from './_readonly';
+export * from './_refine';
+export * from './any';
+export * from './array';
+export * from './async-iterator';
+export * from './base';
+export * from './bigint';
+export * from './boolean';
+export * from './call';
+export * from './constructor';
+export * from './cyclic';
+export * from './deferred';
+export * from './enum';
+export * from './function';
+export * from './generic';
+export * from './identifier';
+export * from './infer';
+export * from './integer';
+export * from './intersect';
+export * from './iterator';
+export * from './literal';
+export * from './never';
+export * from './null';
+export * from './number';
+export * from './unknown';
+export * from './symbol';
+export * from './object';
+export * from './parameter';
+export * from './promise';
+export * from './properties';
+export * from './record';
+export * from './ref';
+export * from './rest';
+export * from './schema';
+export * from './static';
+export * from './string';
+export * from './symbol';
+export * from './template-literal';
+export * from './this';
+export * from './tuple';
+export * from './undefined';
+export * from './union';
+export * from './unknown';
+export * from './unsafe';
+export * from './void';

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

@@ -0,0 +1,69 @@
+"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 });
+// ------------------------------------------------------------------
+// Extensions
+// ------------------------------------------------------------------
+__exportStar(require("./_codec"), exports);
+__exportStar(require("./_optional"), exports);
+__exportStar(require("./_readonly"), exports);
+__exportStar(require("./_refine"), exports);
+// ------------------------------------------------------------------
+// Standard
+// ------------------------------------------------------------------
+__exportStar(require("./any"), exports);
+__exportStar(require("./array"), exports);
+__exportStar(require("./async-iterator"), exports);
+__exportStar(require("./base"), exports);
+__exportStar(require("./bigint"), exports);
+__exportStar(require("./boolean"), exports);
+__exportStar(require("./call"), exports);
+__exportStar(require("./constructor"), exports);
+__exportStar(require("./cyclic"), exports);
+__exportStar(require("./deferred"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./function"), exports);
+__exportStar(require("./generic"), exports);
+__exportStar(require("./identifier"), exports);
+__exportStar(require("./infer"), exports);
+__exportStar(require("./integer"), exports);
+__exportStar(require("./intersect"), exports);
+__exportStar(require("./iterator"), exports);
+__exportStar(require("./literal"), exports);
+__exportStar(require("./never"), exports);
+__exportStar(require("./null"), exports);
+__exportStar(require("./number"), exports);
+__exportStar(require("./unknown"), exports);
+__exportStar(require("./symbol"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./parameter"), exports);
+__exportStar(require("./promise"), exports);
+__exportStar(require("./properties"), exports);
+__exportStar(require("./record"), exports);
+__exportStar(require("./ref"), exports);
+__exportStar(require("./rest"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./static"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./symbol"), exports);
+__exportStar(require("./template-literal"), exports);
+__exportStar(require("./this"), exports);
+__exportStar(require("./tuple"), exports);
+__exportStar(require("./undefined"), exports);
+__exportStar(require("./union"), exports);
+__exportStar(require("./unknown"), exports);
+__exportStar(require("./unsafe"), exports);
+__exportStar(require("./void"), exports);

package/build/cjs/type/types/infer.d.ts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../types/schema';
+import { type TUnknown } from '../types/unknown';
+/** Represents an Infer instruction. */
+export interface TInfer<Name extends string = string, Extends extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Infer';
+    type: 'infer';
+    name: Name;
+    extends: Extends;
+}
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string, Extends extends TSchema>(name: Name, extends_: Extends): TInfer<Name, Extends>;
+/** Creates an Infer instruction. */
+export declare function Infer<Name extends string>(name: Name): TInfer<Name, TUnknown>;
+/** Returns true if the given value is TInfer. */
+export declare function IsInfer(value: unknown): value is TInfer;

package/build/cjs/type/types/infer.js

@@ -0,0 +1,24 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Infer = Infer;
+exports.IsInfer = IsInfer;
+const index_1 = require("../../system/arguments/index");
+const index_2 = require("../../system/memory/index");
+const schema_1 = require("../types/schema");
+const unknown_1 = require("../types/unknown");
+/** Creates an Infer instruction. */
+function Infer(...args) {
+    const [name, extends_] = index_1.Arguments.Match(args, {
+        2: (name, extends_) => [name, extends_, extends_],
+        1: (name) => [name, (0, unknown_1.Unknown)(), (0, unknown_1.Unknown)()],
+    });
+    return index_2.Memory.Create({ ['~kind']: 'Infer' }, { type: 'infer', name, extends: extends_ }, {});
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TInfer. */
+function IsInfer(value) {
+    return (0, schema_1.IsKind)(value, 'Infer');
+}

package/build/cjs/type/types/integer.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema';
+export declare const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+export type StaticInteger = number;
+/** Represents an integer type. */
+export interface TInteger extends TSchema {
+    '~kind': 'Integer';
+    type: 'integer';
+}
+/** Creates a Integer type. */
+export declare function Integer(options?: TNumberOptions): TInteger;
+/** Returns true if the given value is TInteger. */
+export declare function IsInteger(value: unknown): value is TInteger;

package/build/cjs/type/types/integer.js

@@ -0,0 +1,26 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerPattern = void 0;
+exports.Integer = Integer;
+exports.IsInteger = IsInteger;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Pattern
+// ------------------------------------------------------------------
+exports.IntegerPattern = '-?(?:0|[1-9][0-9]*)';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Integer type. */
+function Integer(options) {
+    return index_1.Memory.Create({ '~kind': 'Integer' }, { type: 'integer' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TInteger. */
+function IsInteger(value) {
+    return (0, schema_1.IsKind)(value, 'Integer');
+}

package/build/cjs/type/types/intersect.d.ts

@@ -0,0 +1,15 @@
+import { type StaticType, type StaticDirection } from './static';
+import { type TSchema, type TIntersectOptions } from './schema';
+import { type TProperties } from './properties';
+export type StaticIntersect<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Types extends TSchema[], Result extends unknown = unknown> = (Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? StaticIntersect<Stack, Direction, Context, This, Right, Result & StaticType<Stack, Direction, Context, This, Left>> : Result);
+/** Represents a logical Intersect type. */
+export interface TIntersect<Types extends TSchema[] = TSchema[]> extends TSchema {
+    '~kind': 'Intersect';
+    allOf: Types;
+}
+/** Creates a Intersect type. */
+export declare function Intersect<Types extends TSchema[]>(types: [...Types], options?: TIntersectOptions): TIntersect<Types>;
+/** Returns true if the given value is TIntersect. */
+export declare function IsIntersect(value: unknown): value is TIntersect;
+/** Extracts options from a TIntersect. */
+export declare function IntersectOptions(type: TIntersect): TIntersectOptions;

package/build/cjs/type/types/intersect.js

@@ -0,0 +1,29 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Intersect = Intersect;
+exports.IsIntersect = IsIntersect;
+exports.IntersectOptions = IntersectOptions;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Intersect type. */
+function Intersect(types, options = {}) {
+    return index_1.Memory.Create({ '~kind': 'Intersect' }, { allOf: types }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TIntersect. */
+function IsIntersect(value) {
+    return (0, schema_1.IsKind)(value, 'Intersect');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TIntersect. */
+function IntersectOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'allOf']);
+}

package/build/cjs/type/types/iterator.d.ts

@@ -0,0 +1,16 @@
+import { type StaticType, type StaticDirection } from './static';
+import { type TSchema, type TSchemaOptions } from './schema';
+import { type TProperties } from './properties';
+export type StaticIterator<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, This extends TProperties, Type extends TSchema, Result = IterableIterator<StaticType<Stack, Direction, Context, This, Type>>> = Result;
+/** Represents an Iterator. */
+export interface TIterator<Type extends TSchema = TSchema> extends TSchema {
+    '~kind': 'Iterator';
+    type: 'iterator';
+    iteratorItems: Type;
+}
+/** Creates a Iterator type. */
+export declare function Iterator<Type extends TSchema>(iteratorItems: Type, options?: TSchemaOptions): TIterator<Type>;
+/** Returns true if the given value is TIterator. */
+export declare function IsIterator(value: unknown): value is TIterator;
+/** Extracts options from a TIterator. */
+export declare function IteratorOptions(type: TIterator): TSchemaOptions;

package/build/cjs/type/types/iterator.js

@@ -0,0 +1,29 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Iterator = Iterator;
+exports.IsIterator = IsIterator;
+exports.IteratorOptions = IteratorOptions;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Iterator type. */
+function Iterator(iteratorItems, options) {
+    return index_1.Memory.Create({ '~kind': 'Iterator' }, { type: 'iterator', iteratorItems }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TIterator. */
+function IsIterator(value) {
+    return (0, schema_1.IsKind)(value, 'Iterator');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TIterator. */
+function IteratorOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'type', 'iteratorItems']);
+}

package/build/cjs/type/types/literal.d.ts

@@ -0,0 +1,22 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+export type StaticLiteral<Value extends TLiteralValue> = (Value);
+export type TLiteralValue = string | number | boolean | bigint;
+/** Represents a Literal type. */
+export interface TLiteral<Value extends TLiteralValue = TLiteralValue> extends TSchema {
+    '~kind': 'Literal';
+    const: Value;
+}
+/** Creates a Literal type. */
+export declare function Literal<Value extends TLiteralValue>(value: Value, options?: TSchemaOptions): TLiteral<Value>;
+/** Returns true if the given value is a TLiteralValue. */
+export declare function IsLiteralValue(value: unknown): value is TLiteralValue;
+/** Returns true if the given value is TLiteral<bigint>. */
+export declare function IsLiteralBigInt(value: unknown): value is TLiteral<bigint>;
+/** Returns true if the given value is TLiteral<boolean>. */
+export declare function IsLiteralBoolean(value: unknown): value is TLiteral<boolean>;
+/** Returns true if the given value is TLiteral<number>. */
+export declare function IsLiteralNumber(value: unknown): value is TLiteral<number>;
+/** Returns true if the given value is TLiteral<string>. */
+export declare function IsLiteralString(value: unknown): value is TLiteral<string>;
+/** Returns true if the given value is TLiteral. */
+export declare function IsLiteral(value: unknown): value is TLiteral;

package/build/cjs/type/types/literal.js

@@ -0,0 +1,50 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Literal = Literal;
+exports.IsLiteralValue = IsLiteralValue;
+exports.IsLiteralBigInt = IsLiteralBigInt;
+exports.IsLiteralBoolean = IsLiteralBoolean;
+exports.IsLiteralNumber = IsLiteralNumber;
+exports.IsLiteralString = IsLiteralString;
+exports.IsLiteral = IsLiteral;
+const index_1 = require("../../system/memory/index");
+const index_2 = require("../../guard/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Literal type. */
+function Literal(value, options) {
+    return index_1.Memory.Create({ '~kind': 'Literal' }, { const: value }, options);
+}
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TLiteralValue. */
+function IsLiteralValue(value) {
+    return index_2.Guard.IsBigInt(value)
+        || index_2.Guard.IsBoolean(value)
+        || index_2.Guard.IsNumber(value)
+        || index_2.Guard.IsString(value);
+}
+/** Returns true if the given value is TLiteral<bigint>. */
+function IsLiteralBigInt(value) {
+    return IsLiteral(value) && index_2.Guard.IsBigInt(value.const);
+}
+/** Returns true if the given value is TLiteral<boolean>. */
+function IsLiteralBoolean(value) {
+    return IsLiteral(value) && index_2.Guard.IsBoolean(value.const);
+}
+/** Returns true if the given value is TLiteral<number>. */
+function IsLiteralNumber(value) {
+    return IsLiteral(value) && index_2.Guard.IsNumber(value.const);
+}
+/** Returns true if the given value is TLiteral<string>. */
+function IsLiteralString(value) {
+    return IsLiteral(value) && index_2.Guard.IsString(value.const);
+}
+/** Returns true if the given value is TLiteral. */
+function IsLiteral(value) {
+    return (0, schema_1.IsKind)(value, 'Literal');
+}

package/build/cjs/type/types/never.d.ts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+export declare const NeverPattern = "(?!)";
+export type StaticNever = never;
+/** Represents a Never type. */
+export interface TNever extends TSchema {
+    '~kind': 'Never';
+    not: {};
+}
+/** Creates a Never type. */
+export declare function Never(options?: TSchemaOptions): TNever;
+/** Returns true if the given value is TNever. */
+export declare function IsNever(value: unknown): value is TNever;

package/build/cjs/type/types/never.js

@@ -0,0 +1,26 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeverPattern = void 0;
+exports.Never = Never;
+exports.IsNever = IsNever;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Pattern
+// ------------------------------------------------------------------
+exports.NeverPattern = '(?!)';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Never type. */
+function Never(options) {
+    return index_1.Memory.Create({ '~kind': 'Never' }, { not: {} }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TNever. */
+function IsNever(value) {
+    return (0, schema_1.IsKind)(value, 'Never');
+}

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

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from './schema';
+export type StaticNull = null;
+/** Represents a Null type. */
+export interface TNull extends TSchema {
+    '~kind': 'Null';
+    type: 'null';
+}
+/** Creates a Null type. */
+export declare function Null(options?: TSchemaOptions): TNull;
+/** Returns true if the given value is TNull. */
+export declare function IsNull(value: unknown): value is TNull;

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

@@ -0,0 +1,21 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Null = Null;
+exports.IsNull = IsNull;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Null type. */
+function Null(options) {
+    return index_1.Memory.Create({ '~kind': 'Null' }, { type: 'null' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TNull. */
+function IsNull(value) {
+    return (0, schema_1.IsKind)(value, 'Null');
+}

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

@@ -0,0 +1,12 @@
+import { type TSchema, type TNumberOptions } from './schema';
+export declare const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?";
+export type StaticNumber = number;
+/** Represents a Number type. */
+export interface TNumber extends TSchema {
+    '~kind': 'Number';
+    type: 'number';
+}
+/** Creates a Number type. */
+export declare function Number(options?: TNumberOptions): TNumber;
+/** Returns true if the given value is a TNumber. */
+export declare function IsNumber(value: unknown): value is TNumber;

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

@@ -0,0 +1,26 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberPattern = void 0;
+exports.Number = Number;
+exports.IsNumber = IsNumber;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+// ------------------------------------------------------------------
+// Pattern
+// ------------------------------------------------------------------
+exports.NumberPattern = '-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?';
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates a Number type. */
+function Number(options) {
+    return index_1.Memory.Create({ '~kind': 'Number' }, { type: 'number' }, options);
+}
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is a TNumber. */
+function IsNumber(value) {
+    return (0, schema_1.IsKind)(value, 'Number');
+}

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

@@ -0,0 +1,20 @@
+import { type StaticDirection } from './static';
+import { type TSchema, type TObjectOptions } from './schema';
+import { type TProperties, type TRequiredArray, type StaticProperties } from './properties';
+export type StaticObject<Stack extends string[], Direction extends StaticDirection, Context extends TProperties, _This extends TProperties, Properties extends TProperties, Result = keyof Properties extends never ? object : StaticProperties<Stack, Direction, Context, Properties, Properties>> = Result;
+/** Represents an Object type. */
+export interface TObject<Properties extends TProperties = TProperties> extends TSchema {
+    '~kind': 'Object';
+    type: 'object';
+    properties: Properties;
+    required: TRequiredArray<Properties>;
+}
+/** Creates an Object type. */
+declare function _Object_<Properties extends TProperties>(properties: Properties, options?: TObjectOptions): TObject<Properties>;
+/** `[Json]` Creates an Object type */
+export declare var Object: typeof _Object_;
+/** Returns true if the given value is TObject. */
+export declare function IsObject(value: unknown): value is TObject;
+/** Extracts options from a TObject. */
+export declare function ObjectOptions(type: TObject): TObjectOptions;
+export {};

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

@@ -0,0 +1,34 @@
+"use strict";
+// deno-fmt-ignore-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Object = void 0;
+exports.IsObject = IsObject;
+exports.ObjectOptions = ObjectOptions;
+const index_1 = require("../../system/memory/index");
+const schema_1 = require("./schema");
+const properties_1 = require("./properties");
+// ------------------------------------------------------------------
+// Factory
+// ------------------------------------------------------------------
+/** Creates an Object type. */
+function _Object_(properties, options = {}) {
+    const requiredKeys = (0, properties_1.RequiredArray)(properties);
+    const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
+    return index_1.Memory.Create({ '~kind': 'Object' }, { type: 'object', ...required, properties }, options);
+}
+/** `[Json]` Creates an Object type */
+exports.Object = _Object_; // Required for CommonJS ES Interop
+// ------------------------------------------------------------------
+// Guard
+// ------------------------------------------------------------------
+/** Returns true if the given value is TObject. */
+function IsObject(value) {
+    return (0, schema_1.IsKind)(value, 'Object');
+}
+// ------------------------------------------------------------------
+// Options
+// ------------------------------------------------------------------
+/** Extracts options from a TObject. */
+function ObjectOptions(type) {
+    return index_1.Memory.Discard(type, ['~kind', 'type', 'properties', 'required']);
+}