Action Types

sinclairzx81 · sinclairzx81 · commit dddbc0473a5c · 2026-04-18T23:04:48.000+09:00
diff --git a/src/type/action/awaited.ts b/src/type/action/awaited.ts
@@ -47,6 +47,10 @@ export function AwaitedDeferred<Type extends TSchema>(type: Type, options: TSche
 // Type
 // ------------------------------------------------------------------
 /** Applies an Awaited action to a type. */
-export function Awaited<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TAwaitedAction<Type> {
+export type TAwaited<Type extends TSchema> = (
+  TAwaitedAction<Type>
+)
+/** Applies an Awaited action to a type. */
+export function Awaited<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TAwaited<Type> {
   return AwaitedAction(type, options)
 }
diff --git a/src/type/action/capitalize.ts b/src/type/action/capitalize.ts
@@ -47,6 +47,10 @@ export function CapitalizeDeferred<Type extends TSchema>(type: Type, options: TS
 // Type
 // ------------------------------------------------------------------
 /** Applies a Capitalize action to the given type. */
-export function Capitalize<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TCapitalizeAction<Type> {
+export type TCapitalize<Type extends TSchema> = (
+  TCapitalizeAction<Type>
+)
+/** Applies a Capitalize action to the given type. */
+export function Capitalize<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TCapitalize<Type> {
   return CapitalizeAction(type, options) as never
 }
diff --git a/src/type/action/conditional.ts b/src/type/action/conditional.ts
@@ -50,8 +50,12 @@ export function ConditionalDeferred<Left extends TSchema, Right extends TSchema,
 // Type
 // ------------------------------------------------------------------
 /** Applies a Conditional action to the given types. */
+export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (
+  TConditionalAction<{}, { callstack: [] }, Left, Right, True, False>
+)
+/** Applies a Conditional action to the given types. */
 export function Conditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>
-  (left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions = {}): 
-    TConditionalAction<{}, { callstack: [] }, Left, Right, True, False> {
+  (left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions = {}):
+  TConditional<Left, Right, True, False> {
   return ConditionalAction({}, { callstack: [] }, left, right, true_, false_, options) as never
 }
diff --git a/src/type/action/constructor-parameters.ts b/src/type/action/constructor-parameters.ts
@@ -47,6 +47,10 @@ export function ConstructorParametersDeferred<Type extends TSchema>(type: Type,
 // Type
 // ------------------------------------------------------------------
 /** Applies a ConstructorParameters action to a type. */
-export function ConstructorParameters<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TConstructorParametersAction<Type> {
+export type TConstructorParameters<Type extends TSchema> = (
+  TConstructorParametersAction<Type>
+)
+/** Applies a ConstructorParameters action to a type. */
+export function ConstructorParameters<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TConstructorParameters<Type> {
   return ConstructorParametersAction(type, options) as never
 }
diff --git a/src/type/action/evaluate.ts b/src/type/action/evaluate.ts
@@ -47,6 +47,10 @@ export function EvaluateDeferred<Type extends TSchema>(type: Type, options: TSch
 // Type
 // ------------------------------------------------------------------
 /** Applies an Evaluate action to a type. */
-export function Evaluate<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TEvaluateAction<Type> {
+export type TEvaluate<Type extends TSchema> = (
+  TEvaluateAction<Type>
+)
+/** Applies an Evaluate action to a type. */
+export function Evaluate<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TEvaluate<Type> {
   return EvaluateAction(type, options) as never
 }
diff --git a/src/type/action/exclude.ts b/src/type/action/exclude.ts
@@ -47,6 +47,10 @@ export function ExcludeDeferred<Left extends TSchema, Right extends TSchema>(lef
 // Type
 // ------------------------------------------------------------------
 /** Applies a Exclude action using the given types */
-export function Exclude<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions = {}): TExcludeAction<Left, Right> {
+export type TExclude<Left extends TSchema, Right extends TSchema> = (
+  TExcludeAction<Left, Right>
+)
+/** Applies a Exclude action using the given types */
+export function Exclude<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions = {}): TExclude<Left, Right> {
   return ExcludeAction(left, right, options) as never
 }
diff --git a/src/type/action/extract.ts b/src/type/action/extract.ts
@@ -47,6 +47,10 @@ export function ExtractDeferred<Left extends TSchema, Right extends TSchema>(lef
 // Type
 // ------------------------------------------------------------------
 /** Applies an Extract action using the given types. */
-export function Extract<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions = {}): TExtractAction<Left, Right> {
+export type TExtract<Left extends TSchema, Right extends TSchema> = (
+  TExtractAction<Left, Right>
+)
+/** Applies an Extract action using the given types. */
+export function Extract<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options: TSchemaOptions = {}): TExtract<Left, Right> {
   return ExtractAction(left, right, options) as never
 }
diff --git a/src/type/action/indexed.ts b/src/type/action/indexed.ts
@@ -49,9 +49,13 @@ export function IndexDeferred<Type extends TSchema, Indexer extends TSchema>(typ
 // Index
 // ------------------------------------------------------------------
 /** Applies a Index action using the given types. */
-export function Index<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TIndexAction<Type, TKeysToIndexer<Indexer>>
+export type TIndex<Type extends TSchema, Indexer extends TSchema> = (
+  TIndexAction<Type, Indexer>
+)
+/** Applies a Index action using the given types. */
+export function Index<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TIndex<Type, TKeysToIndexer<Indexer>>
 /** Applies a Index action using the given types. */
-export function Index<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndexAction<Type, Indexer> 
+export function Index<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndex<Type, Indexer>
 /** Applies a Index action using the given types. */
 export function Index(type: TSchema, indexer_or_keys: PropertyKey[] | TSchema, options: TSchemaOptions = {}): never {
   const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys as PropertyKey[]) : indexer_or_keys
diff --git a/src/type/action/instance-type.ts b/src/type/action/instance-type.ts
@@ -47,6 +47,10 @@ export function InstanceTypeDeferred<Type extends TSchema>(type: Type, options:
 // Type
 // ------------------------------------------------------------------
 /** Applies a InstanceType action to the given type. */
-export function InstanceType<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TInstanceTypeAction<Type> {
+export type TInstanceType<Type extends TSchema> = (
+  TInstanceTypeAction<Type>
+)
+/** Applies a InstanceType action to the given type. */
+export function InstanceType<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TInstanceType<Type> {
   return InstanceTypeAction(type, options) as never
 }
diff --git a/src/type/action/interface.ts b/src/type/action/interface.ts
@@ -60,8 +60,12 @@ export function IsInterfaceDeferred(value: unknown): value is TInterfaceDeferred
 // Factory
 // ------------------------------------------------------------------
 /** Creates an Interface using the given heritage and properties. */
+export type TInterface<Heritage extends TSchema[], Properties extends TProperties> = (
+  TInterfaceAction<Heritage, Properties>
+)
+/** Creates an Interface using the given heritage and properties. */
 export function Interface<Heritage extends TSchema[], Properties extends TProperties>
   (heritage: [...Heritage], properties: Properties, options: TSchemaOptions = {}):
-    TInterfaceAction<Heritage, Properties> {
+  TInterface<Heritage, Properties> {
   return InterfaceAction(heritage, properties, options) as never
 }
diff --git a/src/type/action/keyof.ts b/src/type/action/keyof.ts
@@ -47,6 +47,10 @@ export function KeyOfDeferred<Type extends TSchema>(type: Type, options: TSchema
 // Type
 // ------------------------------------------------------------------
 /** Applies a KeyOf action to the given type. */
-export function KeyOf<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TKeyOfAction<Type> {
+export type TKeyOf<Type extends TSchema> = (
+  TKeyOfAction<Type>
+)
+/** Applies a KeyOf action to the given type. */
+export function KeyOf<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TKeyOf<Type> {
   return KeyOfAction(type, options)
 }
diff --git a/src/type/action/lowercase.ts b/src/type/action/lowercase.ts
@@ -47,6 +47,10 @@ export function LowercaseDeferred<Type extends TSchema>(type: Type, options: TSc
 // Type
 // ------------------------------------------------------------------
 /** Applies a Lowercase action to the given type. */
-export function Lowercase<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TLowercaseAction<Type> {
+export type TLowercase<Type extends TSchema> = (
+  TLowercaseAction<Type>
+)
+/** Applies a Lowercase action to the given type. */
+export function Lowercase<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TLowercase<Type> {
   return LowercaseAction(type, options) as never
 }
diff --git a/src/type/action/mapped.ts b/src/type/action/mapped.ts
@@ -49,8 +49,12 @@ export function MappedDeferred<Identifier extends TIdentifier, Type extends TSch
 // Type
 // ------------------------------------------------------------------
 /** Applies a Mapped action using the given types. */
+export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (
+  TMappedAction<{}, { callstack: [] }, Identifier, Type, As, Property>
+)
+/** Applies a Mapped action using the given types. */
 export function Mapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>
-  (identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions = {}): 
-    TMappedAction<{}, { callstack: [] }, Identifier, Type, As, Property> {
+  (identifier: Identifier, type: Type, as: As, property: Property, options: TSchemaOptions = {}):
+  TMapped<Identifier, Type, As, Property> {
   return MappedAction({}, { callstack: [] }, identifier, type, as, property, options)
 }
diff --git a/src/type/action/non-nullable.ts b/src/type/action/non-nullable.ts
@@ -47,6 +47,10 @@ export function NonNullableDeferred<Type extends TSchema>(type: Type, options: T
 // Type
 // ------------------------------------------------------------------
 /** Applies a NonNullable action to the given type. */
-export function NonNullable<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TNonNullableAction<Type> {
+export type TNonNullable<Type extends TSchema> = (
+  TNonNullableAction<Type>
+)
+/** Applies a NonNullable action to the given type. */
+export function NonNullable<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TNonNullable<Type> {
   return NonNullableAction(type, options) as never
 }
diff --git a/src/type/action/omit.ts b/src/type/action/omit.ts
@@ -49,9 +49,13 @@ export function OmitDeferred<Type extends TSchema, Indexer extends TSchema>(type
 // Type
 // ------------------------------------------------------------------
 /** Applies a Omit action using the given types. */
-export function Omit<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TOmitAction<Type, TKeysToIndexer<Indexer>>
+export type TOmit<Type extends TSchema, Indexer extends TSchema> = (
+  TOmitAction<Type, Indexer>
+)
+/** Applies a Omit action using the given types. */
+export function Omit<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TOmit<Type, TKeysToIndexer<Indexer>>
 /** Applies a Omit action using the given types. */
-export function Omit<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmitAction<Type, Indexer> 
+export function Omit<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmit<Type, Indexer>
 /** Applies a Omit action using the given types. */
 export function Omit(type: TSchema, indexer_or_keys: PropertyKey[] | TSchema, options: TSchemaOptions = {}): never {
   const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys as PropertyKey[]) : indexer_or_keys
diff --git a/src/type/action/options.ts b/src/type/action/options.ts
@@ -48,7 +48,7 @@ export function OptionsDeferred<Type extends TSchema, Options extends TSchema>(t
 // ------------------------------------------------------------------
 /** Applies an immediate Options action to the given type. */
 export type TOptions<Type extends TSchema, Options extends TSchema> = (
-  Type & Options
+  Type & Options // note: kept here for presentation of TOptions<T, {...}>
 )
 /** Applies an immediate Options action to the given type. */
 export function Options<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TOptionsAction<Type, Options> {
diff --git a/src/type/action/parameters.ts b/src/type/action/parameters.ts
@@ -47,6 +47,10 @@ export function ParametersDeferred<Type extends TSchema>(type: Type, options: TS
 // Type
 // ------------------------------------------------------------------
 /** Applies a Parameters action to the given type. */
-export function Parameters<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TParametersAction<Type> {
+export type TParameters<Type extends TSchema> = (
+  TParametersAction<Type>
+)
+/** Applies a Parameters action to the given type. */
+export function Parameters<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TParameters<Type> {
   return ParametersAction(type, options)
 }
diff --git a/src/type/action/partial.ts b/src/type/action/partial.ts
@@ -47,6 +47,10 @@ export function PartialDeferred<Type extends TSchema>(type: Type, options: TSche
 // Type
 // ------------------------------------------------------------------
 /** Applies a Partial action to the given type. */
-export function Partial<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TPartialAction<Type> {
+export type TPartial<Type extends TSchema> = (
+  TPartialAction<Type>
+)
+/** Applies a Partial action to the given type. */
+export function Partial<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TPartial<Type> {
   return PartialAction(type, options)
 }
diff --git a/src/type/action/pick.ts b/src/type/action/pick.ts
@@ -49,9 +49,13 @@ export function PickDeferred<Type extends TSchema, Indexer extends TSchema>(type
 // Pick
 // ------------------------------------------------------------------
 /** Applies a Pick action using the given types. */
-export function Pick<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TPickAction<Type, TKeysToIndexer<Indexer>>
+export type TPick<Type extends TSchema, Indexer extends TSchema> = (
+  TPickAction<Type, Indexer>
+)
+/** Applies a Pick action using the given types. */
+export function Pick<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TPick<Type, TKeysToIndexer<Indexer>>
 /** Applies a Pick action using the given types. */
-export function Pick<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPickAction<Type, Indexer> 
+export function Pick<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPick<Type, Indexer> 
 /** Applies a Pick action using the given types. */
 export function Pick(type: TSchema, indexer_or_keys: PropertyKey[] | TSchema, options: TSchemaOptions = {}): never {
   const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys as PropertyKey[]) : indexer_or_keys
diff --git a/src/type/action/readonly-object.ts b/src/type/action/readonly-object.ts
@@ -47,7 +47,11 @@ export function ReadonlyObjectDeferred<Type extends TSchema>(type: Type, options
 // Type
 // ------------------------------------------------------------------
 /** This type is an alias for TypeScript's `Readonly<T>` utility type. It will make all properties of a TObject readonly or marks an TArray or TTuple as immutable `readonly T[]`. */
-export function ReadonlyObject<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TReadonlyObjectAction<Type> {
+export type TReadonlyObject<Type extends TSchema> = (
+  TReadonlyObjectAction<Type>
+)
+/** This type is an alias for TypeScript's `Readonly<T>` utility type. It will make all properties of a TObject readonly or marks an TArray or TTuple as immutable `readonly T[]`. */
+export function ReadonlyObject<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TReadonlyObject<Type> {
   return ReadonlyObjectAction(type, options) as never
 }
 /** 
diff --git a/src/type/action/required.ts b/src/type/action/required.ts
@@ -47,6 +47,10 @@ export function RequiredDeferred<Type extends TSchema>(type: Type, options: TSch
 // Type
 // ------------------------------------------------------------------
 /** Applies a Required action to the given type. */
-export function Required<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TRequiredAction<Type> {
+export type TRequired<Type extends TSchema> = (
+  TRequiredAction<Type>
+)
+/** Applies a Required action to the given type. */
+export function Required<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TRequired<Type> {
   return RequiredAction(type, options)
 }
diff --git a/src/type/action/return-type.ts b/src/type/action/return-type.ts
@@ -47,6 +47,10 @@ export function ReturnTypeDeferred<Type extends TSchema>(type: Type, options: TS
 // Type
 // ------------------------------------------------------------------
 /** Applies a ReturnType action to the given type. */
-export function ReturnType<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TReturnTypeAction<Type> {
+export type TReturnType<Type extends TSchema> = (
+  TReturnTypeAction<Type>
+)
+/** Applies a ReturnType action to the given type. */
+export function ReturnType<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TReturnType<Type> {
   return ReturnTypeAction(type, options) as never
 }
diff --git a/src/type/action/uncapitalize.ts b/src/type/action/uncapitalize.ts
@@ -47,6 +47,10 @@ export function UncapitalizeDeferred<Type extends TSchema>(type: Type, options:
 // Type
 // ------------------------------------------------------------------
 /** Applies a Uncapitalize action to the given type. */
-export function Uncapitalize<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TUncapitalizeAction<Type> {
+export type TUncapitalize<Type extends TSchema> = (
+  TUncapitalizeAction<Type>
+)
+/** Applies a Uncapitalize action to the given type. */
+export function Uncapitalize<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TUncapitalize<Type> {
   return UncapitalizeAction(type, options) as never
 }
diff --git a/src/type/action/uppercase.ts b/src/type/action/uppercase.ts
@@ -47,6 +47,10 @@ export function UppercaseDeferred<Type extends TSchema>(type: Type, options: TSc
 // Type
 // ------------------------------------------------------------------
 /** Applies a Uppercase action to the given type. */
-export function Uppercase<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TUppercaseAction<Type> {
+export type TUppercase<Type extends TSchema> = (
+  TUppercaseAction<Type>
+)
+/** Applies a Uppercase action to the given type. */
+export function Uppercase<Type extends TSchema>(type: Type, options: TSchemaOptions = {}): TUppercase<Type> {
   return UppercaseAction(type, options) as never
 }
diff --git a/src/typebox.ts b/src/typebox.ts
