---
title: SDK types
description: Complete public declarations from @backlit/sdk/types.
---

This page is generated from the built SDK declarations. Import these names
from `@backlit/sdk/types`. The signatures include overloads, type parameters,
options, and public members. Do not edit this page by hand.

Start with [App and areas](/reference/app), [Resources](/reference/resources),
[Search state](/reference/state), or [Extensions](/advanced/extensions) for usage.

## ActionAddress

```ts title="@backlit/sdk/types"
type ActionAddress = {
    resource: string;
    action: string;
    args: string[];
    key: string;
};
```

## ActionHandler

```ts title="@backlit/sdk/types"
type ActionHandler<Schema extends StandardSchemaV1, Params extends ParamNames = readonly [
]> = (ctx: RequestContext<'action', Params, StandardSchemaV1.InferOutput<Schema>>) => AsyncOrSync<void | Respondable<ValidActionResponse>>;
```

## AgentOptions

```ts title="@backlit/sdk/types"
type AgentOptions = {
    description: string;
    search?: boolean;
};
```

## AgentTool

```ts title="@backlit/sdk/types"
type AgentTool = {
    name: string;
    description: string;
    source: AgentToolSource;
    input: Record<string, unknown>;
    mutates: boolean;
};
```

## AgentToolResult

```ts title="@backlit/sdk/types"
type AgentToolResult = {
    kind: 'data';
    value: unknown;
} | {
    kind: 'address';
    address: ViewAddress;
    title?: string;
} | {
    kind: 'response';
    response: ValidActionResponse;
};
```

## AgentToolSource

```ts title="@backlit/sdk/types"
type AgentToolSource = LinkTargetAddress | LookupTarget | FormActionAddress;
```

## AppConfig

```ts title="@backlit/sdk/types"
type AppConfig<Areas extends {
    [area: string]: {
        [resource: string]: ResourceLoader;
    };
}> = {
    preferences?: AppPreferences;
    extensions?: BacklitExtension[];
    middleware?: MiddlewareLoader[];
    areas: {
        [Area in keyof Areas]: {
            label: string;
            icon?: string;
            resources: Areas[Area];
            navigation: NavigationItem<keyof Areas[Area] & string>[];
        };
    };
};
```

## BacklitExtension

```ts title="@backlit/sdk/types"
type BacklitExtension = () => ManifestExtension;
```

## CardinalityValue

```ts title="@backlit/sdk/types"
type CardinalityValue<Value, Card extends Cardinality> = [
    Value
] extends [
    never
] ? never : Card extends 'many' ? Value[] : Value;
```

## ConditionableOptions

```ts title="@backlit/sdk/types"
type ConditionableOptions<Options = {}> = Omit<Options, keyof Conditioned> & {
    [Key in keyof Conditioned]?: Nodeable<Condition>;
};
```

## Defect

```ts title="@backlit/sdk/types"
interface Defect {
    index?: number;
    field?: string;
    kind?: Field['kind'];
    value?: unknown;
    reason: string;
}
```

## DefectReporter

```ts title="@backlit/sdk/types"
type DefectReporter = (defect: Defect) => void;
```

## ExtractFieldByName

```ts title="@backlit/sdk/types"
type ExtractFieldByName<Fields extends readonly FieldBuilderContract<string, unknown, never>[], Name extends string> = Extract<Fields[number], FieldBuilderContract<Name>>;
```

## ExtractFieldNames

```ts title="@backlit/sdk/types"
type ExtractFieldNames<Fields extends readonly FieldBuilderContract<string, unknown, never>[]> = Fields[number][typeof FIELD_NAME];
```

## ExtractFieldValue

```ts title="@backlit/sdk/types"
type ExtractFieldValue<F> = F extends FieldBuilderContract<string, infer Value> ? Value : never;
```

## ExtractFilterByName

```ts title="@backlit/sdk/types"
type ExtractFilterByName<Filters extends readonly FilterBuilderContract<string>[], Name extends string> = Extract<Filters[number], FilterBuilderContract<Name>>;
```

## ExtractFilterNames

```ts title="@backlit/sdk/types"
type ExtractFilterNames<Filters extends readonly FilterBuilderContract<string>[]> = Filters[number][typeof FILTER_NAME];
```

## ExtractFilterValue

```ts title="@backlit/sdk/types"
type ExtractFilterValue<F> = F extends FilterBuilderContract<string, infer Value> ? Value : never;
```

## ExtractRecordOf

```ts title="@backlit/sdk/types"
type ExtractRecordOf<Fields extends readonly FieldBuilderContract<string, unknown, never>[]> = {
    [F in Fields[number] as F[typeof FIELD_NAME]]: NonNullable<F[typeof FIELD_VALUE]>;
};
```

## ExtractRepeaterKeys

