@tailor-platform/sdk 1.71.0 → 1.73.0

package/dist/configure/services/tailordb/types.d.mts

@@ -0,0 +1,149 @@
+import { InferredAttributeMap, TailorUser } from "../../../runtime/types.mjs";
+import { InferFieldsOutput, Prettify, output } from "../../../types/helpers.mjs";
+import { DefinedFieldMetadata, FieldMetadata, TailorField } from "../../types/field.types.mjs";
+import { DBFieldMetadata as DBFieldMetadata$1, GqlOperationsInput, RawPermissions, TailorDBServiceConfigInput } from "../../../types/tailordb.generated.mjs";
+import { NonEmptyObject } from "type-fest";
+
+//#region src/configure/services/tailordb/types.d.ts
+type SerialConfig<T extends "string" | "integer" = "string" | "integer"> = Prettify<{
+  start: number;
+  maxValue?: number;
+} & (T extends "string" ? {
+  format?: string;
+} : object)>;
+interface DBFieldMetadata extends FieldMetadata {
+  index?: boolean;
+  unique?: boolean;
+  vector?: boolean;
+  foreignKey?: boolean;
+  foreignKeyType?: string;
+  foreignKeyField?: string;
+  /** Lifecycle hooks for the field */
+  hooks?: DBFieldMetadata$1["hooks"];
+  serial?: SerialConfig;
+  relation?: boolean;
+  scale?: number;
+}
+interface DefinedDBFieldMetadata extends DefinedFieldMetadata {
+  index?: boolean;
+  unique?: boolean;
+  vector?: boolean;
+  foreignKey?: boolean;
+  foreignKeyType?: boolean;
+  validate?: boolean;
+  hooks?: {
+    create: boolean;
+    update: boolean;
+  };
+  serial?: boolean;
+  relation?: boolean;
+}
+type GqlOperationsConfig = GqlOperationsInput;
+interface RawRelationConfig {
+  type: "1-1" | "n-1" | "keyOnly" | "oneToOne" | "manyToOne" | "N-1";
+  toward: {
+    type: string;
+    as?: string;
+    key?: string;
+  };
+  backward?: string;
+}
+interface TailorDBTypeMetadata {
+  name: string;
+  description?: string;
+  settings?: {
+    pluralForm?: string;
+    aggregation?: boolean;
+    bulkUpsert?: boolean;
+    gqlOperations?: GqlOperationsConfig;
+    publishEvents?: boolean;
+  };
+  permissions: RawPermissions;
+  files: Record<string, string>;
+  indexes?: Record<string, {
+    fields: string[];
+    unique?: boolean;
+  }>;
+}
+/**
+ * Minimal structural interface for TailorDBField.
+ * Defines only the properties needed by parser, plugin, cli, and types layers.
+ * The full interface with builder methods (relation, index, unique, hooks, validate, etc.)
+ * is defined in configure/services/tailordb/schema.ts.
+ */
+interface TailorDBField<Defined extends DefinedDBFieldMetadata = DefinedDBFieldMetadata, Output = any> extends Omit<TailorField<Defined, Output, DBFieldMetadata, Defined["type"]>, "fields"> {
+  readonly fields: Record<string, TailorAnyDBField>;
+  readonly rawRelation: Readonly<RawRelationConfig> | undefined;
+}
+type TailorAnyDBField = TailorDBField<any, any>;
+/**
+ * Minimal structural interface for TailorDBType.
+ * Defines only the properties needed by parser, plugin, cli, and types layers.
+ * The full interface with builder methods (hooks, validate, features, permission, etc.)
+ * is defined in configure/services/tailordb/schema.ts.
+ */
+interface TailorDBType<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributeMap> {
+  readonly name: string;
+  readonly fields: Fields;
+  readonly _output: InferFieldsOutput<Fields>;
+  readonly metadata: TailorDBTypeMetadata;
+  readonly plugins: PluginAttachment[];
+}
+type TailorAnyDBType = TailorDBType<any, any>;
+type TailorDBInstance<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributeMap> = TailorDBType<Fields, User>;
+type HookFn<TValue, TData, TReturn> = (args: {
+  value: TValue;
+  data: TData extends Record<string, unknown> ? { readonly [K in keyof TData]?: TData[K] | null | undefined } : unknown;
+  user: TailorUser;
+}) => TReturn;
+type Hook<TData, TReturn> = {
+  create?: HookFn<TReturn | null, TData, TReturn>;
+  update?: HookFn<TReturn | null, TData, TReturn>;
+};
+type Hooks<F extends Record<string, TailorAnyDBField>, TData = { [K in keyof F]: output<F[K]> }> = NonEmptyObject<{ [K in Exclude<keyof F, "id"> as F[K]["_defined"] extends {
+  hooks: unknown;
+} ? never : F[K]["_defined"] extends {
+  type: "nested";
+} ? never : K]?: Hook<TData, output<F[K]>> }>;
+type ExcludeNestedDBFields<T extends Record<string, TailorAnyDBField>> = { [K in keyof T]: T[K] extends TailorDBField<{
+  type: "nested";
+  array: boolean;
+}, any> ? never : T[K] };
+interface TypeFeatures {
+  pluralForm?: string;
+  aggregation?: true;
+  bulkUpsert?: true;
+  /** Configure GraphQL operations for this type. Use "query" for read-only mode, or an object for granular control. */
+  gqlOperations?: GqlOperationsConfig;
+  /**
+   * Enable publishing events for this type.
+   * When enabled, record creation/update/deletion events are published.
+   * If not specified, this is automatically set to true when an executor uses this type
+   * with recordCreated/recordUpdated/recordDeleted triggers. If explicitly set to false
+   * while an executor uses this type, an error will be thrown during apply.
+   */
+  publishEvents?: boolean;
+}
+/**
+ * Plugin attachment stored on TailorAnyDBType instances.
+ */
+interface PluginAttachment {
+  pluginId: string;
+  config: unknown;
+}
+type IndexDef<T extends {
+  fields: Record<PropertyKey, unknown>;
+}> = {
+  fields: [keyof T["fields"], keyof T["fields"], ...(keyof T["fields"])[]];
+  unique?: boolean;
+  name?: string;
+};
+type RelationType = "1-1" | "oneToOne" | "n-1" | "manyToOne" | "N-1" | "keyOnly";
+type TailorDBExternalConfig = {
+  external: true;
+};
+type TailorDBServiceInput = {
+  [namespace: string]: TailorDBServiceConfigInput | TailorDBExternalConfig;
+};
+//#endregion
+export { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeNestedDBFields, GqlOperationsConfig, Hook, Hooks, IndexDef, PluginAttachment, RawRelationConfig, RelationType, SerialConfig, TailorAnyDBField, TailorAnyDBType, TailorDBExternalConfig, TailorDBField, TailorDBInstance, TailorDBServiceInput, TailorDBType, TailorDBTypeMetadata, TypeFeatures };

