--- url: https://jinju.js.org/api/types.md description: API reference for every exported type, including the inference types. --- # Types Every type used in a public signature is exported. Most code only needs the [inference types](#inference). The rest are here so that anything an editor shows can be named. ## Inference ### `InferFlagType` ```ts type InferFlagType; ``` The value a flag resolves to, e.g. `flag.url(o).multiple()` → `URL[] | undefined`. ### `InferArgType` ```ts type InferArgType; ``` The value an arg resolves to. ### `InferFlags` ```ts type InferFlags = { [K in keyof F]: InferFlagType }; ``` An object of flag values, as `run` receives it. ### `InferArgs` ```ts type InferArgs = { -readonly [K in keyof A]: InferArgType }; ``` A tuple of arg values, as `run` receives it. ### `MergeFlags` ```ts type MergeFlags; ``` `A` with `B`'s keys added or replaced. This is how scope and command flags combine. ## Checks Each check resolves to `unknown` when the input is valid, and otherwise to an object with an `~error` key that describes the problem, so the message appears in the type error. ### `CheckArgs` ```ts type CheckArgs; ``` Fails when more than one arg is `.multiple()`. ### `CheckTree` ```ts type CheckTree; ``` Fails on the first problem with dynamic segments in a command tree. See [Dynamic segments](../guide/dynamic-segments#compile-time-checks). ### `TreeErrors` ```ts type TreeErrors; ``` Every problem in tree `T` as a union of messages, or `never`. `S` is the segments above it and `At` is its path. Used by `CheckTree`. ### `NodeErrors` ```ts type NodeErrors; ``` Problems for a command or subtree `V` at `At`, or `never`. Used by `TreeErrors`. ### `SegmentError` ```ts type SegmentError; ``` The first problem binding args `A` of the command at `At` to segments `S`, or `never`. Used by `NodeErrors`. ### `CheckSchemaInput` ```ts type CheckSchemaInput; ``` Fails when a schema can't receive a string, e.g. `z.number()`. ## Params ### `Param` ```ts abstract class Param { abstract readonly kind: ParamKind; readonly value: ValueType; readonly options: ParamOptions; readonly state: ParamState; readonly defaultValue: unknown; resolve(inputs: readonly string[], label: string): Promise>; } ``` The base class of [`Flag`](./flag#flag-class), [`Switch`](./flag#switch) and [`Arg`](./arg#arg-class). `T` is the resolved type, e.g. `string[] | undefined`, and `V` is what one input parses to. `resolve` parses raw inputs into the final value, applying the modifiers. ### `ParamKind` ```ts type ParamKind = 'arg' | 'flag' | 'switch'; ``` ### `ParamOptions` ```ts interface ParamOptions { description: string; alias?: string; hidden?: boolean; name?: string; choices?: readonly string[]; env?: string; } ``` The options any param can have: the union of [`FlagOptions`](./flag#flagoptions) and [`ArgOptions`](./arg#argoptions). ### `ParamState` ```ts interface ParamState { readonly required: boolean; readonly multiple: boolean; readonly hasDefault: boolean; } ``` The modifier state at runtime. At the type level, it's derived from `T` and `V`. ### `ParamInit` ```ts interface ParamInit { value: ValueType; options: ParamOptions; state: ParamState; defaultValue?: unknown; } ``` What a param is constructed from. ### `Toggle` ```ts type Toggle = (occurrences: readonly [boolean, ...boolean[]]) => V; ``` Reduces a switch's occurrences (`--x` → `true`, `--no-x` → `false`) to its value. Only called when the switch was given at least once. ### `Result` ```ts type Result = { ok: true; value: T } | { ok: false; errors: JinjuError[] }; ``` ### `Defined` ```ts type Defined = {} | null; ``` A parsed value: anything but `undefined`, which means "not provided". ### `IsMultiple` ```ts type IsMultiple; ``` `true` when resolved type `T` collects `V` values into an array. ### `DefaultValue` ```ts type DefaultValue = IsMultiple extends true ? readonly [V, ...V[]] : V; ``` What `.default()` accepts: a non-empty array for `.multiple()` params, so `.multiple(false)` can take the first value. ## Values ### `Parse` ```ts type Parse = (input: string, options: O) => V | Promise; ``` Converts a raw command-line string into a typed value, using the options passed to the creator. Throw any `Error` to reject the input: its message is shown to the user. ### `ValueType` ```ts interface ValueType { readonly name: string; readonly parse: (input: string) => V | Promise; } ``` A parser bound to its options, and the name used in help (`--port `). ### `StringOptions` ```ts interface StringOptions { choices?: readonly C[]; } ``` `choices` restricts input to these values, and the type is their union. ### `NumberOptions` ```ts interface NumberOptions { min?: number; max?: number; integer?: boolean; } ``` ### `PathOptions` ```ts interface PathOptions { exists?: boolean; } ``` `exists` checks the path exists and is the right kind of entry (file or directory). ## Standard Schema ### `StandardSchemaV1` ```ts interface StandardSchemaV1 { readonly '~standard': { readonly version: 1; readonly vendor: string; readonly validate: ( value: unknown, ) => StandardSchemaResult | Promise>; readonly types?: { readonly input: Input; readonly output: Output } | undefined; }; } ``` The [Standard Schema](https://standardschema.dev) interface, as far as Jinju uses it. It's structurally compatible with `@standard-schema/spec`, so schemas from any compliant library work without Jinju depending on them. ### `StandardSchemaResult` ```ts type StandardSchemaResult = | { readonly value: Output; readonly issues?: undefined } | { readonly issues: readonly StandardSchemaIssue[] }; ``` ### `StandardSchemaIssue` ```ts interface StandardSchemaIssue { readonly message: string; readonly path?: readonly (PropertyKey | { readonly key: PropertyKey })[] | undefined; } ``` ### `SchemaInput` ```ts type SchemaInput; ``` A schema's declared input type, or `unknown` when it doesn't declare `types`. ### `SchemaOutput` ```ts type SchemaOutput; ``` What a schema validates to.