```ts title="@backlit/sdk/types"
type ExtractRepeaterKeys<Input> = {
    [Key in Extract<keyof Input, string>]: NonNullable<Input[Key]> extends readonly object[] ? Key : never;
}[Extract<keyof Input, string>];
```

## ExtractRepeaterRow

```ts title="@backlit/sdk/types"
type ExtractRepeaterRow<Input, Key extends keyof Input> = NonNullable<Input[Key]> extends readonly (infer Row extends object)[] ? Row : never;
```

## ExtractResourceFieldNames

```ts title="@backlit/sdk/types"
type ExtractResourceFieldNames<Target> = Target extends Resource<string, infer Fields extends readonly FieldBuilderContract<string, unknown, never>[]> ? ExtractFieldNames<Fields> : never;
```

## ExtractResourceLoader

```ts title="@backlit/sdk/types"
type ExtractResourceLoader<Areas extends Record<string, Record<string, ResourceLoader>>, Name extends ExtractResourceNames<Areas>> = {
    [Area in keyof Areas]: Name extends keyof Areas[Area] ? Areas[Area][Name] : never;
}[keyof Areas];
```

## ExtractResourceNames

```ts title="@backlit/sdk/types"
type ExtractResourceNames<Areas extends Record<string, Record<string, ResourceLoader>>> = {
    [Area in keyof Areas]: keyof Areas[Area] & string;
}[keyof Areas];
```

## ExtractResourceRecord

```ts title="@backlit/sdk/types"
type ExtractResourceRecord<Target> = Target extends Resource<string, infer Fields extends readonly FieldBuilderContract<string, unknown, never>[]> ? ExtractRecordOf<Fields> : never;
```

## ExtractStateBindings

```ts title="@backlit/sdk/types"
type ExtractStateBindings<Atoms extends StateAtoms> = {
    readonly [Key in keyof Atoms]: StateBinding<Atoms[Key]>;
};
```

## ExtractViewFilters

```ts title="@backlit/sdk/types"
type ExtractViewFilters<Atoms extends StateAtoms> = Atoms[keyof Atoms] extends (infer Atom) ? Atom extends FilterBar<infer Filters> ? Filters : never : never;
```

## FieldBuilderContract

```ts title="@backlit/sdk/types"
interface FieldBuilderContract<Name extends string, Value = unknown, in Row = unknown> extends Nodeable<Field> {
    readonly [FIELD_NAME]: Name;
    readonly [FIELD_VALUE]?: Value;
    readonly [FIELD_ROW]?: (row: Row) => void;
    [VALUE_FOR](record: never, node: Field, report: ReportDefect, options?: never): unknown;
}
```

## FieldRemapper

```ts title="@backlit/sdk/types"
type FieldRemapper<Role extends FieldRole, Kind extends GetFieldKindsForRole<Role>> = (value: unknown, field: Extract<Field, {
    kind: Kind;
}>, record: Record<string, unknown>, parent: FieldRemappers, report: ReportDefect) => unknown;
```

## FieldRemapperFallbackRole

```ts title="@backlit/sdk/types"
type FieldRemapperFallbackRole = 'display' | 'input';
```

## FieldRemapperMap

```ts title="@backlit/sdk/types"
type FieldRemapperMap<Role extends FieldRole> = Prettify<{
    [Kind in Exclude<GetFieldKindsForRole<Role>, 'ref' | 'has'>]: FieldRemapper<Role, Kind>;
}>;
```

## FilterBuilderContract

```ts title="@backlit/sdk/types"
interface FilterBuilderContract<Name extends string, Value = unknown> extends Nodeable<Filter> {
    readonly [FILTER_NAME]: Name;
    readonly [FILTER_VALUE]?: Value;
    [PARSE](raw: unknown): Value | undefined;
    [STRINGIFY](value: Value): string | string[];
}
```

## FormInitialData

```ts title="@backlit/sdk/types"
type FormInitialData<Input> = {
    [Key in keyof Input]?: unknown;
};
```

## GetArgsFor

```ts title="@backlit/sdk/types"
type GetArgsFor<Params extends ParamNames> = {
    readonly [K in keyof Params]: string | number;
};
```

## GetFieldBuildersFor

```ts title="@backlit/sdk/types"
type GetFieldBuildersFor<Input, Row = unknown> = {
    [Name in Extract<keyof Input, string>]: FieldBuilderContract<Name, Input[Name], Row>;
}[Extract<keyof Input, string>];
```

## GetFieldRoleSelectionsFor

```ts title="@backlit/sdk/types"
type GetFieldRoleSelectionsFor<Fields extends readonly FieldBuilderContract<string, unknown, never>[]> = Prettify<{
    [Name in ExtractFieldNames<Fields>]?: GetFieldRolesForKind<ExtractFieldByName<Fields, Name> extends Nodeable<infer Node extends Field> ? Node['kind'] : never>;
}>;
```