package/dist/configure/services/workflow/index.d.mts

@@ -0,0 +1,7 @@
+import { WorkflowServiceConfig, WorkflowServiceInput } from "../../config/types.mjs";
+import { ConcurrencyPolicy, RetryPolicy } from "../../../types/workflow.generated.mjs";
+import { WORKFLOW_TEST_ENV_KEY } from "./test-env-key.mjs";
+import { WorkflowJob, WorkflowJobContext, createWorkflowJob } from "./job.mjs";
+import { Workflow, WorkflowConfig, createWorkflow } from "./workflow.mjs";
+import { WaitPointInstance, defineWaitPoint, defineWaitPoints } from "./wait-point.mjs";
+export { type ConcurrencyPolicy, type RetryPolicy, WORKFLOW_TEST_ENV_KEY, WaitPointInstance, Workflow, WorkflowConfig, WorkflowJob, WorkflowJobContext, type WorkflowServiceConfig, type WorkflowServiceInput, createWorkflow, createWorkflowJob, defineWaitPoint, defineWaitPoints };

package/dist/configure/services/workflow/job.d.mts

@@ -0,0 +1,81 @@
+import { TailorEnv, TailorInvoker } from "../../../runtime/types.mjs";
+import { JsonCompatible } from "../../../types/helpers.mjs";
+import { WORKFLOW_TEST_ENV_KEY } from "./test-env-key.mjs";
+
+//#region src/configure/services/workflow/job.d.ts
+/**
+ * Context object passed as the second argument to workflow job body functions.
+ */
+type WorkflowJobContext = {
+  env: TailorEnv;
+  invoker?: TailorInvoker;
+};
+/**
+ * The body function type for a workflow job.
+ * Resolves to the callable signature when `I` / `O` are JsonValue-compatible,
+ * or to a template-literal error string that surfaces at the `body:` property.
+ */
+type JobBody<I, O> = [null] extends [I] ? "ERROR: Input cannot be null at the top level" : [I] extends [undefined] ? [O] extends [JsonCompatible<O> | undefined | void] ? (input: I, context: WorkflowJobContext) => O | Promise<O> : "ERROR: Output must be JsonValue-compatible (plain objects/arrays; no class instances or functions)" : [undefined] extends [I] ? "ERROR: Input cannot include undefined at the top level" : [I] extends [JsonCompatible<I>] ? [O] extends [JsonCompatible<O> | undefined | void] ? (input: I, context: WorkflowJobContext) => O | Promise<O> : "ERROR: Output must be JsonValue-compatible (plain objects/arrays; no class instances or functions)" : "ERROR: Input must be JsonValue-compatible (plain objects/arrays; no class instances or functions)";
+/**
+ * WorkflowJob represents a job that can be triggered in a workflow.
+ *
+ * Type constraints:
+ * - Input: Must be JsonValue-compatible (plain objects/arrays; no class instances or functions) or undefined.
+ * - Output: Must be JsonValue-compatible (plain objects/arrays; no class instances or functions), undefined, or void.
+ * - Trigger returns `Awaited<Output>` as-is (no Jsonify transformation).
+ */
+interface WorkflowJob<Name extends string = string, Input = undefined, Output = undefined> {
+  name: Name;
+  /**
+   * Trigger this job with the given input. Returns a Promise that resolves
+   * to the job's output value.
+   * @example
+   * body: async (input) => {
+   *   const a = await jobA.trigger({ id: input.id });
+   *   const b = await jobB.trigger({ id: input.id });
+   *   return { a, b };
+   * }
+   */
+  trigger: [Input] extends [undefined] ? () => Promise<Awaited<Output>> : (input: Input) => Promise<Awaited<Output>>;
+  body: (input: Input, context: WorkflowJobContext) => Output | Promise<Output>;
+}
+interface CreateWorkflowJobConfig<Name extends string, I, O> {
+  readonly name: Name;
+  readonly body: JobBody<I, O>;
+}
+/**
+ * Create a workflow job definition.
+ *
+ * All jobs must be named exports from the workflow file.
+ * Job names must be unique across the entire project.
+ *
+ * Input and output must be JsonValue-compatible (primitives, plain objects, arrays).
+ * Functions and objects with a `toJSON` method are rejected at the type level;
+ * class instances exposing methods are rejected via the property walk.
+ * @param config - Job configuration with name and body function.
+ * @param config.name - Unique job name across the project.
+ * @param config.body - Async function that processes the job input.
+ * @returns A WorkflowJob that can be triggered from other jobs.
+ * @example
+ * // Simple job with async body:
+ * export const fetchData = createWorkflowJob({
+ *   name: "fetch-data",
+ *   body: async (input: { id: string }) => {
+ *     const db = getDB("tailordb");
+ *     return await db.selectFrom("Table").selectAll().where("id", "=", input.id).executeTakeFirst();
+ *   },
+ * });
+ * @example
+ * // Orchestrator job that fans out to other jobs.
+ * export const orchestrate = createWorkflowJob({
+ *   name: "orchestrate",
+ *   body: async (input: { orderId: string }) => {
+ *     const inventory = await checkInventory.trigger({ orderId: input.orderId });
+ *     const payment = await processPayment.trigger({ orderId: input.orderId });
+ *     return { inventory, payment };
+ *   },
+ * });
+ */
+declare function createWorkflowJob<const Name extends string, I = undefined, O = undefined>(config: CreateWorkflowJobConfig<Name, I, O>): WorkflowJob<Name, I, Awaited<O>>;
+//#endregion
+export { WORKFLOW_TEST_ENV_KEY, WorkflowJob, WorkflowJobContext, createWorkflowJob };

