@sinclair/typebox 0.28.2 → 0.28.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sinclair/typebox",
-  "version": "0.28.2",
+  "version": "0.28.3",
   "description": "JSONSchema Type Builder with Static Type Resolution for TypeScript",
   "keywords": [
     "typescript",

package/readme.md

@@ -83,6 +83,7 @@ License MIT
   - [Conditional](#types-conditional)
   - [Template](#types-template-literal)
   - [Indexed](#types-indexed)
+  - [Variadic](#types-variadic)
   - [Guards](#types-guards)
   - [Unsafe](#types-unsafe)
   - [Strict](#types-strict)
@@ -256,7 +257,8 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │ })                             │ }                           │   properties: {                │
 │                                │                             │     x: {                       │
 │                                │                             │       type: 'number'           │
-│                                │                             │     }, {                       │
+│                                │                             │     },                         │
+│                                │                             │     y: {                       │
 │                                │                             │       type: 'number'           │
 │                                │                             │     }                          │
 │                                │                             │   }                            │
@@ -277,14 +279,6 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │                                │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
-│ const T = Type.Index(          │ type T = {                  │ const T = {                    │
-│   Type.Object({                │   x: number,                │   type: number                 │
-│     x: Type.Number(),          │   y: string                 │ }                              │
-│     y: Type.String()           │ }['x']                      │                                │
-│   }), ['x']                    │                             │                                │
-│ )                              │                             │                                │
-│                                │                             │                                │
-├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ enum Foo {                     │ enum Foo {                  │ const T = {                    │
 │   A,                           │   A,                        │   anyOf: [{                    │
 │   B                            │   B                         │     type: 'number',            │
@@ -468,6 +462,28 @@ The following table lists the Standard TypeBox types. These types are fully comp
 │                                │                             │ }                              │
 │                                │                             │                                │
 ├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const T = Type.Index(          │ type T = {                  │ const T = {                    │
+│   Type.Object({                │   x: number,                │   type: 'number'               │
+│     x: Type.Number(),          │   y: string                 │ }                              │
+│     y: Type.String()           │ }['x']                      │                                │
+│   }), ['x']                    │                             │                                │
+│ )                              │                             │                                │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
+│ const A = Type.Tuple([         │ type A = [0, 1]             │ const T = {                    │
+│   Type.Literal(0),             │ type B = [2, 3]             │   type: 'array',               │
+│   Type.Literal(1)              │ type T = [...A, ...B]       │   items: [                     │
+│ ])                             │                             │     { const: 0 },              │
+│ const B = Type.Tuple([         │                             │     { const: 1 },              │
+|   Type.Literal(2),             │                             │     { const: 2 },              │
+|   Type.Literal(3)              │                             │     { const: 3 }               │
+│ ])                             │                             │   ],                           │
+│ const T = Type.Tuple([         │                             │   additionalItems: false,      │
+|   ...Type.Rest(A),             │                             │   minItems: 4,                 │
+|   ...Type.Test(B)              │                             │   maxItems: 4                  │
+│ ])                             │                             │ }                              │
+│                                │                             │                                │
+├────────────────────────────────┼─────────────────────────────┼────────────────────────────────┤
 │ const T = Type.Object({        │ type T = {                  │ const R = {                    │
 │    x: Type.Number(),           │   x: number,                │   $ref: 'T'                    │
 │    y: Type.Number()            │   y: number                 │ }                              │
@@ -856,10 +872,34 @@ const A = Type.Index(T, ['x'])                       // type A = T['x']
 
 const B = Type.Index(T, Type.KeyOf(T))               // type B = T[keyof T]
 ```
+<a name='types-variadic'></a>
+
+### Variadic Types
+
+Variadic types are supported with `Type.Rest`. This type will extract interior types from a tuple and return them as a flat array. This array can then be passed to other types that accept arrays as arguments.
+
+The following creates variadic functions using the Rest type.
+
+```typescript
+// TypeScript
 
+type P = [number, number]
+
+type F1 = (param: [...P]) => void
+
+type F2 = (param: [...P, number]) => void
+
+// TypeBox
+
+const P = Type.Tuple([Type.Number(), Type.Number()])
+
+const F1 = Type.Function(Type.Rest(P), Type.Void())
+
+const F2 = Type.Function([...Type.Rest(P), Type.Number()], Type.Void())
+```
 <a name='types-unsafe'></a>
 
-### Unsafe
+### Unsafe Types
 
 Use `Type.Unsafe` to create custom schematics with user defined inference rules.
 
@@ -904,7 +944,7 @@ type T = Static<typeof T>                            // type T = 'A' | 'B' | 'C'
 
 <a name='types-guards'></a>
 
-### Guards
+### Type Gaurds
 
 TypeBox provides a `TypeGuard` module that can be used for reflection and asserting values as types.
 
@@ -1436,11 +1476,11 @@ The following table lists esbuild compiled and minified sizes for each TypeBox m
 ┌──────────────────────┬────────────┬────────────┬─────────────┐
 │       (index)        │  Compiled  │  Minified  │ Compression │
 ├──────────────────────┼────────────┼────────────┼─────────────┤
-│ typebox/compiler     │ '127.2 kb' │ ' 56.9 kb' │  '2.23 x'   │
-│ typebox/errors       │ '110.9 kb' │ ' 49.2 kb' │  '2.25 x'   │
-│ typebox/system       │ ' 76.4 kb' │ ' 31.5 kb' │  '2.42 x'   │
-│ typebox/value        │ '176.9 kb' │ ' 76.8 kb' │  '2.30 x'   │
-│ typebox              │ ' 75.3 kb' │ ' 31.1 kb' │  '2.42 x'   │
+│ typebox/compiler     │ '126.7 kb' │ ' 56.6 kb' │  '2.24 x'   │
+│ typebox/errors       │ '110.4 kb' │ ' 48.8 kb' │  '2.26 x'   │
+│ typebox/system       │ ' 75.9 kb' │ ' 31.1 kb' │  '2.44 x'   │
+│ typebox/value        │ '176.4 kb' │ ' 76.4 kb' │  '2.31 x'   │
+│ typebox              │ ' 74.8 kb' │ ' 30.7 kb' │  '2.44 x'   │
 └──────────────────────┴────────────┴────────────┴─────────────┘
 ```
 

package/typebox.d.ts

@@ -20,15 +20,10 @@ export type Evaluate<T> = T extends infer O ? {
 } : never;
 export type Ensure<T> = T extends infer U ? U : never;
 export type AssertProperties<T> = T extends TProperties ? T : TProperties;
-export type AssertSchemas<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
-export type AssertSchema<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
-export type AssertObjects<T> = Assert<T, TObject[]>;
-export type AssertObject<T> = Assert<T, TObject>;
-export type AssertKeys<T> = Assert<T, Key[]>;
-export type AssertKey<T> = Assert<T, Key>;
-export type Key = keyof any;
-export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TIntersect<T>;
-export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertSchema<T[0]> : TUnion<T>;
+export type AssertRest<T, E extends TSchema[] = TSchema[]> = T extends E ? T : [];
+export type AssertType<T, E extends TSchema = TSchema> = T extends E ? T : TNever;
+export type IntersectType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : TIntersect<T>;
+export type UnionType<T extends TSchema[]> = T extends [] ? TNever : T extends [TSchema] ? AssertType<T[0]> : TUnion<T>;
 export type TModifier = TReadonlyOptional<TSchema> | TOptional<TSchema> | TReadonly<TSchema>;
 export type TReadonly<T extends TSchema> = T & {
     [Modifier]: 'Readonly';
@@ -39,6 +34,7 @@ export type TOptional<T extends TSchema> = T & {
 export type TReadonlyOptional<T extends TSchema> = T & {
     [Modifier]: 'ReadonlyOptional';
 };
+export type Key = keyof any;
 export interface SchemaOptions {
     $schema?: string;
     /** Id for this schema */
@@ -99,21 +95,21 @@ export interface TBoolean extends TSchema {
 export type TConstructorParameters<T extends TConstructor<TSchema[], TSchema>> = TTuple<T['parameters']>;
 export type TInstanceType<T extends TConstructor<TSchema[], TSchema>> = T['returns'];
 export type TCompositeIsOptional<T extends TSchema> = T extends TOptional<T> | TReadonlyOptional<T> ? true : false;
-export type TCompositeOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? TCompositeIsOptional<AssertSchema<L>> extends false ? false : TCompositeOptional<AssertSchemas<R>> : true;
+export type TCompositeOptional<T extends TSchema[]> = T extends [infer L, ...infer R] ? TCompositeIsOptional<AssertType<L>> extends false ? false : TCompositeOptional<AssertRest<R>> : true;
 export type TCompositeKeyOfUnion1<T extends TObject> = keyof T['properties'];
 export type TCompositeKeyOfUnion2<T extends TObject[]> = T extends [infer L, ...infer R] ? TCompositeKeyOfUnion1<Assert<L, TObject>> | TCompositeKeyOfUnion2<Assert<R, TObject[]>> : never;
 export type TCompositeKeyOf<T extends TObject[]> = UnionToTuple<TCompositeKeyOfUnion2<T>>;
 export type TCompositePropertiesWithKey1<T extends TObject, K extends Key> = K extends keyof T['properties'] ? [T['properties'][K]] : [];
-export type TCompositePropertiesWithKey2<T extends TObject[], K extends Key> = T extends [infer L, ...infer R] ? [...TCompositePropertiesWithKey1<AssertObject<L>, K>, ...TCompositePropertiesWithKey2<AssertObjects<R>, K>] : [];
-export type TCompositeObjectProperty<T extends TObject[], K extends Key> = TCompositePropertiesWithKey2<T, K> extends infer S ? TCompositeOptional<AssertSchemas<S>> extends true ? {
-    [_ in K]: TOptional<IntersectType<AssertSchemas<S>>>;
+export type TCompositePropertiesWithKey2<T extends TObject[], K extends Key> = T extends [infer L, ...infer R] ? [...TCompositePropertiesWithKey1<Assert<L, TObject>, K>, ...TCompositePropertiesWithKey2<Assert<R, TObject[]>, K>] : [];
+export type TCompositeObjectProperty<T extends TObject[], K extends Key> = TCompositePropertiesWithKey2<T, K> extends infer S ? TCompositeOptional<AssertRest<S>> extends true ? {
+    [_ in K]: TOptional<IntersectType<AssertRest<S>>>;
 } : {
-    [_ in K]: IntersectType<AssertSchemas<S>>;
+    [_ in K]: IntersectType<AssertRest<S>>;
 } : {};
-export type TCompositeObjectsWithKeys<T extends TObject[], K extends Key[]> = K extends [infer L, ...infer R] ? L extends Key ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, AssertKeys<R>> : {} : {};
-export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, AssertKeys<TCompositeKeyOf<T>>>>>>;
+export type TCompositeObjectsWithKeys<T extends TObject[], K extends Key[]> = K extends [infer L, ...infer R] ? L extends Key ? TCompositeObjectProperty<T, L> & TCompositeObjectsWithKeys<T, Assert<R, Key[]>> : {} : {};
+export type TComposite<T extends TObject[]> = Ensure<TObject<Evaluate<TCompositeObjectsWithKeys<T, Assert<TCompositeKeyOf<T>, Key[]>>>>>;
 export type TConstructorParameterArray<T extends readonly TSchema[], P extends unknown[]> = [...{
-    [K in keyof T]: Static<AssertSchema<T[K]>, P>;
+    [K in keyof T]: Static<AssertType<T[K]>, P>;
 }];
 export interface TConstructor<T extends TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Constructor';
@@ -144,25 +140,25 @@ export interface TEnum<T extends Record<string, string | number> = Record<string
     static: T[keyof T];
     anyOf: TLiteral<string | number>[];
 }
-export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertSchema<X>, AssertSchema<Y>]> : AssertSchema<O> : never;
-export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{
+export type TExtends<L extends TSchema, R extends TSchema, T extends TSchema, U extends TSchema> = (Static<L> extends Static<R> ? T : U) extends infer O ? UnionToTuple<O> extends [infer X, infer Y] ? TUnion<[AssertType<X>, AssertType<Y>]> : AssertType<O> : never;
+export type TExcludeTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
 export type TExcludeTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Exclude<Static<T>, Static<U>> extends infer S ? TExcludeTemplateLiteralResult<Assert<S, string>> : never;
-export type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<{
-    [K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? never : T[K];
-}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never;
+export type TExcludeArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? never : T[K];
+}[number]>> extends infer R ? UnionType<AssertRest<R>> : never;
 export type TExclude<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExcludeTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExcludeArray<S, U> : T extends U ? TNever : T;
-export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertSchemas<UnionToTuple<{
+export type TExtractTemplateLiteralResult<T extends string> = UnionType<AssertRest<UnionToTuple<{
     [K in T]: TLiteral<K>;
 }[T]>>>;
 export type TExtractTemplateLiteral<T extends TTemplateLiteral, U extends TSchema> = Extract<Static<T>, Static<U>> extends infer S ? TExtractTemplateLiteralResult<Assert<S, string>> : never;
-export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertSchemas<UnionToTuple<{
-    [K in keyof T]: Static<AssertSchema<T[K]>> extends Static<U> ? T[K] : never;
-}[number]>> extends infer R ? UnionType<AssertSchemas<R>> : never;
+export type TExtractArray<T extends TSchema[], U extends TSchema> = AssertRest<UnionToTuple<{
+    [K in keyof T]: Static<AssertType<T[K]>> extends Static<U> ? T[K] : never;
+}[number]>> extends infer R ? UnionType<AssertRest<R>> : never;
 export type TExtract<T extends TSchema, U extends TSchema> = T extends TTemplateLiteral ? TExtractTemplateLiteral<T, U> : T extends TUnion<infer S> ? TExtractArray<S, U> : T extends U ? T : T;
 export type TFunctionParameters<T extends readonly TSchema[], P extends unknown[]> = [...{
-    [K in keyof T]: Static<AssertSchema<T[K]>, P>;
+    [K in keyof T]: Static<AssertType<T[K]>, P>;
 }];
 export interface TFunction<T extends readonly TSchema[] = TSchema[], U extends TSchema = TSchema> extends TSchema {
     [Kind]: 'Function';
@@ -177,13 +173,13 @@ export type TIndexProperty<T extends TProperties, K extends IndexKey> = K extend
 ];
 export type TIndexTuple<T extends TSchema[], K extends IndexKey> = K extends keyof T ? [T[K]] : [
 ];
-export type TIndexComposite<T extends TSchema[], K extends IndexKey> = T extends [infer L, ...infer R] ? [...TIndexKey<AssertSchema<L>, K>, ...TIndexComposite<AssertSchemas<R>, K>] : [
+export type TIndexComposite<T extends TSchema[], K extends IndexKey> = T extends [infer L, ...infer R] ? [...TIndexKey<AssertType<L>, K>, ...TIndexComposite<AssertRest<R>, K>] : [
 ];
 export type TIndexKey<T extends TSchema, K extends IndexKey> = T extends TRecursive<infer S> ? TIndexKey<S, K> : T extends TIntersect<infer S> ? TIndexComposite<S, K> : T extends TUnion<infer S> ? TIndexComposite<S, K> : T extends TObject<infer S> ? TIndexProperty<S, K> : T extends TTuple<infer S> ? TIndexTuple<S, K> : T extends TArray<infer S> ? S : [
 ];
 export type TIndexKeys<T extends TSchema, K extends IndexKey[]> = K extends [infer L, ...infer R] ? [...TIndexKey<T, Assert<L, IndexKey>>, ...TIndexKeys<T, Assert<R, IndexKey[]>>] : [
 ];
-export type TIndex<T extends TSchema, K extends IndexKey[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndex<S, K> : T extends TTuple ? UnionType<AssertSchemas<R>> : T extends TIntersect ? UnionType<AssertSchemas<R>> : T extends TUnion ? UnionType<AssertSchemas<R>> : T extends TObject ? UnionType<AssertSchemas<R>> : T extends TArray ? UnionType<AssertSchemas<R>> : TNever : TNever;
+export type TIndex<T extends TSchema, K extends IndexKey[]> = TIndexKeys<T, K> extends infer R ? T extends TRecursive<infer S> ? TIndex<S, K> : T extends TTuple ? UnionType<AssertRest<R>> : T extends TIntersect ? UnionType<AssertRest<R>> : T extends TUnion ? UnionType<AssertRest<R>> : T extends TObject ? UnionType<AssertRest<R>> : T extends TArray ? UnionType<AssertRest<R>> : TNever : TNever;
 export interface TInteger extends TSchema, NumericOptions<number> {
     [Kind]: 'Integer';
     static: number;
@@ -196,7 +192,7 @@ export interface IntersectOptions extends SchemaOptions {
 export interface TIntersect<T extends TSchema[] = TSchema[]> extends TSchema, IntersectOptions {
     [Kind]: 'Intersect';
     static: TupleToIntersect<{
-        [K in keyof T]: Static<AssertSchema<T[K]>, this['params']>;
+        [K in keyof T]: Static<AssertType<T[K]>, this['params']>;
     }>;
     type?: 'object';
     allOf: [...T];
@@ -205,11 +201,11 @@ export type TKeyOfProperties<T extends TSchema> = Static<T> extends infer S ? Un
     [K in keyof S]: TLiteral<`${Assert<K, TLiteralValue>}`>;
 }[keyof S]> : [];
 export type TKeyOfIndicesArray<T extends TSchema[]> = UnionToTuple<keyof T & `${number}`>;
-export type TKeyOfIndices<T extends TSchema[]> = AssertSchemas<TKeyOfIndicesArray<T> extends infer R ? {
+export type TKeyOfIndices<T extends TSchema[]> = AssertRest<TKeyOfIndicesArray<T> extends infer R ? {
     [K in keyof R]: TLiteral<Assert<R[K], TLiteralValue>>;
 } : []>;
 export type TKeyOf<T extends TSchema = TSchema> = (T extends TRecursive<infer S> ? TKeyOfProperties<S> : T extends TIntersect ? TKeyOfProperties<T> : T extends TUnion ? TKeyOfProperties<T> : T extends TObject ? TKeyOfProperties<T> : T extends TTuple<infer K> ? TKeyOfIndices<K> : T extends TArray ? [TNumber] : T extends TRecord<infer K> ? [K] : [
-]) extends infer R ? UnionType<AssertSchemas<R>> : never;
+]) extends infer R ? UnionType<AssertRest<R>> : never;
 export type TLiteralValue = string | number | boolean;
 export interface TLiteral<T extends TLiteralValue = TLiteralValue> extends TSchema {
     [Kind]: 'Literal';
@@ -269,27 +265,27 @@ export interface TObject<T extends TProperties = TProperties> extends TSchema, O
     properties: T;
     required?: string[];
 }
-export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertSchemas<{
-    [K2 in keyof T]: TOmit<AssertSchema<T[K2]>, K>;
+export type TOmitArray<T extends TSchema[], K extends keyof any> = AssertRest<{
+    [K2 in keyof T]: TOmit<AssertType<T[K2]>, K>;
 }>;
 export type TOmitProperties<T extends TProperties, K extends keyof any> = Evaluate<AssertProperties<Omit<T, K>>>;
 export type TOmit<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TOmit<S, K>> : T extends TIntersect<infer S> ? TIntersect<TOmitArray<S, K>> : T extends TUnion<infer S> ? TUnion<TOmitArray<S, K>> : T extends TObject<infer S> ? TObject<TOmitProperties<S, K>> : T;
 export type TParameters<T extends TFunction> = Ensure<TTuple<T['parameters']>>;
-export type TPartialObjectArray<T extends TObject[]> = AssertSchemas<{
-    [K in keyof T]: TPartial<AssertSchema<T[K], TObject>>;
+export type TPartialObjectArray<T extends TObject[]> = AssertRest<{
+    [K in keyof T]: TPartial<AssertType<T[K], TObject>>;
 }, TObject[]>;
-export type TPartialArray<T extends TSchema[]> = AssertSchemas<{
-    [K in keyof T]: TPartial<AssertSchema<T[K]>>;
+export type TPartialArray<T extends TSchema[]> = AssertRest<{
+    [K in keyof T]: TPartial<AssertType<T[K]>>;
 }>;
 export type TPartialProperties<T extends TProperties> = Evaluate<AssertProperties<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonlyOptional<U> : T[K] extends TReadonly<infer U> ? TReadonlyOptional<U> : T[K] extends TOptional<infer U> ? TOptional<U> : TOptional<T[K]>;
 }>>;
 export type TPartial<T extends TSchema> = T extends TRecursive<infer S> ? TRecursive<TPartial<S>> : T extends TIntersect<infer S> ? TIntersect<TPartialArray<S>> : T extends TUnion<infer S> ? TUnion<TPartialArray<S>> : T extends TObject<infer S> ? TObject<TPartialProperties<S>> : T;
 export type TPickArray<T extends TSchema[], K extends keyof any> = {
-    [K2 in keyof T]: TPick<AssertSchema<T[K2]>, K>;
+    [K2 in keyof T]: TPick<AssertType<T[K2]>, K>;
 };
 export type TPickProperties<T extends TProperties, K extends keyof any> = Pick<T, Assert<Extract<K, keyof T>, keyof T>> extends infer R ? ({
-    [K in keyof R]: AssertSchema<R[K]> extends TSchema ? R[K] : never;
+    [K in keyof R]: AssertType<R[K]> extends TSchema ? R[K] : never;
 }) : never;
 export type TPick<T extends TSchema = TSchema, K extends keyof any = keyof any> = T extends TRecursive<infer S> ? TRecursive<TPick<S, K>> : T extends TIntersect<infer S> ? TIntersect<TPickArray<S, K>> : T extends TUnion<infer S> ? TUnion<TPickArray<S, K>> : T extends TObject<infer S> ? TObject<TPickProperties<S, K>> : T;
 export interface TPromise<T extends TSchema = TSchema> extends TSchema {
@@ -336,9 +332,10 @@ export interface TRef<T extends TSchema = TSchema> extends TSchema {
     static: Static<T, this['params']>;
     $ref: string;
 }
+export type TRest<T extends TSchema> = T extends TTuple<infer R> ? Assert<R, TSchema[]> : Assert<[T], TSchema[]>;
 export type TReturnType<T extends TFunction> = T['returns'];
-export type TRequiredArray<T extends TSchema[]> = AssertSchemas<{
-    [K in keyof T]: TRequired<AssertSchema<T[K]>>;
+export type TRequiredArray<T extends TSchema[]> = AssertRest<{
+    [K in keyof T]: TRequired<AssertType<T[K]>>;
 }>;
 export type TRequiredProperties<T extends TProperties> = Evaluate<AssertProperties<{
     [K in keyof T]: T[K] extends TReadonlyOptional<infer U> ? TReadonly<U> : T[K] extends TReadonly<infer U> ? TReadonly<U> : T[K] extends TOptional<infer U> ? U : T[K];
@@ -373,14 +370,14 @@ export type TTemplateLiteralConst<T, Acc extends string> = T extends TUnion<infe
     [K in keyof U]: TTemplateLiteralUnion<Assert<[U[K]], TTemplateLiteralKind[]>, Acc>;
 }[number] : T extends TTemplateLiteral ? `${Static<T>}` : T extends TLiteral<infer U> ? `${U}` : T extends TString ? `${string}` : T extends TNumber ? `${number}` : T extends TBigInt ? `${bigint}` : T extends TBoolean ? `${boolean}` : never;
 export type TTemplateLiteralUnion<T extends TTemplateLiteralKind[], Acc extends string = ''> = T extends [infer L, ...infer R] ? `${TTemplateLiteralConst<L, Acc>}${TTemplateLiteralUnion<Assert<R, TTemplateLiteralKind[]>, Acc>}` : Acc;
-export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = AssertKeys<UnionToTuple<Static<T>>>;
+export type TTemplateLiteralKeyArray<T extends TTemplateLiteral> = Assert<UnionToTuple<Static<T>>, Key[]>;
 export interface TTemplateLiteral<T extends TTemplateLiteralKind[] = TTemplateLiteralKind[]> extends TSchema {
     [Kind]: 'TemplateLiteral';
     static: TTemplateLiteralUnion<T>;
     type: 'string';
     pattern: string;
 }
-export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertSchemas<R> : never;
+export type TTupleIntoArray<T extends TTuple<TSchema[]>> = T extends TTuple<infer R> ? AssertRest<R> : never;
 export interface TTuple<T extends TSchema[] = TSchema[]> extends TSchema {
     [Kind]: 'Tuple';
     static: {
@@ -662,7 +659,9 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     /** `[Standard]` Returns indexed property types for the given keys */
     Index<T extends TSchema, K extends TTemplateLiteral>(schema: T, key: K, options?: SchemaOptions): TIndex<T, TTemplateLiteralKeyArray<K>>;
     /** `[Standard]` Returns indexed property types for the given keys */
-    Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): T['items'];
+    Index<T extends TTuple, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): UnionType<Assert<T['items'], TSchema[]>>;
+    /** `[Standard]` Returns indexed property types for the given keys */
+    Index<T extends TArray, K extends TNumber>(schema: T, key: K, options?: SchemaOptions): AssertType<T['items']>;
     /** `[Standard]` Returns indexed property types for the given keys */
     Index<T extends TSchema, K extends TNever>(schema: T, key: K, options?: SchemaOptions): TIndex<T, never>;
     /** `[Standard]` Creates an Integer type */
@@ -724,6 +723,8 @@ export declare class StandardTypeBuilder extends TypeBuilder {
     Ref<T extends TSchema>(schema: T, options?: SchemaOptions): TRef<T>;
     /** `[Standard]` Creates a mapped type where all properties are Required */
     Required<T extends TSchema>(schema: T, options?: SchemaOptions): TRequired<T>;
+    /** `[Standard]` Returns a schema array which allows types to compose with the JavaScript spread operator */
+    Rest<T extends TSchema>(schema: T): TRest<T>;
     /** `[Standard]` Creates a String type */
     String(options?: StringOptions): TString;
     /** `[Standard]` Creates a template literal type */
@@ -749,14 +750,10 @@ export declare class ExtendedTypeBuilder extends StandardTypeBuilder {
     /** `[Extended]` Extracts the ConstructorParameters from the given Constructor type */
     ConstructorParameters<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TConstructorParameters<T>;
     /** `[Extended]` Creates a Constructor type */
-    Constructor<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TConstructor<TTupleIntoArray<T>, U>;
-    /** `[Extended]` Creates a Constructor type */
     Constructor<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TConstructor<T, U>;
     /** `[Extended]` Creates a Date type */
     Date(options?: DateOptions): TDate;
     /** `[Extended]` Creates a Function type */
-    Function<T extends TTuple<TSchema[]>, U extends TSchema>(parameters: T, returns: U, options?: SchemaOptions): TFunction<TTupleIntoArray<T>, U>;
-    /** `[Extended]` Creates a Function type */
     Function<T extends TSchema[], U extends TSchema>(parameters: [...T], returns: U, options?: SchemaOptions): TFunction<T, U>;
     /** `[Extended]` Extracts the InstanceType from the given Constructor */
     InstanceType<T extends TConstructor<any[], any>>(schema: T, options?: SchemaOptions): TInstanceType<T>;

package/typebox.js

@@ -1960,6 +1960,11 @@ class StandardTypeBuilder extends TypeBuilder {
         if (TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved)) {
             return TypeClone.Clone(schema.items, options);
         }
+        if (TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved)) {
+            const items = schema.items === undefined ? [] : schema.items;
+            const cloned = items.map((schema) => TypeClone.Clone(schema, {}));
+            return this.Union(cloned, options);
+        }
         const resolved = IndexedAccessor.Resolve(schema, keys);
         const cloned = resolved.map((schema) => TypeClone.Clone(schema, {}));
         return this.Union(cloned, options);
@@ -2177,6 +2182,17 @@ class StandardTypeBuilder extends TypeBuilder {
             return schema;
         }, options);
     }
+    /** `[Standard]` Returns a schema array which allows types to compose with the JavaScript spread operator */
+    Rest(schema) {
+        if (TypeGuard.TTuple(schema)) {
+            if (schema.items === undefined)
+                return [];
+            return schema.items.map((schema) => TypeClone.Clone(schema, {}));
+        }
+        else {
+            return [TypeClone.Clone(schema, {})];
+        }
+    }
     /** `[Standard]` Creates a String type */
     String(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'String', type: 'string' });
@@ -2232,37 +2248,21 @@ class ExtendedTypeBuilder extends StandardTypeBuilder {
     ConstructorParameters(schema, options = {}) {
         return this.Tuple([...schema.parameters], { ...options });
     }
-    Constructor(parameters, returns, options = {}) {
+    /** `[Extended]` Creates a Constructor type */
+    Constructor(parameters, returns, options) {
         const clonedReturns = TypeClone.Clone(returns, {});
-        if (TypeGuard.TTuple(parameters)) {
-            const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
-        }
-        else if (globalThis.Array.isArray(parameters)) {
-            const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
-            return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
-        }
-        else {
-            throw new Error('ExtendedTypeBuilder.Constructor: Invalid parameters');
-        }
+        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+        return this.Create({ ...options, [exports.Kind]: 'Constructor', type: 'object', instanceOf: 'Constructor', parameters: clonedParameters, returns: clonedReturns });
     }
     /** `[Extended]` Creates a Date type */
     Date(options = {}) {
         return this.Create({ ...options, [exports.Kind]: 'Date', type: 'object', instanceOf: 'Date' });
     }
-    Function(parameters, returns, options = {}) {
+    /** `[Extended]` Creates a Function type */
+    Function(parameters, returns, options) {
         const clonedReturns = TypeClone.Clone(returns, {});
-        if (TypeGuard.TTuple(parameters)) {
-            const clonedParameters = parameters.items === undefined ? [] : parameters.items.map((parameter) => TypeClone.Clone(parameter, {}));
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
-        }
-        else if (globalThis.Array.isArray(parameters)) {
-            const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
-            return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
-        }
-        else {
-            throw new Error('ExtendedTypeBuilder.Function: Invalid parameters');
-        }
+        const clonedParameters = parameters.map((parameter) => TypeClone.Clone(parameter, {}));
+        return this.Create({ ...options, [exports.Kind]: 'Function', type: 'object', instanceOf: 'Function', parameters: clonedParameters, returns: clonedReturns });
     }
     /** `[Extended]` Extracts the InstanceType from the given Constructor */
     InstanceType(schema, options = {}) {