## GetFiltersFor

```ts title="@backlit/sdk/types"
type GetFiltersFor<View extends Linkable> = View extends ViewDefinition<string, string, ParamNames, infer Atoms> ? [
    ExtractViewFilters<Atoms>
] extends [
    never
] ? {
    [name: string]: never;
} : Partial<ParseFilters<ExtractViewFilters<Atoms>>> : never;
```

## GetLookupArgsFor

```ts title="@backlit/sdk/types"
type GetLookupArgsFor<Params extends ParamNames> = {
    readonly [K in keyof Params]: FieldBuilderContract<string, unknown, never> | string | number | boolean;
};
```

## GetParamValuesFor

```ts title="@backlit/sdk/types"
type GetParamValuesFor<Names extends ParamNames> = {
    readonly [K in Names[number]]: string;
};
```

## HttpRequestOptions

```ts title="@backlit/sdk/types"
type HttpRequestOptions = {
    query(): Record<string, string | string[]>;
    headers(): Record<string, string>;
    cookies(): Record<string, string>;
    json(): Promise<unknown>;
    formdata(): Promise<FormData>;
};
```

## Linkable

```ts title="@backlit/sdk/types"
type Linkable = ViewDefinition<string, string, ParamNames, any>;
```

## LookupResolver

```ts title="@backlit/sdk/types"
type LookupResolver<Fields extends readonly FieldBuilderContract<string, unknown, never>[], Params extends ParamNames = readonly [
]> = (ctx: RequestContext<'lookup', Params>, lookup: LookupBuilder) => AsyncOrSync<LookupBuilder<Fields> | Respondable<ErrorResponse>>;
```

## Middleware

```ts title="@backlit/sdk/types"
type Middleware = (ctx: RequestContext, request: HttpRequest | undefined, next: NextFn) => AsyncOrSync<void | Respondable<RedirectResponse | ErrorResponse>>;
```

## MiddlewareLoader

```ts title="@backlit/sdk/types"
type MiddlewareLoader = LazyImport<Middleware>;
```

## NavigationEntry

```ts title="@backlit/sdk/types"
type NavigationEntry<ResourceKey extends string> = {
    label: string;
    resource: ResourceKey;
    view: string;
    icon?: string;
};
```

## NavigationGroup

```ts title="@backlit/sdk/types"
type NavigationGroup<ResourceKey extends string> = {
    label: string;
    items: NavigationEntry<ResourceKey>[];
};
```

## NavigationItem

```ts title="@backlit/sdk/types"
type NavigationItem<ResourceKey extends string> = NavigationEntry<ResourceKey> | NavigationGroup<ResourceKey>;
```

## Nodeable

```ts title="@backlit/sdk/types"
interface Nodeable<T> {
    [TO_NODE](ctx: RequestContext): T;
    [VALUE_FOR]?(record: never, node: T, report: ReportDefect, options?: never): unknown;
}
```

## PaginatorState

```ts title="@backlit/sdk/types"
type PaginatorState = {
    page: number;
    perPage: number;
};
```

## ParamNames

```ts title="@backlit/sdk/types"
type ParamNames = readonly string[];
```

## ParseFilters

```ts title="@backlit/sdk/types"
type ParseFilters<Filters extends readonly FilterBuilderContract<string>[]> = {
    readonly [Name in ExtractFilterNames<Filters>]: ExtractFilterValue<ExtractFilterByName<Filters, Name>> | undefined;
};
```

## ParseState

```ts title="@backlit/sdk/types"
type ParseState<Atoms extends StateAtoms> = {
    readonly [Key in keyof Atoms]: Atoms[Key] extends StateAtomContract<infer Value> ? Value : never;
};
```

## PickFieldBuilders

```ts title="@backlit/sdk/types"
type PickFieldBuilders<Fields extends readonly FieldBuilderContract<string, unknown, never>[], Keys extends readonly string[]> = {
    -readonly [Index in keyof Keys]: Extract<Fields[number], FieldBuilderContract<Keys[Index]>>;
};
```

## Producer

```ts title="@backlit/sdk/types"
type Producer<Node extends Block = Block> = Nodeable<Node> | Resolvable<Node> | ZoneBuilder<Node, any>;
```

## ReportDefect

```ts title="@backlit/sdk/types"
type ReportDefect = (reason: string) => undefined;
```

## RequestContextOptions

```ts title="@backlit/sdk/types"
type RequestContextOptions<Kind extends RequestKind, Params extends ParamNames = ParamNames, Data = Kind extends 'action' ? unknown : never, SearchQuery = Kind extends 'lookup' ? string : never> = {
    kind: Kind;
    resource: string;
    name: string;
    args?: string[];
    paramValues?: GetParamValuesFor<Params>;
    mode?: TargetMode;
    search?: SearchParams;
} & (Kind extends 'action' ? {
    data: Data;
} : Kind extends 'lookup' ? {
    searchQuery: SearchQuery;
} : object);
```