package/dist/configure/services/workflow/test-env-key.d.mts

@@ -0,0 +1,9 @@
+//#region src/configure/services/workflow/test-env-key.d.ts
+/**
+ * Env-var fallback read by `.trigger()` when `mockWorkflow().setEnv()` is unset.
+ * @deprecated Use `mockWorkflow().setEnv()` from `@tailor-platform/sdk/vitest`.
+ * @internal
+ */
+declare const WORKFLOW_TEST_ENV_KEY = "TAILOR_TEST_WORKFLOW_ENV";
+//#endregion
+export { WORKFLOW_TEST_ENV_KEY };

package/dist/configure/services/workflow/types.d.mts

@@ -0,0 +1,2 @@
+import { WorkflowServiceConfig, WorkflowServiceInput } from "../../config/types.mjs";
+export type { WorkflowServiceConfig, WorkflowServiceInput };

package/dist/configure/services/workflow/wait-point.d.mts

@@ -0,0 +1,73 @@
+import { JsonCompatible } from "../../../types/helpers.mjs";
+
+//#region src/configure/services/workflow/wait-point.d.ts
+/**
+ * A single wait point instance with typed `.wait()` and `.resolve()` methods.
+ *
+ * - `.wait(payload?)` suspends execution until resolved. Returns the result from `.resolve()`.
+ * - `.resolve(executionId, callback)` resumes a suspended execution.
+ *
+ * Both `Payload` and `Result` must be JsonValue-compatible (primitives, plain objects, arrays).
+ * Functions and objects with a `toJSON` method are rejected at the type level.
+ */
+interface WaitPointInstance<Payload = undefined, Result = undefined> {
+  wait: [Payload] extends [undefined] ? () => Promise<Result> : (payload: Payload) => Promise<Result>;
+  resolve: (executionId: string, callback: (payload: [Payload] extends [undefined] ? undefined : Payload) => Result | Promise<Result>) => Promise<void>;
+}
+/**
+ * The type produced by `define<Payload, Result>()` / `defineWaitPoint<Payload, Result>(key)`.
+ * Resolves to `WaitPointInstance<Payload, Result>` when both types are JsonValue-compatible,
+ * or to a template-literal error string that surfaces at the call site.
+ */
+type WaitPointDef<Payload, Result> = [null] extends [Payload] ? "ERROR: Payload cannot be null at the top level" : [undefined] extends [Result] ? "ERROR: Result cannot be (or include) undefined (resolve callback must return a value)" : [Payload] extends [undefined] ? [Result] extends [JsonCompatible<Result>] ? WaitPointInstance<Payload, Result> : "ERROR: Result must be JsonValue-compatible (plain objects/arrays; no class instances or functions)" : [undefined] extends [Payload] ? "ERROR: Payload cannot include undefined at the top level" : [Payload] extends [JsonCompatible<Payload>] ? [Result] extends [JsonCompatible<Result>] ? WaitPointInstance<Payload, Result> : "ERROR: Result must be JsonValue-compatible (plain objects/arrays; no class instances or functions)" : "ERROR: Payload must be JsonValue-compatible (plain objects/arrays; no class instances or functions)";
+/**
+ * The `define` function passed to the `defineWaitPoints` builder callback.
+ * Returns an actual WaitPointInstance (not a phantom marker) so that the
+ * builder's return type can flow through as-is, preserving JSDoc comments
+ * on each property for IDE autocompletion.
+ *
+ * JSON validation is encoded in the return type rather than in type-parameter
+ * constraints, because tsgo rejects self-referential constraints like
+ * `Payload extends JsonCompatible<Payload>` as circular.
+ */
+type DefineFn = <Payload = undefined, Result = undefined>() => WaitPointDef<Payload, Result>;
+/**
+ * Define a single typed wait point with an explicit key.
+ *
+ * `Payload` and `Result` must be JsonValue-compatible.
+ * Functions and objects with a `toJSON` method are rejected at the type level;
+ * class instances exposing methods are rejected via the property walk.
+ * @param key - The wait point key used to match wait and resolve calls
+ * @returns A WaitPointInstance with typed `.wait()` and `.resolve()` methods
+ * @example
+ * export const approval = defineWaitPoint<{ message: string }, { approved: boolean }>("approval");
+ *
+ * await approval.wait({ message: "Please approve" });
+ */
+declare function defineWaitPoint<Payload = undefined, Result = undefined>(key: string): WaitPointDef<Payload, Result>;
+/**
+ * Define a group of typed wait points for human-in-the-loop workflows.
+ * Property names become the wait point keys.
+ *
+ * The return type is the same as the builder's return type, so JSDoc on each
+ * property is preserved and visible in IDE autocompletion.
+ *
+ * `Payload` and `Result` must be JsonValue-compatible.
+ * Functions and objects with a `toJSON` method are rejected at the type level;
+ * class instances exposing methods are rejected via the property walk.
+ * @param builder - Callback that receives a `define` factory and returns an object of wait points
+ * @returns The same object returned by the builder (with correct keys set on each instance)
+ * @example
+ * export const waitPoints = defineWaitPoints(define => ({
+ *   // Preceding JSDoc on this property is shown in IDE autocompletion
+ *   approval: define<{ message: string }, { approved: boolean }>(),
+ * }));
+ *
+ * // IDE shows the JSDoc when typing `waitPoints.`
+ * await waitPoints.approval.wait({ message: "Please approve" });
+ *
+ * // For 2-level access, use destructured export with JSDoc attached to the export itself.
+ */
+declare function defineWaitPoints<T extends Record<string, WaitPointInstance<any, any>>>(builder: (define: DefineFn) => T): T;
+//#endregion
+export { WaitPointInstance, defineWaitPoint, defineWaitPoints };

