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

package/build/import/type/intrinsic/intrinsic.mjs

@@ -0,0 +1,59 @@
+import { TemplateLiteral, TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralGenerate } from '../template-literal/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { Union } from '../union/index.mjs';
+import { TTemplateLiteral as IsTemplateLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType } from '../guard/type.mjs';
+import { CloneType } from '../clone/type.mjs';
+function ApplyUncapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toLowerCase(), rest].join('');
+}
+function ApplyCapitalize(value) {
+    const [first, rest] = [value.slice(0, 1), value.slice(1)];
+    return [first.toUpperCase(), rest].join('');
+}
+function ApplyUppercase(value) {
+    return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+    return value.toLowerCase();
+}
+function FromTemplateLiteral(schema, mode) {
+    const expression = TemplateLiteralParseExact(schema.pattern);
+    const finite = IsTemplateLiteralFinite(expression);
+    if (!finite)
+        return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+    const strings = [...TemplateLiteralGenerate(expression)];
+    const literals = strings.map((value) => Literal(value));
+    const mapped = FromRest(literals, mode);
+    const union = Union(mapped);
+    return TemplateLiteral([union]);
+}
+function FromLiteralValue(value, mode) {
+    return (typeof value === 'string' ? (mode === 'Uncapitalize' ? ApplyUncapitalize(value) :
+        mode === 'Capitalize' ? ApplyCapitalize(value) :
+            mode === 'Uppercase' ? ApplyUppercase(value) :
+                mode === 'Lowercase' ? ApplyLowercase(value) :
+                    value) : value.toString());
+}
+function FromRest(T, mode) {
+    const [L, ...R] = T;
+    return (T.length > 0 ? [IntrinsicResolve(L, mode), ...FromRest(R, mode)] : []);
+}
+export function IntrinsicResolve(schema, mode) {
+    return (IsTemplateLiteralType(schema) ? FromTemplateLiteral(schema, mode) :
+        IsUnionType(schema) ? Union(FromRest(schema.anyOf, mode)) :
+            IsLiteralType(schema) ? Literal(FromLiteralValue(schema.const, mode)) :
+                schema);
+}
+export function Uncapitalize(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Uncapitalize'), options);
+}
+export function Uppercase(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Uppercase'), options);
+}
+export function Lowercase(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Lowercase'), options);
+}
+export function Capitalize(T, options = {}) {
+    return CloneType(IntrinsicResolve(T, 'Capitalize'), options);
+}

package/build/import/type/iterator/index.mjs

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

package/build/import/type/iterator/iterator.mjs

@@ -0,0 +1,10 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Iterator(items, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Iterator',
+        type: 'Iterator',
+        items: CloneType(items),
+    };
+}

package/build/import/type/keyof/index.mjs

@@ -0,0 +1,3 @@
+export * from './keyof-string.mjs';
+export * from './keyof-type.mjs';
+export * from './keyof.mjs';

package/build/import/type/keyof/keyof-string.mjs