## RequestKind

```ts title="@backlit/sdk/types"
type RequestKind = 'view' | 'zone' | 'action' | 'lookup';
```

## Resolvable

```ts title="@backlit/sdk/types"
interface Resolvable<Node> {
    [RESOLVE](ctx: RequestContext<'view' | 'zone'>): Promise<Node>;
    [RESOLVE_FOR](ctx: RequestContext<'view' | 'zone'>, zone: string): Promise<ZoneNode | undefined>;
}
```

## ResourceLoader

```ts title="@backlit/sdk/types"
type ResourceLoader = LazyImport<unknown>;
```

## Respondable

```ts title="@backlit/sdk/types"
interface Respondable<ResponseType extends Response = Response> {
    [TO_RESPONSE](): ResponseType;
}
```

## SorterState

```ts title="@backlit/sdk/types"
type SorterState<Columns extends readonly string[] = readonly string[]> = {
    column: Columns[number];
    direction: 'asc' | 'desc';
}[];
```

## StateAtomContract

```ts title="@backlit/sdk/types"
interface StateAtomContract<Value = unknown> {
    readonly [KEYWORD]: string;
    readonly definesResult: boolean;
    readonly dependsOnResult: boolean;
    fieldNames(): string[];
    [PARSE](values: SearchValues): Value;
}
```

## StateAtoms

```ts title="@backlit/sdk/types"
type StateAtoms = Record<string, StateAtomContract>;
```

## StateBinding

```ts title="@backlit/sdk/types"
type StateBinding<Atom extends StateAtomContract> = {
    atom: Atom;
    zone: string | undefined;
};
```

## TableFooterRow

```ts title="@backlit/sdk/types"
type TableFooterRow<FieldNames extends string> = {
    label: string;
    values: Partial<Record<FieldNames, unknown>>;
};
```

## TargetBuilderContract

```ts title="@backlit/sdk/types"
interface TargetBuilderContract<Row> {
    [TO_NODE](ctx: RequestContext): TargetDefinition;
    [VALUE_FOR](record: Row, report: ReportDefect, options: {
        ctx: RequestContext;
        onDefect: DefectReporter;
        requireLabel?: boolean;
        repeated?: boolean;
    }): TargetValue | undefined;
}
```

## Transport

```ts title="@backlit/sdk/types"
type Transport = {
    request: HttpRequest;
};
```

## ValidActionResponse

```ts title="@backlit/sdk/types"
type ValidActionResponse = (SuccessResponse & {
    node?: undefined;
}) | RedirectResponse | RefreshResponse | ErrorResponse;
```

## ValidLookupResponse

```ts title="@backlit/sdk/types"
type ValidLookupResponse = (SuccessResponse & {
    node: LookupNode;
}) | RedirectResponse | ErrorResponse;
```

## ValidViewResponse

```ts title="@backlit/sdk/types"
type ValidViewResponse = (SuccessResponse & {
    node: ViewNode;
}) | RedirectResponse | ErrorResponse;
```

## ValidZoneResponse

```ts title="@backlit/sdk/types"
type ValidZoneResponse = (SuccessResponse & {
    node: ZoneNode;
}) | RedirectResponse | ErrorResponse;
```

## ViewAddress

```ts title="@backlit/sdk/types"
type ViewAddress = {
    resource: string;
    view: string;
    args: string[];
    key: string;
};
```

## ViewResolver

```ts title="@backlit/sdk/types"
type ViewResolver<Params extends ParamNames = readonly [
], Atoms extends StateAtoms = {}> = (ctx: RequestContext<'view' | 'zone', Params>, view: ViewBuilder<Atoms>) => AsyncOrSync<OneOrMore<Producer> | Respondable<RedirectResponse | ErrorResponse>>;
```

## ViewTargetOptions

```ts title="@backlit/sdk/types"
type ViewTargetOptions<View extends Linkable, Row> = {
    mode?: TargetMode;
    filters?: GetFiltersFor<View> | ((record: Row) => GetFiltersFor<View>);
};
```

## VisitPresentation

```ts title="@backlit/sdk/types"
type VisitPresentation<View extends Linkable> = TargetPresentation & {
    skip?: boolean;
    filters?: GetFiltersFor<View>;
};
```

## ZoneResolver

```ts title="@backlit/sdk/types"
type ZoneResolver<Node extends Block, Atoms extends StateAtoms = {}> = (ctx: RequestContext<'view' | 'zone'>, zone: ZoneBuilder<Node, Atoms>) => AsyncOrSync<OneOrMore<Nodeable<Node> | Resolvable<Node>>>;
```