package/dist/configure/services/workflow/workflow.d.mts

@@ -0,0 +1,55 @@
+import { ConcurrencyPolicy, RetryPolicy } from "../../../types/workflow.generated.mjs";
+import { MachineUserName } from "../../types/machine-user.mjs";
+import { AuthInvoker } from "../auth/index.mjs";
+import { WorkflowJob } from "./job.mjs";
+
+//#region src/configure/services/workflow/workflow.d.ts
+interface WorkflowConfig<Job extends WorkflowJob<any, any, any> = WorkflowJob<any, any, any>> {
+  name: string;
+  mainJob: Job;
+  retryPolicy?: RetryPolicy;
+  concurrencyPolicy?: ConcurrencyPolicy;
+}
+interface Workflow<Job extends WorkflowJob<any, any, any> = WorkflowJob<any, any, any>> {
+  name: string;
+  mainJob: Job;
+  retryPolicy?: RetryPolicy;
+  concurrencyPolicy?: ConcurrencyPolicy;
+  trigger: (args: Parameters<Job["trigger"]>[0], options?: {
+    authInvoker: AuthInvoker<string> | MachineUserName;
+  }) => Promise<string>;
+}
+interface WorkflowDefinition<Job extends WorkflowJob<any, any, any>> {
+  name: string;
+  mainJob: Job;
+  retryPolicy?: RetryPolicy;
+  concurrencyPolicy?: ConcurrencyPolicy;
+}
+/**
+ * Create a workflow definition that can be triggered via the Tailor SDK.
+ * In production, bundler transforms .trigger() calls to tailor.workflow.triggerWorkflow().
+ *
+ * The workflow MUST be the default export of the file.
+ * All jobs referenced by the workflow MUST be named exports.
+ * @template Job
+ * @param config - Workflow configuration
+ * @returns Defined workflow
+ * @example
+ * export const fetchData = createWorkflowJob({ name: "fetch-data", body: async (input: { id: string }) => ({ id: input.id }) });
+ * export const processData = createWorkflowJob({
+ *   name: "process-data",
+ *   body: async (input: { id: string }) => {
+ *     const data = await fetchData.trigger({ id: input.id });
+ *     return { data };
+ *   },
+ * });
+ *
+ * // Workflow must be default export; mainJob is the entry point
+ * export default createWorkflow({
+ *   name: "data-processing",
+ *   mainJob: processData,
+ * });
+ */
+declare function createWorkflow<Job extends WorkflowJob<any, any, any>>(config: WorkflowDefinition<Job>): Workflow<Job>;
+//#endregion
+export { type ConcurrencyPolicy, type RetryPolicy, Workflow, WorkflowConfig, createWorkflow };