@@ -0,0 +1,55 @@
+import { Increment } from '../helpers/index.mjs';
+import { OperatorUnionMany, OperatorIntersectMany } from '../operators/index.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TTuple as IsTupleType, TArray as IsArrayType, TObject as IsObjectType, TRecord as IsRecordType } from '../guard/type.mjs';
+function FromRest(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? [KeyOfStringResolve(L), ...FromRest(R)]
+        : []);
+}
+function FromIntersect(T, C = FromRest(T)) {
+    return OperatorUnionMany(C);
+}
+function FromUnion(T) {
+    const C = FromRest(T);
+    return OperatorIntersectMany(C);
+}
+function FromTuple(T, I = '0') {
+    const [_, ...R] = T;
+    return (T.length > 0
+        ? [I, ...FromTuple(R, Increment(I))]
+        : []);
+}
+function FromArray(_) {
+    return (['[number]']);
+}
+function FromProperties(T) {
+    return (globalThis.Object.getOwnPropertyNames(T));
+}
+function FromPatternProperties(patternProperties) {
+    if (!includePatternProperties)
+        return [];
+    const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
+    return patternPropertyKeys.map(key => {
+        return (key[0] === '^' && key[key.length - 1] === '$')
+            ? key.slice(1, key.length - 1)
+            : key;
+    });
+}
+export function KeyOfStringResolve(T) {
+    return (IsIntersectType(T) ? FromIntersect(T.allOf) :
+        IsUnionType(T) ? FromUnion(T.anyOf) :
+            IsTupleType(T) ? FromTuple(T.items ?? []) :
+                IsArrayType(T) ? FromArray(T.items) :
+                    IsObjectType(T) ? FromProperties(T.properties) :
+                        IsRecordType(T) ? FromPatternProperties(T.patternProperties) :
+                            []);
+}
+let includePatternProperties = false;
+export function KeyOfStringResolvePattern(schema) {
+    includePatternProperties = true;
+    const keys = KeyOfStringResolve(schema);
+    includePatternProperties = false;
+    const pattern = keys.map((key) => `(${key})`);
+    return `^(${pattern.join('|')})$`;
+}

package/build/import/type/keyof/keyof-type.mjs

@@ -0,0 +1,15 @@
+import { Literal } from '../literal/index.mjs';
+import { Number } from '../number/index.mjs';
+import { KeyOfStringResolve } from './keyof-string.mjs';
+import { UnionResolve } from '../union/index.mjs';
+function FromLiterals(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? L === '[number]'
+            ? [Number(), ...FromLiterals(R)]
+            : [Literal(L), ...FromLiterals(R)]
+        : []);
+}
+export function KeyOfTypeResolve(T) {
+    return (UnionResolve(FromLiterals(KeyOfStringResolve(T))));
+}

package/build/import/type/keyof/keyof.mjs

@@ -0,0 +1,6 @@
+import { KeyOfTypeResolve } from './keyof-type.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function KeyOf(schema, options = {}) {
+    const K = KeyOfTypeResolve(schema);
+    return CloneType(K, options);
+}

package/build/import/type/literal/index.mjs

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

package/build/import/type/literal/literal.mjs

@@ -0,0 +1,9 @@
+import { Kind } from '../symbols/index.mjs';
+export function Literal(value, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Literal',
+        const: value,
+        type: typeof value,
+    };
+}

package/build/import/type/mapped/index.mjs

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

package/build/import/type/mapped/mapped.mjs

@@ -0,0 +1,14 @@
+import { Object } from '../object/index.mjs';
+import { Literal } from '../literal/index.mjs';
+import { IndexedKeyResolve } from '../indexed/indexed-key.mjs';
+import { TSchema as IsSchemaType } from '../guard/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+export function Mapped(key, map) {
+    const keys = IsSchemaType(key) ? IndexedKeyResolve(key) : key;
+    const anyOf = keys.map(key => Literal(key));
+    const mapped = { [Kind]: 'MappedKey', anyOf };
+    const properties = keys.reduce((acc, key) => {
+        return { ...acc, [key]: map(mapped) };
+    }, {});
+    return Object(properties);
+}

package/build/import/type/modifiers/index.mjs

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

package/build/import/type/modifiers/modifiers.mjs

@@ -0,0 +1,40 @@
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Optional } from '../optional/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { OptionalKind } from '../symbols/index.mjs';
+import { TOptional as IsOptionalType } from '../guard/type.mjs';
+function IsOptionalFromIntersect(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptionalType(L)
+            ? IsOptionalFromIntersect(R)
+            : false
+        : true);
+}
+function IsOptionalFromUnion(T) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? IsOptionalType(L)
+            ? true
+            : IsOptionalFromUnion(R)
+        : false);
+}
+function RemoveOptionalFromRest(T) {
+    return (T.map(T => RemoveOptionalFromSchema(T)));
+}
+function RemoveOptionalFromSchema(T) {
+    return (Discard(T, [OptionalKind]));
+}
+export function OptionalFromIntersect(T) {
+    const D = RemoveOptionalFromRest(T);
+    return (IsOptionalFromIntersect(T)
+        ? Optional(Intersect(D))
+        : Intersect(T));
+}
+export function OptionalFromUnion(T) {
+    const D = RemoveOptionalFromRest(T);
+    return (IsOptionalFromUnion(T)
+        ? Optional(Union(D))
+        : Union(T));
+}

