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

package/build/import/type/guard/type.mjs

@@ -57,7 +57,7 @@ function IsControlCharacterFree(value) {
     return true;
 }
 function IsAdditionalProperties(value) {
-    return IsOptionalBoolean(value) || TSchema(value);
+    return IsOptionalBoolean(value) || IsSchema(value);
 }
 function IsOptionalBigInt(value) {
     return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
@@ -78,34 +78,34 @@ function IsOptionalFormat(value) {
     return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value));
 }
 function IsOptionalSchema(value) {
-    return ValueGuard.IsUndefined(value) || TSchema(value);
+    return ValueGuard.IsUndefined(value) || IsSchema(value);
 }
 // ------------------------------------------------------------------
 // Modifiers
 // ------------------------------------------------------------------
 /** Returns true if this value has a Readonly symbol */
-export function TReadonly(value) {
+export function IsReadonly(value) {
     return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly';
 }
 /** Returns true if this value has a Optional symbol */
-export function TOptional(value) {
+export function IsOptional(value) {
     return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional';
 }
 // ------------------------------------------------------------------
 // Types
 // ------------------------------------------------------------------
 /** Returns true if the given value is TAny */
-export function TAny(value) {
+export function IsAny(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Any') &&
+    return (IsKindOf(value, 'Any') &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is TArray */
-export function TArray(value) {
-    return (TKindOf(value, 'Array') &&
+export function IsArray(value) {
+    return (IsKindOf(value, 'Array') &&
         value.type === 'array' &&
         IsOptionalString(value.$id) &&
-        TSchema(value.items) &&
+        IsSchema(value.items) &&
         IsOptionalNumber(value.minItems) &&
         IsOptionalNumber(value.maxItems) &&
         IsOptionalBoolean(value.uniqueItems) &&
@@ -114,17 +114,17 @@ export function TArray(value) {
         IsOptionalNumber(value.maxContains));
 }
 /** Returns true if the given value is TAsyncIterator */
-export function TAsyncIterator(value) {
+export function IsAsyncIterator(value) {
     // prettier-ignore
-    return (TKindOf(value, 'AsyncIterator') &&
+    return (IsKindOf(value, 'AsyncIterator') &&
         value.type === 'AsyncIterator' &&
         IsOptionalString(value.$id) &&
-        TSchema(value.items));
+        IsSchema(value.items));
 }
 /** Returns true if the given value is TBigInt */
-export function TBigInt(value) {
+export function IsBigInt(value) {
     // prettier-ignore
-    return (TKindOf(value, 'BigInt') &&
+    return (IsKindOf(value, 'BigInt') &&
         value.type === 'bigint' &&
         IsOptionalString(value.$id) &&
         IsOptionalBigInt(value.exclusiveMaximum) &&
@@ -134,25 +134,25 @@ export function TBigInt(value) {
         IsOptionalBigInt(value.multipleOf));
 }
 /** Returns true if the given value is TBoolean */
-export function TBoolean(value) {
+export function IsBoolean(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Boolean') &&
+    return (IsKindOf(value, 'Boolean') &&
         value.type === 'boolean' &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is TConstructor */
-export function TConstructor(value) {
+export function IsConstructor(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Constructor') &&
+    return (IsKindOf(value, 'Constructor') &&
         value.type === 'Constructor' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsArray(value.parameters) &&
-        value.parameters.every(schema => TSchema(schema)) &&
-        TSchema(value.returns));
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
 }
 /** Returns true if the given value is TDate */
-export function TDate(value) {
-    return (TKindOf(value, 'Date') &&
+export function IsDate(value) {
+    return (IsKindOf(value, 'Date') &&
         value.type === 'Date' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.exclusiveMaximumTimestamp) &&
@@ -162,18 +162,18 @@ export function TDate(value) {
         IsOptionalNumber(value.multipleOfTimestamp));
 }
 /** Returns true if the given value is TFunction */
-export function TFunction(value) {
+export function IsFunction(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Function') &&
+    return (IsKindOf(value, 'Function') &&
         value.type === 'Function' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsArray(value.parameters) &&
-        value.parameters.every(schema => TSchema(schema)) &&
-        TSchema(value.returns));
+        value.parameters.every(schema => IsSchema(schema)) &&
+        IsSchema(value.returns));
 }
 /** Returns true if the given value is TInteger */
-export function TInteger(value) {
-    return (TKindOf(value, 'Integer') &&
+export function IsInteger(value) {
+    return (IsKindOf(value, 'Integer') &&
         value.type === 'integer' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.exclusiveMaximum) &&
@@ -183,92 +183,92 @@ export function TInteger(value) {
         IsOptionalNumber(value.multipleOf));
 }
 /** Returns true if the given schema is TProperties */
-export function TProperties(value) {
+export function IsProperties(value) {
     // prettier-ignore
     return (ValueGuard.IsObject(value) &&
-        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && TSchema(schema)));
+        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema)));
 }
 /** Returns true if the given value is TIntersect */
-export function TIntersect(value) {
+export function IsIntersect(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Intersect') &&
+    return (IsKindOf(value, 'Intersect') &&
         (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
         ValueGuard.IsArray(value.allOf) &&
-        value.allOf.every(schema => TSchema(schema) && !TTransform(schema)) &&
+        value.allOf.every(schema => IsSchema(schema) && !IsTransform(schema)) &&
         IsOptionalString(value.type) &&
         (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is TIterator */
-export function TIterator(value) {
+export function IsIterator(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Iterator') &&
+    return (IsKindOf(value, 'Iterator') &&
         value.type === 'Iterator' &&
         IsOptionalString(value.$id) &&
-        TSchema(value.items));
+        IsSchema(value.items));
 }
 /** Returns true if the given value is a TKind with the given name. */
-export function TKindOf(value, kind) {
+export function IsKindOf(value, kind) {
     return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind;
 }
 /** Returns true if the given value is TLiteral<string> */
-export function TLiteralString(value) {
-    return TLiteral(value) && ValueGuard.IsString(value.const);
+export function IsLiteralString(value) {
+    return IsLiteral(value) && ValueGuard.IsString(value.const);
 }
 /** Returns true if the given value is TLiteral<number> */
-export function TLiteralNumber(value) {
-    return TLiteral(value) && ValueGuard.IsNumber(value.const);
+export function IsLiteralNumber(value) {
+    return IsLiteral(value) && ValueGuard.IsNumber(value.const);
 }
 /** Returns true if the given value is TLiteral<boolean> */
-export function TLiteralBoolean(value) {
-    return TLiteral(value) && ValueGuard.IsBoolean(value.const);
+export function IsLiteralBoolean(value) {
+    return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
 }
 /** Returns true if the given value is TLiteral */
-export function TLiteral(value) {
+export function IsLiteral(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Literal') &&
-        IsOptionalString(value.$id) && TLiteralValue(value.const));
+    return (IsKindOf(value, 'Literal') &&
+        IsOptionalString(value.$id) && IsLiteralValue(value.const));
 }
 /** Returns true if the given value is a TLiteralValue */
-export function TLiteralValue(value) {
+export function IsLiteralValue(value) {
     return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
 }
 /** Returns true if the given value is a TMappedKey */
-export function TMappedKey(value) {
+export function IsMappedKey(value) {
     // prettier-ignore
-    return (TKindOf(value, 'MappedKey') &&
+    return (IsKindOf(value, 'MappedKey') &&
         ValueGuard.IsArray(value.keys) &&
         value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
 }
 /** Returns true if the given value is TMappedResult */
-export function TMappedResult(value) {
+export function IsMappedResult(value) {
     // prettier-ignore
-    return (TKindOf(value, 'MappedResult') &&
-        TProperties(value.properties));
+    return (IsKindOf(value, 'MappedResult') &&
+        IsProperties(value.properties));
 }
 /** Returns true if the given value is TNever */
-export function TNever(value) {
+export function IsNever(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Never') &&
+    return (IsKindOf(value, 'Never') &&
         ValueGuard.IsObject(value.not) &&
         Object.getOwnPropertyNames(value.not).length === 0);
 }
 /** Returns true if the given value is TNot */
-export function TNot(value) {
+export function IsNot(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Not') &&
-        TSchema(value.not));
+    return (IsKindOf(value, 'Not') &&
+        IsSchema(value.not));
 }
 /** Returns true if the given value is TNull */
-export function TNull(value) {
+export function IsNull(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Null') &&
+    return (IsKindOf(value, 'Null') &&
         value.type === 'null' &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is TNumber */
-export function TNumber(value) {
-    return (TKindOf(value, 'Number') &&
+export function IsNumber(value) {
+    return (IsKindOf(value, 'Number') &&
         value.type === 'number' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.exclusiveMaximum) &&
@@ -278,28 +278,28 @@ export function TNumber(value) {
         IsOptionalNumber(value.multipleOf));
 }
 /** Returns true if the given value is TObject */
-export function TObject(value) {
+export function IsObject(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Object') &&
+    return (IsKindOf(value, 'Object') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
-        TProperties(value.properties) &&
+        IsProperties(value.properties) &&
         IsAdditionalProperties(value.additionalProperties) &&
         IsOptionalNumber(value.minProperties) &&
         IsOptionalNumber(value.maxProperties));
 }
 /** Returns true if the given value is TPromise */
-export function TPromise(value) {
+export function IsPromise(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Promise') &&
+    return (IsKindOf(value, 'Promise') &&
         value.type === 'Promise' &&
         IsOptionalString(value.$id) &&
-        TSchema(value.item));
+        IsSchema(value.item));
 }
 /** Returns true if the given value is TRecord */
-export function TRecord(value) {
+export function IsRecord(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Record') &&
+    return (IsKindOf(value, 'Record') &&
         value.type === 'object' &&
         IsOptionalString(value.$id) &&
         IsAdditionalProperties(value.additionalProperties) &&
@@ -309,24 +309,24 @@ export function TRecord(value) {
             return (keys.length === 1 &&
                 IsPattern(keys[0]) &&
                 ValueGuard.IsObject(schema.patternProperties) &&
-                TSchema(schema.patternProperties[keys[0]]));
+                IsSchema(schema.patternProperties[keys[0]]));
         })(value));
 }
 /** Returns true if this value is TRecursive */
-export function TRecursive(value) {
+export function IsRecursive(value) {
     return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive';
 }
 /** Returns true if the given value is TRef */
-export function TRef(value) {
+export function IsRef(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Ref') &&
+    return (IsKindOf(value, 'Ref') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
 /** Returns true if the given value is TString */
-export function TString(value) {
+export function IsString(value) {
     // prettier-ignore
-    return (TKindOf(value, 'String') &&
+    return (IsKindOf(value, 'String') &&
         value.type === 'string' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.minLength) &&
@@ -335,36 +335,36 @@ export function TString(value) {
         IsOptionalFormat(value.format));
 }
 /** Returns true if the given value is TSymbol */
-export function TSymbol(value) {
+export function IsSymbol(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Symbol') &&
+    return (IsKindOf(value, 'Symbol') &&
         value.type === 'symbol' &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is TTemplateLiteral */
-export function TTemplateLiteral(value) {
+export function IsTemplateLiteral(value) {
     // prettier-ignore
-    return (TKindOf(value, 'TemplateLiteral') &&
+    return (IsKindOf(value, 'TemplateLiteral') &&
         value.type === 'string' &&
         ValueGuard.IsString(value.pattern) &&
         value.pattern[0] === '^' &&
         value.pattern[value.pattern.length - 1] === '$');
 }
 /** Returns true if the given value is TThis */
-export function TThis(value) {
+export function IsThis(value) {
     // prettier-ignore
-    return (TKindOf(value, 'This') &&
+    return (IsKindOf(value, 'This') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsString(value.$ref));
 }
 /** Returns true of this value is TTransform */
-export function TTransform(value) {
+export function IsTransform(value) {
     return ValueGuard.IsObject(value) && TransformKind in value;
 }
 /** Returns true if the given value is TTuple */
-export function TTuple(value) {
+export function IsTuple(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Tuple') &&
+    return (IsKindOf(value, 'Tuple') &&
         value.type === 'array' &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsNumber(value.minItems) &&
@@ -374,93 +374,93 @@ export function TTuple(value) {
         ValueGuard.IsUndefined(value.items) &&
             ValueGuard.IsUndefined(value.additionalItems) &&
             value.minItems === 0) || (ValueGuard.IsArray(value.items) &&
-            value.items.every(schema => TSchema(schema)))));
+            value.items.every(schema => IsSchema(schema)))));
 }
 /** Returns true if the given value is TUndefined */
-export function TUndefined(value) {
+export function IsUndefined(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Undefined') &&
+    return (IsKindOf(value, 'Undefined') &&
         value.type === 'undefined' &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is TUnion<Literal<string | number>[]> */
-export function TUnionLiteral(value) {
-    return TUnion(value) && value.anyOf.every((schema) => TLiteralString(schema) || TLiteralNumber(schema));
+export function IsUnionLiteral(value) {
+    return IsUnion(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
 }
 /** Returns true if the given value is TUnion */
-export function TUnion(value) {
+export function IsUnion(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Union') &&
+    return (IsKindOf(value, 'Union') &&
         IsOptionalString(value.$id) &&
         ValueGuard.IsObject(value) &&
         ValueGuard.IsArray(value.anyOf) &&
-        value.anyOf.every(schema => TSchema(schema)));
+        value.anyOf.every(schema => IsSchema(schema)));
 }
 /** Returns true if the given value is TUint8Array */
-export function TUint8Array(value) {
+export function IsUint8Array(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Uint8Array') &&
+    return (IsKindOf(value, 'Uint8Array') &&
         value.type === 'Uint8Array' &&
         IsOptionalString(value.$id) &&
         IsOptionalNumber(value.minByteLength) &&
         IsOptionalNumber(value.maxByteLength));
 }
 /** Returns true if the given value is TUnknown */
-export function TUnknown(value) {
+export function IsUnknown(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Unknown') &&
+    return (IsKindOf(value, 'Unknown') &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is a raw TUnsafe */
-export function TUnsafe(value) {
-    return TKindOf(value, 'Unsafe');
+export function IsUnsafe(value) {
+    return IsKindOf(value, 'Unsafe');
 }
 /** Returns true if the given value is TVoid */
-export function TVoid(value) {
+export function IsVoid(value) {
     // prettier-ignore
-    return (TKindOf(value, 'Void') &&
+    return (IsKindOf(value, 'Void') &&
         value.type === 'void' &&
         IsOptionalString(value.$id));
 }
 /** Returns true if the given value is TKind */
-export function TKind(value) {
+export function IsKind(value) {
     return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
 /** Returns true if the given value is TSchema */
-export function TSchema(value) {
+export function IsSchema(value) {
     // prettier-ignore
-    return (ValueGuard.IsObject(value)) && (TAny(value) ||
-        TArray(value) ||
-        TBoolean(value) ||
-        TBigInt(value) ||
-        TAsyncIterator(value) ||
-        TConstructor(value) ||
-        TDate(value) ||
-        TFunction(value) ||
-        TInteger(value) ||
-        TIntersect(value) ||
-        TIterator(value) ||
-        TLiteral(value) ||
-        TMappedKey(value) ||
-        TMappedResult(value) ||
-        TNever(value) ||
-        TNot(value) ||
-        TNull(value) ||
-        TNumber(value) ||
-        TObject(value) ||
-        TPromise(value) ||
-        TRecord(value) ||
-        TRef(value) ||
-        TString(value) ||
-        TSymbol(value) ||
-        TTemplateLiteral(value) ||
-        TThis(value) ||
-        TTuple(value) ||
-        TUndefined(value) ||
-        TUnion(value) ||
-        TUint8Array(value) ||
-        TUnknown(value) ||
-        TUnsafe(value) ||
-        TVoid(value) ||
-        TKind(value));
+    return (ValueGuard.IsObject(value)) && (IsAny(value) ||
+        IsArray(value) ||
+        IsBoolean(value) ||
+        IsBigInt(value) ||
+        IsAsyncIterator(value) ||
+        IsConstructor(value) ||
+        IsDate(value) ||
+        IsFunction(value) ||
+        IsInteger(value) ||
+        IsIntersect(value) ||
+        IsIterator(value) ||
+        IsLiteral(value) ||
+        IsMappedKey(value) ||
+        IsMappedResult(value) ||
+        IsNever(value) ||
+        IsNot(value) ||
+        IsNull(value) ||
+        IsNumber(value) ||
+        IsObject(value) ||
+        IsPromise(value) ||
+        IsRecord(value) ||
+        IsRef(value) ||
+        IsString(value) ||
+        IsSymbol(value) ||
+        IsTemplateLiteral(value) ||
+        IsThis(value) ||
+        IsTuple(value) ||
+        IsUndefined(value) ||
+        IsUnion(value) ||
+        IsUint8Array(value) ||
+        IsUnknown(value) ||
+        IsUnsafe(value) ||
+        IsVoid(value) ||
+        IsKind(value));
 }

package/build/import/type/indexed/indexed-property-keys.mjs

@@ -3,14 +3,14 @@ import { TemplateLiteralParseExact, IsTemplateLiteralFinite, TemplateLiteralToUn
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TTemplateLiteral as IsTemplateLiteralType, TUnionLiteral as IsUnionLiteralType, TUnion as IsUnionType, TLiteral as IsLiteralType, TNumber as IsNumberType, TInteger as IsIntegerType } from '../guard/type.mjs';
+import { IsTemplateLiteral, IsUnionLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/type.mjs';
 // prettier-ignore
 function FromTemplateLiteral(T) {
     const E = TemplateLiteralParseExact(T.pattern);
     const F = IsTemplateLiteralFinite(E);
     const S = TemplateLiteralToUnion(T);
     return (F === true
-        ? IsUnionLiteralType(S)
+        ? IsUnionLiteral(S)
             ? S.anyOf.map(S => S.const.toString())
             : []
         : []);
@@ -29,10 +29,10 @@ function FromLiteral(T) {
 /** Returns a tuple of PropertyKeys derived from the given TSchema */
 // prettier-ignore
 export function IndexPropertyKeys(T) {
-    return [...new Set((IsTemplateLiteralType(T) ? FromTemplateLiteral(T) :
-            IsUnionType(T) ? FromUnion(T.anyOf) :
-                IsLiteralType(T) ? FromLiteral(T.const) :
-                    IsNumberType(T) ? ['[number]'] :
-                        IsIntegerType(T) ? ['[number]'] :
+    return [...new Set((IsTemplateLiteral(T) ? FromTemplateLiteral(T) :
+            IsUnion(T) ? FromUnion(T.anyOf) :
+                IsLiteral(T) ? FromLiteral(T.const) :
+                    IsNumber(T) ? ['[number]'] :
+                        IsInteger(T) ? ['[number]'] :
                             []))];
 }

package/build/import/type/indexed/indexed.mjs

@@ -8,7 +8,7 @@ import { IndexFromMappedKey } from './indexed-from-mapped-key.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TArray as IsArrayType, TIntersect as IsIntersectType, TObject as IsObjectType, TMappedKey as IsMappedKey, TNever as IsNeverType, TSchema as IsSchemaType, TTuple as IsTupleType, TUnion as IsUnionType } from '../guard/type.mjs';
+import { IsArray, IsIntersect, IsObject, IsMappedKey, IsNever, IsSchema, IsTuple, IsUnion } from '../guard/type.mjs';
 // prettier-ignore
 function FromRest(T, K) {
     const [L, ...R] = T;
@@ -20,7 +20,7 @@ function FromRest(T, K) {
 function FromIntersectRest(T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? IsNeverType(L)
+        ? IsNever(L)
             ? [...FromIntersectRest(R)]
             : [L, ...FromIntersectRest(R)]
         : []);
@@ -33,7 +33,7 @@ function FromIntersect(T, K) {
 function FromUnionRest(T, S = T) {
     const [L, ...R] = T;
     return (T.length > 0
-        ? IsNeverType(L)
+        ? IsNever(L)
             ? []
             : FromUnionRest(R, S)
         : S);
@@ -62,11 +62,11 @@ function FromProperty(T, K) {
 }
 // prettier-ignore
 function FromKey(T, K) {
-    return (IsIntersectType(T) ? FromIntersect(T.allOf, K) :
-        IsUnionType(T) ? FromUnion(T.anyOf, K) :
-            IsTupleType(T) ? FromTuple(T.items ?? [], K) :
-                IsArrayType(T) ? FromArray(T.items, K) :
-                    IsObjectType(T) ? FromProperty(T.properties, K) :
+    return (IsIntersect(T) ? FromIntersect(T.allOf, K) :
+        IsUnion(T) ? FromUnion(T.anyOf, K) :
+            IsTuple(T) ? FromTuple(T.items ?? [], K) :
+                IsArray(T) ? FromArray(T.items, K) :
+                    IsObject(T) ? FromProperty(T.properties, K) :
                         Never());
 }
 // prettier-ignore
@@ -84,6 +84,6 @@ function FromSchema(T, K) {
 export function Index(T, K, options = {}) {
     // prettier-ignore
     return (IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) :
-        IsSchemaType(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
+        IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) :
             CloneType(FromSchema(T, K), options));
 }

package/build/import/type/intersect/intersect-create.mjs

@@ -4,17 +4,17 @@ import { CloneType, CloneRest } from '../clone/type.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TObject as IsObjectType, TSchema as IsSchemaType } from '../guard/type.mjs';
+import { IsObject, IsSchema } from '../guard/type.mjs';
 // ------------------------------------------------------------------
 // IntersectCreate
 // ------------------------------------------------------------------
 // prettier-ignore
 export function IntersectCreate(T, options) {
-    const allObjects = T.every((schema) => IsObjectType(schema));
-    const clonedUnevaluatedProperties = IsSchemaType(options.unevaluatedProperties)
+    const allObjects = T.every((schema) => IsObject(schema));
+    const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties)
         ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) }
         : {};
-    return ((options.unevaluatedProperties === false || IsSchemaType(options.unevaluatedProperties) || allObjects
+    return ((options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects
         ? { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', type: 'object', allOf: CloneRest(T) }
         : { ...options, ...clonedUnevaluatedProperties, [Kind]: 'Intersect', allOf: CloneRest(T) }));
 }

package/build/import/type/intersect/intersect-evaluated.mjs

@@ -8,7 +8,7 @@ import { IntersectCreate } from './intersect-create.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TOptional as IsOptionalType, TTransform as IsTransformType, } from '../guard/type.mjs';
+import { IsOptional as IsOptionalType, IsTransform as IsTransformType, } from '../guard/type.mjs';
 // prettier-ignore
 function IsIntersectOptional(T) {
     const [L, ...R] = T;

package/build/import/type/intersect/intersect.mjs

@@ -5,14 +5,14 @@ import { IntersectCreate } from './intersect-create.mjs';
 // TypeGuard
 // ------------------------------------------------------------------
 // prettier-ignore
-import { TTransform as IsTransformType, } from '../guard/type.mjs';
+import { IsTransform, } from '../guard/type.mjs';
 /** `[Json]` Creates an evaluated Intersect type */
 export function Intersect(T, options = {}) {
     if (T.length === 0)
         return Never(options);
     if (T.length === 1)
         return CloneType(T[0], options);
-    if (T.some((schema) => IsTransformType(schema)))
+    if (T.some((schema) => IsTransform(schema)))
         throw new Error('Cannot intersect transform types');
     return IntersectCreate(T, options);
 }