package/dist/configure/types/aigateway-name.d.mts

@@ -0,0 +1,12 @@
+//#region src/configure/types/aigateway-name.d.ts
+interface AIGatewayNameRegistry {}
+/**
+ * AI Gateway name.
+ *
+ * When `tailor.d.ts` is generated (via `tailor-sdk deploy`/`generate`), this is narrowed
+ * to the union of AI Gateway names defined via `defineAIGateway()`. Falls back to
+ * `string` before the first generate run.
+ */
+type AIGatewayName = keyof AIGatewayNameRegistry extends never ? string : keyof AIGatewayNameRegistry & string;
+//#endregion
+export { AIGatewayName, AIGatewayNameRegistry };

package/dist/configure/types/connection-name.d.mts

@@ -0,0 +1,12 @@
+//#region src/configure/types/connection-name.d.ts
+interface ConnectionNameRegistry {}
+/**
+ * Auth connection name.
+ *
+ * When `tailor.d.ts` is generated (via `tailor-sdk deploy`/`generate`), this is narrowed
+ * to the union of connection names defined in `defineAuth()`'s `connections`. Falls back
+ * to `string` before the first generate run.
+ */
+type ConnectionName = keyof ConnectionNameRegistry extends never ? string : keyof ConnectionNameRegistry & string;
+//#endregion
+export { ConnectionName, ConnectionNameRegistry };