package/build/import/type/never/index.mjs

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

package/build/import/type/never/never.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function Never(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Never',
+        not: {},
+    };
+}

package/build/import/type/not/index.mjs

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

package/build/import/type/not/not.mjs

@@ -0,0 +1,9 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Not(schema, options) {
+    return {
+        ...options,
+        [Kind]: 'Not',
+        not: CloneType(schema),
+    };
+}

package/build/import/type/null/index.mjs

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

package/build/import/type/null/null.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function Null(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Null',
+        type: 'null',
+    };
+}

package/build/import/type/number/index.mjs

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

package/build/import/type/number/number.mjs

@@ -0,0 +1,8 @@
+import { Kind } from '../symbols/index.mjs';
+export function Number(options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Number',
+        type: 'number',
+    };
+}

package/build/import/type/object/index.mjs

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

package/build/import/type/object/object.mjs

@@ -0,0 +1,14 @@
+import { CloneType } from '../clone/type.mjs';
+import { Kind } from '../symbols/index.mjs';
+import { TOptional as IsOptionalType, TSchema as IsSchemaType } from '../guard/type.mjs';
+export function _Object(properties, options = {}) {
+    const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
+    const optionalKeys = propertyKeys.filter((key) => IsOptionalType(properties[key]));
+    const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+    const clonedAdditionalProperties = IsSchemaType(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
+    const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: CloneType(properties[key]) }), {});
+    return (requiredKeys.length > 0
+        ? { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties, required: requiredKeys }
+        : { ...options, ...clonedAdditionalProperties, [Kind]: 'Object', type: 'object', properties: clonedProperties });
+}
+export const Object = _Object;

package/build/import/type/omit/index.mjs

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

package/build/import/type/omit/omit.mjs

@@ -0,0 +1,35 @@
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Object } from '../object/index.mjs';
+import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { TransformKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+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);
+}
+export function OmitResolve(T, K) {
+    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf, K)) :
+        IsUnionType(T) ? Union(FromUnion(T.anyOf, K)) :
+            IsObjectType(T) ? Object(FromProperties(T.properties, K)) :
+                Object({}));
+}
+export function Omit(T, K, options = {}) {
+    const I = IsSchemaType(K) ? IndexedKeyResolve(K) : K;
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(OmitResolve(T, I), options);
+    return { ...D, ...R };
+}

package/build/import/type/operators/index.mjs

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

package/build/import/type/operators/operators.mjs

@@ -0,0 +1,66 @@
+export function OperatorIncludes(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? S === L
+            ? true
+            : OperatorIncludes(R, S)
+        : false);
+}
+export function OperatorSubset(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? OperatorSubset(R, S)
+            : false
+        : true);
+}
+export function OperatorDistinct(T, Acc = []) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(Acc, L) === false
+            ? OperatorDistinct(R, [...Acc, L])
+            : OperatorDistinct(R, [...Acc])
+        : Acc);
+}
+export function OperatorIntersect(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? [L, ...OperatorIntersect(R, S)]
+            : [...OperatorIntersect(R, S)]
+        : []);
+}
+export function OperatorUnion(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? [...OperatorUnion(R, S)]
+            : [L, ...OperatorUnion(R, S)]
+        : S);
+}
+export function OperatorComplement(T, S) {
+    const [L, ...R] = T;
+    return (T.length > 0
+        ? OperatorIncludes(S, L) === true
+            ? [...OperatorComplement(R, S)]
+            : [L, ...OperatorComplement(R, S)]
+        : []);
+}
+export function OperatorIntersectMany(T) {
+    return (T.length === 1
+        ? T[0]
+        : (() => {
+            const [L, ...R] = T;
+            return (L.length > 0
+                ? OperatorIntersect(L, OperatorIntersectMany(R))
+                : []);
+        })());
+}
+export function OperatorUnionMany(T) {
+    return (T.length === 1
+        ? T[0]
+        : (() => {
+            const [L, ...R] = T;
+            return T.length > 0 ? OperatorUnion(L, OperatorUnionMany(R)) : [];
+        })());
+}