package/dist/configure/types/field.d.mts

@@ -0,0 +1,9 @@
+import { EnumValue } from "./field.types.mjs";
+
+//#region src/configure/types/field.d.ts
+type AllowedValues = readonly [string | EnumValue, ...(string | EnumValue)[]];
+type AllowedValuesOutput<V extends AllowedValues> = V[number] extends infer T ? T extends string ? T : T extends {
+  value: infer K;
+} ? K : never : never;
+//#endregion
+export { AllowedValues, AllowedValuesOutput };

package/dist/configure/types/field.types.d.mts

@@ -0,0 +1,109 @@
+import { TailorUser } from "../../runtime/types.mjs";
+import { InferFieldsOutput, output } from "../../types/helpers.mjs";
+import { NonEmptyObject } from "type-fest";
+
+//#region src/configure/types/field.types.d.ts
+interface EnumValue {
+  value: string;
+  description?: string;
+}
+type TailorFieldType = "uuid" | "string" | "boolean" | "integer" | "float" | "decimal" | "enum" | "date" | "datetime" | "time" | "nested";
+type TailorToTs = {
+  string: string;
+  integer: number;
+  float: number;
+  decimal: string;
+  boolean: boolean;
+  uuid: string;
+  date: string;
+  datetime: string | Date;
+  time: string;
+  enum: string;
+  object: Record<string, unknown>;
+  nested: Record<string, unknown>;
+} & Record<TailorFieldType, unknown>;
+interface FieldMetadata {
+  description?: string;
+  required?: boolean;
+  array?: boolean;
+  allowedValues?: EnumValue[];
+  validate?: FieldValidateInput<any>[];
+  typeName?: string;
+}
+interface DefinedFieldMetadata {
+  type: TailorFieldType;
+  array: boolean;
+  description?: boolean;
+  validate?: boolean;
+  typeName?: boolean;
+}
+type FieldOptions = {
+  optional?: boolean;
+  array?: boolean;
+};
+type FieldOutput<T, O extends FieldOptions> = OptionalFieldOutput<ArrayFieldOutput<T, O>, O>;
+type OptionalFieldOutput<T, O extends FieldOptions> = O["optional"] extends true ? T | null : T;
+type ArrayFieldOutput<T, O extends FieldOptions> = [O] extends [{
+  array: true;
+}] ? T[] : T;
+/**
+ * Validation function type
+ */
+type ValidateFn<O, D = unknown> = (args: {
+  value: O;
+  data: D;
+  user: TailorUser;
+}) => boolean;
+/**
+ * Validation configuration with custom error message
+ */
+type ValidateConfig<O, D = unknown> = [ValidateFn<O, D>, string];
+/**
+ * Field-level validation function
+ */
+type FieldValidateFn<O> = ValidateFn<O>;
+/**
+ * Field-level validation configuration
+ */
+type FieldValidateConfig<O> = ValidateConfig<O>;
+/**
+ * Input type for field validation - can be either a function or a tuple of [function, errorMessage]
+ */
+type FieldValidateInput<O> = FieldValidateFn<O> | FieldValidateConfig<O>;
+/**
+ * Base validators type for field collections
+ * @template F - Record of fields
+ * @template ExcludeKeys - Keys to exclude from validation (default: "id" for TailorDB)
+ */
+type ValidatorsBase<F extends Record<string, {
+  _defined: any;
+  _output: any;
+  [key: string]: any;
+}>, ExcludeKeys extends string = "id"> = NonEmptyObject<{ [K in Exclude<keyof F, ExcludeKeys> as F[K]["_defined"] extends {
+  validate: unknown;
+} ? never : K]?: ValidateFn<output<F[K]>, InferFieldsOutput<F>> | ValidateConfig<output<F[K]>, InferFieldsOutput<F>> | (ValidateFn<output<F[K]>, InferFieldsOutput<F>> | ValidateConfig<output<F[K]>, InferFieldsOutput<F>>)[] }>;
+/**
+ * Validators type (by default excludes "id" field for TailorDB compatibility)
+ * Can be used with both TailorField and TailorDBField
+ */
+type Validators<F extends Record<string, {
+  _defined: any;
+  _output: any;
+  [key: string]: any;
+}>> = ValidatorsBase<F, "id">;
+/**
+ * Minimal structural interface for TailorField.
+ * Defines only the properties needed by parser, plugin, cli, and types layers.
+ * The full interface with builder methods (description, typeName, validate, parse)
+ * is defined in configure/types/type.ts.
+ */
+interface TailorField<Defined extends DefinedFieldMetadata = DefinedFieldMetadata, Output = any, M extends FieldMetadata = FieldMetadata, T extends TailorFieldType = TailorFieldType> {
+  readonly type: T;
+  readonly fields: Record<string, TailorAnyField>;
+  readonly _defined: Defined;
+  readonly _output: Output;
+  readonly metadata: M;
+}
+type TailorAnyField = TailorField<any>;
+//#endregion
+export { ArrayFieldOutput, DefinedFieldMetadata, EnumValue, FieldMetadata, FieldOptions, FieldOutput, FieldValidateInput, TailorAnyField, TailorField, TailorFieldType, TailorToTs, ValidateConfig, ValidateFn, Validators };

package/dist/configure/types/idp-name.d.mts

@@ -0,0 +1,12 @@
+//#region src/configure/types/idp-name.d.ts
+interface IdpNameRegistry {}
+/**
+ * IdP namespace name.
+ *
+ * When `tailor.d.ts` is generated (via `tailor-sdk deploy`/`generate`), this is narrowed
+ * to the union of defined IdP names. When no IdPs are registered yet, falls back to
+ * `string` to avoid blocking editing before the first generate run.
+ */
+type IdpName = keyof IdpNameRegistry extends never ? string : keyof IdpNameRegistry & string;
+//#endregion
+export { IdpName, IdpNameRegistry };

package/dist/configure/types/index.d.mts

@@ -0,0 +1,4 @@
+import { AllowedValues, AllowedValuesOutput } from "./field.mjs";
+import { TailorAnyField, TailorField } from "./type.mjs";
+import { MachineUserName, MachineUserNameRegistry } from "./machine-user.mjs";
+export { AllowedValues, AllowedValuesOutput, MachineUserName, MachineUserNameRegistry, TailorAnyField, TailorField };

package/dist/configure/types/machine-user.d.mts

@@ -0,0 +1,12 @@
+//#region src/configure/types/machine-user.d.ts
+interface MachineUserNameRegistry {}
+/**
+ * Machine user name.
+ *
+ * When `tailor.d.ts` is generated (via `tailor-sdk deploy`/`generate`), this is narrowed
+ * to the union of defined machine user names. When no machine users are registered yet,
+ * falls back to `string` to avoid blocking editing before the first generate run.
+ */
+type MachineUserName = keyof MachineUserNameRegistry extends never ? string : keyof MachineUserNameRegistry & string;
+//#endregion
+export { MachineUserName, MachineUserNameRegistry };

package/dist/configure/types/type.d.mts