package/build/import/type/optional/index.mjs

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

package/build/import/type/optional/optional.mjs

@@ -0,0 +1,5 @@
+import { OptionalKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Optional(schema) {
+    return { ...CloneType(schema), [OptionalKind]: 'Optional' };
+}

package/build/import/type/parameters/index.mjs

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

package/build/import/type/parameters/parameters.mjs

@@ -0,0 +1,5 @@
+import { Tuple } from '../tuple/index.mjs';
+import { CloneRest } from '../clone/type.mjs';
+export function Parameters(schema, options = {}) {
+    return Tuple(CloneRest(schema.parameters), { ...options });
+}

package/build/import/type/partial/index.mjs

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

package/build/import/type/partial/partial.mjs

@@ -0,0 +1,36 @@
+import { Optional } from '../optional/index.mjs';
+import { Object } from '../object/index.mjs';
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { TransformKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType } from '../guard/type.mjs';
+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]: Optional(T[K]) };
+    }, {});
+}
+export function PartialResolve(T) {
+    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf)) :
+        IsUnionType(T) ? Union(FromUnion(T.anyOf)) :
+            IsObjectType(T) ? Object(FromProperties(T.properties)) :
+                Object({}));
+}
+export function Partial(T, options = {}) {
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PartialResolve(T), options);
+    return { ...D, ...R };
+}

package/build/import/type/patterns/index.mjs

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

package/build/import/type/patterns/patterns.mjs

@@ -0,0 +1,6 @@
+export const PatternBoolean = '(true|false)';
+export const PatternNumber = '(0|[1-9][0-9]*)';
+export const PatternString = '(.*)';
+export const PatternBooleanExact = `^${PatternBoolean}$`;
+export const PatternNumberExact = `^${PatternNumber}$`;
+export const PatternStringExact = `^${PatternString}$`;

package/build/import/type/pick/index.mjs

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

package/build/import/type/pick/pick.mjs

@@ -0,0 +1,31 @@
+import { Intersect } from '../intersect/index.mjs';
+import { Union } from '../union/index.mjs';
+import { Object } from '../object/index.mjs';
+import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { Discard } from '../discard/index.mjs';
+import { TransformKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { TIntersect as IsIntersectType, TUnion as IsUnionType, TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+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;
+    }, {});
+}
+export function PickResolve(T, K) {
+    return (IsIntersectType(T) ? Intersect(FromIntersect(T.allOf, K)) :
+        IsUnionType(T) ? Union(FromUnion(T.anyOf, K)) :
+            IsObjectType(T) ? Object(FromProperties(T.properties, K)) :
+                Object({}));
+}
+export function Pick(T, K, options = {}) {
+    const I = IsSchemaType(K) ? IndexedKeyResolve(K) : K;
+    const D = Discard(T, [TransformKind, '$id', 'required']);
+    const R = CloneType(PickResolve(T, I), options);
+    return { ...D, ...R };
+}

package/build/import/type/promise/index.mjs

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

package/build/import/type/promise/promise.mjs