@@ -0,0 +1,99 @@
+import { TailorUser } from "../../runtime/types.mjs";
+import { TypeLevelError } from "../../types/helpers.mjs";
+import { DefinedFieldMetadata, FieldMetadata, FieldValidateInput, TailorField as TailorField$1, TailorFieldType } from "./field.types.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/configure/types/type.d.ts
+type AnyBuilderMethod = any;
+type TailorAnyField = Omit<TailorField$1<AnyBuilderMethod, AnyBuilderMethod, FieldMetadata, TailorFieldType>, "fields"> & {
+  readonly fields: Record<string, AnyBuilderMethod>;
+  _metadata: FieldMetadata;
+  description: AnyBuilderMethod;
+  typeName: AnyBuilderMethod;
+  validate: AnyBuilderMethod;
+  parse: AnyBuilderMethod;
+  _parseInternal: AnyBuilderMethod;
+};
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type WithFieldDescription<Defined> = Defined & {
+  description: true;
+};
+type WithFieldTypeName<Defined> = Defined & {
+  typeName: true;
+};
+type WithFieldValidate<Defined> = Defined & {
+  validate: true;
+};
+type FieldDescriptionFn<Defined extends DefinedFieldMetadata, Output> = (description: string) => TailorField<WithFieldDescription<Defined>, Output>;
+type FieldTypeNameFn<Defined extends DefinedFieldMetadata, Output> = (typeName: string) => TailorField<WithFieldTypeName<Defined>, Output>;
+type FieldValidateFn<Defined extends DefinedFieldMetadata, Output> = (...validate: FieldValidateInput<Output>[]) => TailorField<WithFieldValidate<Defined>, Output>;
+type FieldDescriptionMethod<Defined extends DefinedFieldMetadata, Output> = IsAny<Defined> extends true ? FieldDescriptionFn<Defined, Output> : Defined extends {
+  description: unknown;
+} ? TypeLevelError<".description() has already been set"> : FieldDescriptionFn<Defined, Output>;
+type FieldTypeNameMethod<Defined extends DefinedFieldMetadata, Output> = IsAny<Defined> extends true ? TypeLevelError<string> : Defined extends {
+  typeName: unknown;
+} ? TypeLevelError<".typeName() has already been set"> : Defined extends {
+  type: "enum" | "nested";
+} ? FieldTypeNameFn<Defined, Output> : TypeLevelError<"typeName can only be set on enum or object fields">;
+type FieldValidateMethod<Defined extends DefinedFieldMetadata, Output> = IsAny<Defined> extends true ? FieldValidateFn<Defined, Output> : Defined extends {
+  validate: unknown;
+} ? TypeLevelError<".validate() has already been set"> : FieldValidateFn<Defined, Output>;
+/**
+ * Full TailorField interface with builder methods.
+ * Extends the minimal structural interface from types/ with fluent API methods.
+ */
+interface TailorField<Defined extends DefinedFieldMetadata = DefinedFieldMetadata, Output = any, M extends FieldMetadata = FieldMetadata, T extends TailorFieldType = TailorFieldType> extends TailorField$1<Defined, Output, M, T> {
+  readonly fields: Record<string, TailorAnyField>;
+  _metadata: M;
+  /**
+   * Set a description for the field
+   * @param description - The description text
+   * @returns The field with updated metadata
+   */
+  description: FieldDescriptionMethod<Defined, Output>;
+  /**
+   * Set a custom type name for enum or nested types
+   * @param typeName - The custom type name
+   * @returns The field with updated metadata
+   */
+  typeName: FieldTypeNameMethod<Defined, Output>;
+  /**
+   * Add validation functions to the field
+   * @param validate - One or more validation functions
+   * @returns The field with updated metadata
+   */
+  validate: FieldValidateMethod<Defined, Output>;
+  /**
+   * Parse and validate a value against this field's validation rules
+   * Returns StandardSchema Result type with success or failure
+   * @param args - Value, context data, and user
+   * @returns Validation result
+   */
+  parse(args: FieldParseArgs): StandardSchemaV1.Result<Output>;
+  /**
+   * Internal parse method that tracks field path for nested validation
+   * @private
+   * @param args - Parse arguments
+   * @returns Validation result
+   */
+  _parseInternal(args: FieldParseInternalArgs): StandardSchemaV1.Result<Output>;
+}
+type FieldParseArgs = {
+  value: unknown;
+  data: unknown;
+  user: TailorUser;
+};
+type FieldParseInternalArgs = {
+  value: any;
+  data: unknown;
+  user: TailorUser;
+  pathArray: string[];
+};
+/**
+ * Create a UUID field for resolver input/output.
+ * @param options - Field configuration options
+ * @returns A UUID field
+ * @example t.uuid()
+ */
+//#endregion
+export { TailorAnyField, TailorField };