@@ -0,0 +1,10 @@
+import { Kind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Promise(item, options = {}) {
+    return {
+        ...options,
+        [Kind]: 'Promise',
+        type: 'Promise',
+        item: CloneType(item),
+    };
+}

package/build/import/type/readonly/index.mjs

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

package/build/import/type/readonly/readonly.mjs

@@ -0,0 +1,5 @@
+import { ReadonlyKind } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+export function Readonly(schema) {
+    return { ...CloneType(schema), [ReadonlyKind]: 'Readonly' };
+}

package/build/import/type/readonly-optional/index.mjs

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

package/build/import/type/readonly-optional/readonly-optional.mjs

@@ -0,0 +1,5 @@
+import { Readonly } from '../readonly/index.mjs';
+import { Optional } from '../optional/index.mjs';
+export function ReadonlyOptional(schema) {
+    return Readonly(Optional(schema));
+}

package/build/import/type/record/index.mjs

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

package/build/import/type/record/record.mjs

@@ -0,0 +1,51 @@
+import { Object } from '../object/index.mjs';
+import { Never } from '../never/index.mjs';
+import { Union } from '../union/index.mjs';
+import { IsTemplateLiteralFinite, TemplateLiteralParseExact } from '../template-literal/index.mjs';
+import { PatternStringExact, PatternNumberExact } from '../patterns/index.mjs';
+import { IndexedKeyResolve } from '../indexed/index.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+import { CloneType } from '../clone/type.mjs';
+import { IsUndefined } from '../guard/value.mjs';
+import { TUnion as IsUnionType, TTemplateLiteral as IsTemplateLiteralType, TLiteral as IsLiteralType, TString as IsStringType, TInteger as IsIntegerType, TNumber as IsNumberType } from '../guard/type.mjs';
+function FromPattern(pattern, T) {
+    return { [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: CloneType(T) } };
+}
+function FromKeys(keys, T) {
+    const properties = keys.reduce((acc, key) => ({ ...acc, [key]: CloneType(T) }), {});
+    return Object(properties, { [Hint]: 'Record' });
+}
+function FromTemplateLiteralKey(K, T) {
+    const expression = TemplateLiteralParseExact(K.pattern);
+    return (IsTemplateLiteralFinite(expression)
+        ? FromKeys(IndexedKeyResolve(K), T)
+        : FromPattern(K.pattern, T));
+}
+function FromUnionKey(K, T) {
+    return FromKeys(IndexedKeyResolve(Union(K)), T);
+}
+function FromLiteralKey(K, T) {
+    return FromKeys([K.toString()], T);
+}
+function FromStringKey(K, T) {
+    const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern;
+    return FromPattern(pattern, T);
+}
+function FromIntegerKey(_, T) {
+    return FromPattern(PatternNumberExact, T);
+}
+function FromNumberKey(_, T) {
+    return FromPattern(PatternNumberExact, T);
+}
+export function RecordResolve(K, T) {
+    return (IsUnionType(K) ? FromUnionKey(K.anyOf, T) :
+        IsTemplateLiteralType(K) ? FromTemplateLiteralKey(K, T) :
+            IsLiteralType(K) ? FromLiteralKey(K.const, T) :
+                IsStringType(K) ? FromStringKey(K, T) :
+                    IsIntegerType(K) ? FromIntegerKey(K, T) :
+                        IsNumberType(K) ? FromNumberKey(K, T) :
+                            Never());
+}
+export function Record(K, T, options = {}) {
+    return CloneType(RecordResolve(K, T), options);
+}

package/build/import/type/recursive/index.mjs

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

package/build/import/type/recursive/recursive.mjs

@@ -0,0 +1,15 @@
+import { CloneType } from '../clone/type.mjs';
+import { IsUndefined } from '../guard/value.mjs';
+import { Kind, Hint } from '../symbols/index.mjs';
+let Ordinal = 0;
+export function Recursive(callback, options = {}) {
+    if (IsUndefined(options.$id))
+        options.$id = `T${Ordinal++}`;
+    const thisType = callback({ [Kind]: 'This', $ref: `${options.$id}` });
+    thisType.$id = options.$id;
+    return CloneType({
+        ...options,
+        [Hint]: 'Recursive',
+        ...thisType,
+    });
+}

package/build/import/type/ref/index.mjs

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