@tailor-platform/sdk 2.0.0-next.1 → 2.0.0-next.11

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

@@ -0,0 +1,103 @@
+import { InferredAttributes } from "../../../runtime/types.mjs";
+import { UserBooleanArrayOperand, UserBooleanOperand, UserStringArrayOperand, UserStringOperand } from "../../types/permission-operand.types.mjs";
+//#region src/configure/services/tailordb/permission.d.ts
+/**
+ * Record-level permission configuration for a TailorDB type.
+ * Defines create, read, update, and delete permissions.
+ *
+ * Prefer object format with explicit `conditions` and `permit` for readability.
+ * Shorthand array format is supported for compatibility, but less readable.
+ *
+ * For update operations, use `newRecord`/`oldRecord` operands instead of `record`.
+ * @example
+ * const permission: TailorTypePermission = {
+ *   create: [{ conditions: [[{ user: "_loggedIn" }, "=", true]], permit: true }],
+ *   read: [{ conditions: [[{ record: "isPublic" }, "=", true]], permit: true }],
+ *   update: [{ conditions: [[{ newRecord: "ownerId" }, "=", { user: "id" }]], permit: true }],
+ *   delete: [{ conditions: [[{ record: "ownerId" }, "=", { user: "id" }]], permit: true }],
+ * };
+ */
+type TailorTypePermission<User extends object = InferredAttributes, Type extends object = object> = {
+  create: readonly ActionPermission<"record", User, Type, false>[];
+  read: readonly ActionPermission<"record", User, Type, false>[];
+  update: readonly ActionPermission<"record", User, Type, true>[];
+  delete: readonly ActionPermission<"record", User, Type, false>[];
+};
+type ActionPermission<Level extends "record" | "gql" = "record" | "gql", User extends object = InferredAttributes, Type extends object = object, Update extends boolean = boolean> = {
+  conditions: PermissionCondition<Level, User, Update, Type> | readonly PermissionCondition<Level, User, Update, Type>[];
+  description?: string | undefined;
+  /**
+   * Whether matching records are granted (`true`) or denied (`false`).
+   * Omitting `permit` in this object form defaults to `deny` and emits a
+   * warning; set it explicitly. (The array shorthand defaults to `allow`.)
+   */
+  permit?: boolean;
+} | readonly [...PermissionCondition<Level, User, Update, Type>, ...([] | [boolean])] | readonly [...PermissionCondition<Level, User, Update, Type>[], ...([] | [boolean])];
+type TailorTypeGqlPermission<User extends object = InferredAttributes, Type extends object = object> = readonly GqlPermissionPolicy<User, Type>[];
+type GqlPermissionPolicy<User extends object = InferredAttributes, Type extends object = object> = {
+  conditions: readonly PermissionCondition<"gql", User, boolean, Type>[];
+  actions: "all" | readonly GqlPermissionAction[];
+  /**
+   * Whether matching requests are granted (`true`) or denied (`false`).
+   * Omitting `permit` defaults to `deny` and emits a warning; set it explicitly.
+   */
+  permit?: boolean;
+  description?: string;
+};
+type GqlPermissionAction = "read" | "create" | "update" | "delete" | "aggregate" | "bulkUpsert";
+type EqualityOperator = "=" | "!=";
+type ContainsOperator = "in" | "not in";
+type HasAnyOperator = "hasAny" | "not hasAny";
+type RecordOperand<Type extends object, Update extends boolean = false> = Update extends true ? {
+  oldRecord: (keyof Type & string) | "id";
+} | {
+  newRecord: (keyof Type & string) | "id";
+} : {
+  record: (keyof Type & string) | "id";
+};
+type StringEqualityCondition<Level extends "record" | "gql", User extends object, Update extends boolean, Type extends object> = (Level extends "gql" ? readonly [string, EqualityOperator, boolean] : never) | readonly [string, EqualityOperator, string] | readonly [UserStringOperand<User>, EqualityOperator, string] | readonly [string, EqualityOperator, UserStringOperand<User>] | (Level extends "record" ? readonly [RecordOperand<Type, Update>, EqualityOperator, string | UserStringOperand<User>] | readonly [string | UserStringOperand<User>, EqualityOperator, RecordOperand<Type, Update>] : never);
+type BooleanEqualityCondition<Level extends "record" | "gql", User extends object, Update extends boolean, Type extends object> = readonly [boolean, EqualityOperator, boolean] | readonly [UserBooleanOperand<User>, EqualityOperator, boolean] | readonly [boolean, EqualityOperator, UserBooleanOperand<User>] | (Level extends "record" ? readonly [RecordOperand<Type, Update>, EqualityOperator, boolean | UserBooleanOperand<User>] | readonly [boolean | UserBooleanOperand<User>, EqualityOperator, RecordOperand<Type, Update>] : never);
+type EqualityCondition<Level extends "record" | "gql" = "record", User extends object = InferredAttributes, Update extends boolean = boolean, Type extends object = object> = StringEqualityCondition<Level, User, Update, Type> | BooleanEqualityCondition<Level, User, Update, Type>;
+type StringContainsCondition<Level extends "record" | "gql", User extends object, Update extends boolean, Type extends object> = readonly [string, ContainsOperator, string[]] | readonly [UserStringOperand<User>, ContainsOperator, string[]] | readonly [string, ContainsOperator, UserStringArrayOperand<User>] | (Level extends "record" ? readonly [RecordOperand<Type, Update>, ContainsOperator, string[] | UserStringArrayOperand<User>] | readonly [string | UserStringOperand<User>, ContainsOperator, RecordOperand<Type, Update>] : never);
+type BooleanContainsCondition<Level extends "record" | "gql", User extends object, Update extends boolean, Type extends object> = (Level extends "gql" ? readonly [string, ContainsOperator, boolean[]] : never) | readonly [boolean, ContainsOperator, boolean[]] | readonly [UserBooleanOperand<User>, ContainsOperator, boolean[]] | readonly [boolean, ContainsOperator, UserBooleanArrayOperand<User>] | (Level extends "record" ? readonly [RecordOperand<Type, Update>, ContainsOperator, boolean[] | UserBooleanArrayOperand<User>] | readonly [boolean | UserBooleanOperand<User>, ContainsOperator, RecordOperand<Type, Update>] : never);
+type ContainsCondition<Level extends "record" | "gql" = "record", User extends object = InferredAttributes, Update extends boolean = boolean, Type extends object = object> = StringContainsCondition<Level, User, Update, Type> | BooleanContainsCondition<Level, User, Update, Type>;
+type HasAnyCondition<Level extends "record" | "gql", User extends object, Update extends boolean, Type extends object> = readonly [string[] | UserStringArrayOperand<User>, HasAnyOperator, string[] | UserStringArrayOperand<User>] | (Level extends "record" ? readonly [RecordOperand<Type, Update>, HasAnyOperator, string[] | UserStringArrayOperand<User>] | readonly [string[] | UserStringArrayOperand<User>, HasAnyOperator, RecordOperand<Type, Update>] : never);
+/**
+ * Type representing a permission condition that combines user attributes, record fields, and literal values using comparison operators.
+ *
+ * The User type is extended by `tailor.d.ts`, which is automatically generated when running `tailor generate`.
+ * Attributes enabled in the config file's `auth.userProfile.attributes` (or
+ * `auth.machineUserAttributes` when userProfile is omitted) become available as types.
+ * @example
+ * ```ts
+ * // tailor.config.ts
+ * export const auth = defineAuth("my-auth", {
+ *   userProfile: {
+ *     type: user,
+ *     attributes: {
+ *       isAdmin: true,
+ *       roles: true,
+ *     }
+ *   }
+ * });
+ * ```
+ */
+type PermissionCondition<Level extends "record" | "gql" = "record", User extends object = InferredAttributes, Update extends boolean = boolean, Type extends object = object> = EqualityCondition<Level, User, Update, Type> | ContainsCondition<Level, User, Update, Type> | HasAnyCondition<Level, User, Update, Type>;
+/**
+ * Grants full record-level access without any conditions.
+ *
+ * Unsafe and intended only for local development, prototyping, or tests.
+ * Do not use this in production environments, as it effectively disables
+ * authorization checks.
+ */
+declare const unsafeAllowAllTypePermission: TailorTypePermission;
+/**
+ * Grants full GraphQL access (all actions) without any conditions.
+ *
+ * Unsafe and intended only for local development, prototyping, or tests.
+ * Do not use this in production environments, as it effectively disables
+ * authorization checks.
+ */
+declare const unsafeAllowAllGqlPermission: TailorTypeGqlPermission;
+//#endregion
+export { PermissionCondition, TailorTypeGqlPermission, TailorTypePermission, unsafeAllowAllGqlPermission, unsafeAllowAllTypePermission };

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

@@ -0,0 +1,486 @@
+import { FieldOptions, FieldOutput, FieldValidateInput, TailorFieldType, TailorToTs } from "../../types/field.types.mjs";
+import { InferredAttributes, TailorPrincipal } from "../../../runtime/types.mjs";
+import { InferFieldsOutput, TypeLevelError, output } from "../../../types/helpers.mjs";
+import { DBFieldMetadata, DefinedDBFieldMetadata, ExcludeDefaultedDBFields, ExcludeHookedDBFields, ExcludeNestedDBFields, Hook, IndexDef, RelationType, SerialConfig, TailorDBField as TailorDBField$1, TailorDBType as TailorDBType$1, TypeFeatures, TypeHook, TypeValidateFn } from "./types.mjs";
+import { AllowedValues, AllowedValuesOutput } from "../../types/field.mjs";
+import { FieldParseArgs } from "../../../runtime/field-parse.mjs";
+import { PluginConfigs } from "../../../plugin/types.mjs";
+import { TailorTypeGqlPermission, TailorTypePermission } from "./permission.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/configure/services/tailordb/schema.d.ts
+type AnyBuilderMethod = any;
+type TailorAnyDBField = Omit<TailorDBField$1<AnyBuilderMethod, AnyBuilderMethod>, "fields"> & {
+  readonly fields: Record<string, AnyBuilderMethod>;
+  _metadata: DBFieldMetadata;
+  parse: AnyBuilderMethod;
+  readonly typeName: TypeLevelError<string>;
+  description: AnyBuilderMethod;
+  relation: AnyBuilderMethod;
+  index: AnyBuilderMethod;
+  unique: AnyBuilderMethod;
+  vector: AnyBuilderMethod;
+  default: AnyBuilderMethod;
+  hooks: AnyBuilderMethod;
+  validate: AnyBuilderMethod;
+  serial: AnyBuilderMethod;
+  clone: AnyBuilderMethod;
+};
+type TailorAnyDBType = TailorDBType<any, any, any>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type DBFieldTypeNameMethod<Defined extends DefinedDBFieldMetadata> = IsAny<Defined> extends true ? TypeLevelError<string> : TypeLevelError<"typeName cannot be used on TailorDB fields">;
+type WithDBFieldDescription<Defined> = Defined & {
+  description: true;
+};
+type WithDBFieldRelation<Defined, S extends RelationType | RelationSelfConfig> = S extends "oneToOne" | "1-1" ? Defined & {
+  unique: true;
+  index: true;
+  relation: true;
+} : S extends {
+  type: "oneToOne" | "1-1";
+} ? Defined & {
+  unique: true;
+  index: true;
+  relation: true;
+} : Defined & {
+  index: true;
+  relation: true;
+};
+type WithDBFieldIndex<Defined> = Defined & {
+  index: true;
+};
+type WithDBFieldUnique<Defined> = Defined & {
+  unique: true;
+  index: true;
+};
+type WithDBFieldVector<Defined> = Defined & {
+  vector: true;
+};
+type WithDBFieldHooks<Defined, H> = Defined & {
+  hooks: {
+    create: H extends {
+      create: unknown;
+    } ? true : false;
+    update: H extends {
+      update: unknown;
+    } ? true : false;
+  };
+  serial: false;
+};
+type WithDBFieldDefault<Defined> = Defined & {
+  default: true;
+};
+type WithDBFieldValidate<Defined> = Defined & {
+  validate: true;
+};
+type WithDBFieldSerial<Defined> = Defined & {
+  serial: true;
+  hooks: {
+    create: false;
+    update: false;
+  };
+};
+type WithDBFieldCloneOptions<Defined extends DefinedDBFieldMetadata, NewOpt extends FieldOptions> = IsAny<Defined> extends true ? Defined : Omit<Defined, "array"> & {
+  array: NewOpt extends {
+    array: true;
+  } ? true : NewOpt extends {
+    array: false;
+  } ? false : Defined["array"];
+};
+type NonNullableDBFieldOutput<Output> = Exclude<Output, null>;
+type DBFieldScalarOutput<Output> = NonNullableDBFieldOutput<Output> extends (infer Item)[] ? Item : NonNullableDBFieldOutput<Output>;
+type DBFieldCloneArrayOutput<Output, NewOpt extends FieldOptions> = NewOpt extends {
+  array: true;
+} ? DBFieldScalarOutput<Output>[] : NewOpt extends {
+  array: false;
+} ? DBFieldScalarOutput<Output> : NonNullableDBFieldOutput<Output>;
+type DBFieldCloneOutput<Output, NewOpt extends FieldOptions> = NewOpt extends {
+  optional: true;
+} ? DBFieldCloneArrayOutput<Output, NewOpt> | null : NewOpt extends {
+  optional: false;
+} ? DBFieldCloneArrayOutput<Output, NewOpt> : null extends Output ? DBFieldCloneArrayOutput<Output, NewOpt> | null : DBFieldCloneArrayOutput<Output, NewOpt>;
+type DBFieldCloneOptions<Defined extends DefinedDBFieldMetadata> = Omit<FieldOptions, "array"> & {
+  array?: Defined extends {
+    validate: unknown;
+  } ? Defined["array"] : boolean;
+};
+type InvalidValidatedArrayCloneKeys<Fields extends Record<string, TailorAnyDBField>, K extends keyof Fields, Opt extends FieldOptions> = Opt extends {
+  array: infer ArrayOption;
+} ? { [P in K]: Fields[P] extends TailorDBField<infer Defined, infer _Output> ? Defined extends {
+  validate: unknown;
+} ? ArrayOption extends Defined["array"] ? never : P : never : never; }[K] : never;
+type DBFieldsCloneOptionsGuard<Fields extends Record<string, TailorAnyDBField>, K extends keyof Fields, Opt extends FieldOptions> = [InvalidValidatedArrayCloneKeys<Fields, K, Opt>] extends [never] ? unknown : TypeLevelError<"array cannot be changed on fields with custom validation">;
+type DefinedDBTypeMetadata = {
+  hooks?: true;
+  validate?: true;
+  features?: true;
+  indexes?: true;
+  files?: true;
+  permission?: true;
+  gqlPermission?: true;
+  description?: true;
+};
+type WithDBTypeMetadata<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata> = Defined & Record<Key, true>;
+type DBTypeDuplicateInputGuard<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata, Input, Message extends string> = IsAny<Defined> extends true ? Input : Defined extends Record<Key, unknown> ? TypeLevelError<Message> : Input;
+type DBTypeDuplicateRestGuard<Defined extends DefinedDBTypeMetadata, Key extends keyof DefinedDBTypeMetadata, Input extends unknown[], Message extends string> = IsAny<Defined> extends true ? Input : Defined extends Record<Key, unknown> ? [TypeLevelError<Message>, ...TypeLevelError<Message>[]] : Input;
+type FileKeyConflictError<Fields extends Record<string, TailorAnyDBField>, User extends object> = Partial<Record<keyof output<TailorDBType<Fields, User>> & string, TypeLevelError<"file keys cannot use existing field names">>>;
+type DBFieldDescriptionFn<Defined extends DefinedDBFieldMetadata, Output> = (description: string) => TailorDBField<WithDBFieldDescription<Defined>, Output>;
+type DBFieldRelationFn<Defined extends DefinedDBFieldMetadata, Output> = {
+  <S extends RelationType, T extends TailorAnyDBType>(config: RelationConfig<S, T>): TailorDBField<WithDBFieldRelation<Defined, S>, Output>;
+  <S extends RelationSelfConfig>(config: S): TailorDBField<WithDBFieldRelation<Defined, S>, Output>;
+};
+type DBFieldIndexFn<Defined extends DefinedDBFieldMetadata, Output> = () => TailorDBField<WithDBFieldIndex<Defined>, Output>;
+type DBFieldUniqueFn<Defined extends DefinedDBFieldMetadata, Output> = () => TailorDBField<WithDBFieldUnique<Defined>, Output>;
+type DBFieldVectorFn<Defined extends DefinedDBFieldMetadata, Output> = () => TailorDBField<WithDBFieldVector<Defined>, Output>;
+type DBFieldHooksFn<Defined extends DefinedDBFieldMetadata, Output> = <const H extends Hook<Output, Defined extends {
+  default: true;
+} ? Output | null | undefined : Output>>(hooks: H) => TailorDBField<WithDBFieldHooks<Defined, H>, Output>;
+type DBFieldValidateFn<Defined extends DefinedDBFieldMetadata, Output> = (...validate: FieldValidateInput<Output>[]) => TailorDBField<WithDBFieldValidate<Defined>, Output>;
+type DBFieldSerialFn<Defined extends DefinedDBFieldMetadata, Output> = (config: SerialConfig<Defined["type"] & ("integer" | "string")>) => TailorDBField<WithDBFieldSerial<Defined>, Output>;
+type DBFieldDescriptionMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldDescriptionFn<Defined, Output> : Defined extends {
+  description: unknown;
+} ? TypeLevelError<".description() has already been set"> : DBFieldDescriptionFn<Defined, Output>;
+type DBFieldRelationMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldRelationFn<Defined, Output> : Defined extends {
+  relation: unknown;
+} ? TypeLevelError<".relation() has already been set"> : DBFieldRelationFn<Defined, Output>;
+type DBFieldArrayCheck<A extends boolean, Ok, Msg extends string> = A extends true ? TypeLevelError<Msg> : Ok;
+type DBFieldIndexMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldIndexFn<Defined, Output> : Defined extends {
+  index: unknown;
+} ? TypeLevelError<".index() has already been set"> : DBFieldArrayCheck<Defined["array"], DBFieldIndexFn<Defined, Output>, "index cannot be set on array fields">;
+type DBFieldUniqueMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldUniqueFn<Defined, Output> : Defined extends {
+  unique: unknown;
+} ? TypeLevelError<".unique() has already been set"> : DBFieldArrayCheck<Defined["array"], DBFieldUniqueFn<Defined, Output>, "unique cannot be set on array fields">;
+type DBFieldVectorMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldVectorFn<Defined, Output> : Defined extends {
+  vector: unknown;
+} ? TypeLevelError<".vector() has already been set"> : Defined extends {
+  type: "string";
+  array: false;
+} ? DBFieldVectorFn<Defined, Output> : TypeLevelError<"vector can only be set on non-array string fields">;
+type DBFieldHooksMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldHooksFn<Defined, Output> : Defined extends {
+  serial: true;
+  hooks: {
+    create: false;
+    update: false;
+  };
+} ? TypeLevelError<"hooks cannot be set after serial"> : Defined extends {
+  hooks: unknown;
+} ? TypeLevelError<".hooks() has already been set"> : Defined extends {
+  type: "nested";
+} ? TypeLevelError<"hooks cannot be set on nested type fields"> : DBFieldHooksFn<Defined, Output>;
+type DBFieldValidateMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldValidateFn<Defined, Output> : Defined extends {
+  validate: unknown;
+} ? TypeLevelError<".validate() has already been set"> : DBFieldValidateFn<Defined, Output>;
+type DBFieldSerialMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldSerialFn<Defined, Output> : Defined extends {
+  serial: true;
+} ? TypeLevelError<".serial() has already been set"> : Defined extends {
+  serial: false;
+} ? TypeLevelError<"serial cannot be set after hooks"> : IsAny<Output> extends true ? Defined extends {
+  type: "integer" | "string";
+  array: false;
+} ? DBFieldSerialFn<Defined, Output> : TypeLevelError<"serial can only be set on non-array integer or string fields"> : null extends Output ? TypeLevelError<"serial can only be set on non-array integer or string fields"> : Defined extends {
+  type: "integer" | "string";
+  array: false;
+} ? DBFieldSerialFn<Defined, Output> : TypeLevelError<"serial can only be set on non-array integer or string fields">;
+type DBFieldDefaultFn<Defined extends DefinedDBFieldMetadata, Output> = (value: Output extends null ? NonNullable<Output> : Output) => TailorDBField<WithDBFieldDefault<Defined>, Output>;
+type DBFieldDefaultMethod<Defined extends DefinedDBFieldMetadata, Output> = IsAny<Defined> extends true ? DBFieldDefaultFn<Defined, Output> : Defined extends {
+  default: unknown;
+} ? TypeLevelError<".default() has already been set"> : Defined extends {
+  type: "nested";
+} ? TypeLevelError<"default cannot be set on nested type fields"> : Defined extends {
+  serial: true;
+} ? TypeLevelError<"default cannot be set on serial fields"> : null extends Output ? TypeLevelError<"default cannot be set on optional fields"> : DBFieldDefaultFn<Defined, Output>;
+/**
+ * Full TailorDBField interface with builder methods.
+ * Extends the minimal structural interface from types/ with fluent API methods.
+ */
+interface TailorDBField<Defined extends DefinedDBFieldMetadata = DefinedDBFieldMetadata, Output = any> extends Omit<TailorDBField$1<Defined, Output>, "fields"> {
+  readonly fields: Record<string, TailorAnyDBField>;
+  _metadata: DBFieldMetadata;
+  /**
+   * Parse and validate a value against this field's validation rules
+   */
+  parse(args: FieldParseArgs): StandardSchemaV1.Result<Output>;
+  /**
+   * typeName is not available on TailorDB fields.
+   * Use typeName on pipeline fields (t.enum / t.object) instead.
+   */
+  typeName: DBFieldTypeNameMethod<Defined>;
+  /**
+   * Set a description for the field
+   */
+  description: DBFieldDescriptionMethod<Defined, Output>;
+  /**
+   * Define a relation to another type.
+   */
+  relation: DBFieldRelationMethod<Defined, Output>;
+  /**
+   * Add an index to the field
+   */
+  index: DBFieldIndexMethod<Defined, Output>;
+  /**
+   * Make the field unique (also adds an index)
+   */
+  unique: DBFieldUniqueMethod<Defined, Output>;
+  /**
+   * Enable vector search on the field (string type only)
+   */
+  vector: DBFieldVectorMethod<Defined, Output>;
+  /**
+   * Set a default value for the field on create. When the field is required,
+   * this makes it optional in the Create input — the default fills in when
+   * no value (or a nullish hook result) is provided.
+   *
+   * For datetime/date/time fields, pass `"now"` to use the operation timestamp.
+   */
+  default: DBFieldDefaultMethod<Defined, Output>;
+  /**
+   * Add hooks for create/update operations on this field.
+   */
+  hooks: DBFieldHooksMethod<Defined, Output>;
+  /**
+   * Add validation functions to the field.
+   *
+   * Validators receive `{ value, data, user }` and run after hooks and
+   * built-in type validation; they are skipped when built-in validation
+   * fails. For array fields, `value` is the complete array.
+   */
+  validate: DBFieldValidateMethod<Defined, Output>;
+  /**
+   * Configure serial/auto-increment behavior
+   */
+  serial: DBFieldSerialMethod<Defined, Output>;
+  /**
+   * Clone the field with optional overrides for field options.
+   * The `array` option cannot change on fields with custom validation.
+   */
+  clone<const NewOpt extends DBFieldCloneOptions<Defined>>(options?: NewOpt): TailorDBField<WithDBFieldCloneOptions<Defined, NewOpt>, DBFieldCloneOutput<Output, NewOpt>>;
+}
+/**
+ * Full TailorDBType interface with builder methods.
+ * Extends the minimal structural interface from types/ with fluent API methods.
+ */
+interface TailorDBType<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes, Defined extends DefinedDBTypeMetadata = any> extends TailorDBType$1<Fields, User> {
+  _description?: string;
+  hooks(hook: DBTypeDuplicateInputGuard<Defined, "hooks", TypeHook<Fields>, ".hooks() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "hooks">>;
+  validate(fn: DBTypeDuplicateInputGuard<Defined, "validate", TypeValidateFn<Fields>, ".validate() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "validate">>;
+  features(features: DBTypeDuplicateInputGuard<Defined, "features", Omit<TypeFeatures, "pluralForm">, ".features() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "features">>;
+  indexes(...indexes: DBTypeDuplicateRestGuard<Defined, "indexes", IndexDef<TailorDBType<Fields, User, Defined>>[], ".indexes() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "indexes">>;
+  files<const F extends string>(files: DBTypeDuplicateInputGuard<Defined, "files", Record<F, string> & FileKeyConflictError<Fields, User>, ".files() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "files">>;
+  permission<U extends object = User, P extends TailorTypePermission<U, output<TailorDBType<Fields, User, Defined>>> = TailorTypePermission<U, output<TailorDBType<Fields, User, Defined>>>>(permission: DBTypeDuplicateInputGuard<Defined, "permission", P, ".permission() has already been set">): TailorDBType<Fields, U, WithDBTypeMetadata<Defined, "permission">>;
+  gqlPermission<U extends object = User, P extends TailorTypeGqlPermission<U> = TailorTypeGqlPermission<U>>(permission: DBTypeDuplicateInputGuard<Defined, "gqlPermission", P, ".gqlPermission() has already been set">): TailorDBType<Fields, U, WithDBTypeMetadata<Defined, "gqlPermission">>;
+  description(description: DBTypeDuplicateInputGuard<Defined, "description", string, ".description() has already been set">): TailorDBType<Fields, User, WithDBTypeMetadata<Defined, "description">>;
+  pickFields<K extends keyof Fields>(keys: K[]): Pick<Fields, K>;
+  pickFields<K extends keyof Fields, const Opt extends FieldOptions>(keys: K[], options: Opt & DBFieldsCloneOptionsGuard<Fields, K, Opt>): { [P in K]: Fields[P] extends TailorDBField<infer D, infer O> ? TailorDBField<WithDBFieldCloneOptions<D, Opt>, DBFieldCloneOutput<O, Opt>> : never; };
+  omitFields<K extends keyof Fields>(keys: K[]): Omit<Fields, K>;
+  plugin<P extends keyof PluginConfigs<keyof Fields & string>>(config: { [K in P]: PluginConfigs<keyof Fields & string>[K]; }): TailorDBType<Fields, User, Defined>;
+}
+type TailorDBInstance<Fields extends Record<string, TailorAnyDBField> = any, User extends object = InferredAttributes, Defined extends DefinedDBTypeMetadata = any> = TailorDBType<Fields, User, Defined>;
+interface RelationConfig<S extends RelationType, T extends TailorDBType> {
+  type: S;
+  toward: {
+    type: T;
+    as?: string;
+    key?: keyof T["fields"] & string;
+  };
+  backward?: string;
+}
+type RelationSelfConfig = {
+  type: RelationType;
+  toward: {
+    type: "self";
+    as?: string;
+    key?: string;
+  };
+  backward?: string;
+};
+type DBFieldDefined<T extends TailorFieldType, Opt extends FieldOptions> = {
+  type: T;
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+};
+type DBFieldOutput<T extends TailorFieldType, Opt extends FieldOptions, OutputBase = TailorToTs[T]> = FieldOutput<OutputBase, Opt>;
+type TailorDBFieldInstance<T extends TailorFieldType, Opt extends FieldOptions, OutputBase = TailorToTs[T]> = TailorDBField<DBFieldDefined<T, Opt>, DBFieldOutput<T, Opt, OutputBase>>;
+/**
+ * Create a UUID field.
+ * @param options - Field configuration options
+ * @returns A UUID field
+ * @example db.uuid()
+ * @example db.uuid({ optional: true })
+ */
+declare function uuid<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"uuid", Opt, string>;
+/**
+ * Create a string field.
+ * @param options - Field configuration options
+ * @returns A string field
+ * @example db.string()
+ * @example db.string({ optional: true })
+ */
+declare function string<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"string", Opt, string>;
+/**
+ * Create a boolean field.
+ * Note: The method name is `bool` but creates a `boolean` type field.
+ * @param options - Field configuration options
+ * @returns A boolean field
+ * @example db.bool()
+ * @example db.bool({ optional: true })
+ */
+declare function bool<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"boolean", Opt, boolean>;
+/**
+ * Create an integer field.
+ * @param options - Field configuration options
+ * @returns An integer field
+ * @example db.int()
+ * @example db.int({ optional: true })
+ */
+declare function int<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"integer", Opt, number>;
+/**
+ * Create a float (decimal number) field.
+ * @param options - Field configuration options
+ * @returns A float field
+ * @example db.float()
+ * @example db.float({ optional: true })
+ */
+declare function float<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"float", Opt, number>;
+interface DecimalFieldOptions extends FieldOptions {
+  scale?: number;
+}
+/**
+ * Create a decimal field (stored as string for precision).
+ * @param options - Field configuration options including optional scale (0-12)
+ * @returns A decimal field
+ * @example db.decimal()
+ * @example db.decimal({ scale: 2 })
+ * @example db.decimal({ scale: 2, optional: true })
+ */
+declare function decimal<const Opt extends DecimalFieldOptions>(options?: Opt): TailorDBFieldInstance<"decimal", Opt, string>;
+/**
+ * Create a date field (date only, no time component).
+ * Format: "yyyy-MM-dd"
+ * @param options - Field configuration options
+ * @returns A date field
+ * @example db.date()
+ */
+declare function date<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"date", Opt, string>;
+/**
+ * Create a datetime field (date and time).
+ * Format: ISO 8601, such as "yyyy-MM-ddTHH:mm:ssZ" or "yyyy-MM-ddTHH:mm:ss+09:00"
+ * @param options - Field configuration options
+ * @returns A datetime field
+ * @example db.datetime()
+ */
+declare function datetime<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"datetime", Opt, string | Date>;
+/**
+ * Create a time field (time only, no date component).
+ * Format: "HH:mm"
+ * @param options - Field configuration options
+ * @returns A time field
+ * @example db.time()
+ */
+declare function time<const Opt extends FieldOptions>(options?: Opt): TailorDBFieldInstance<"time", Opt, string>;
+/**
+ * Create an enum field with a fixed set of allowed string values.
+ * @param values - Array of allowed string values, or array of `{ value, description }` objects
+ * @param options - Field configuration options
+ * @returns An enum field
+ * @example db.enum(["active", "inactive", "suspended"])
+ * @example db.enum(["small", "medium", "large"], { optional: true })
+ */
+declare function _enum<const V extends AllowedValues, const Opt extends FieldOptions>(values: V, options?: Opt): TailorDBField<{
+  type: "enum";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, FieldOutput<AllowedValuesOutput<V>, Opt>>;
+/**
+ * Create a nested object field with sub-fields.
+ * @param fields - Record of nested field definitions
+ * @param options - Field configuration options
+ * @returns A nested object field
+ * @example db.object({ street: db.string(), city: db.string(), zip: db.string() })
+ * @example db.object({ name: db.string() }, { optional: true })
+ */
+declare function object<const F extends Record<string, TailorAnyDBField> & ExcludeNestedDBFields<F> & ExcludeHookedDBFields<F> & ExcludeDefaultedDBFields<F>, const Opt extends FieldOptions>(fields: F, options?: Opt): TailorDBField<{
+  type: "nested";
+  array: Opt extends {
+    array: true;
+  } ? true : false;
+}, FieldOutput<InferFieldsOutput<F>, Opt>>;
+declare const idField: TailorDBFieldInstance<"uuid", FieldOptions, string>;
+type idField = typeof idField;
+type DBTable<F extends {
+  id?: never;
+} & Record<string, TailorAnyDBField>, Defined extends DefinedDBTypeMetadata = DefinedDBTypeMetadata> = TailorDBInstance<{
+  id: idField;
+} & F, InferredAttributes, Defined>;
+/**
+ * Creates a new database table with the specified fields.
+ * An `id` field (UUID) is automatically added to every table.
+ * @param name - The name of the table, or a tuple of [name, pluralForm]
+ * @param fields - The field definitions for the table
+ * @returns A new TailorDB table instance
+ * @example
+ * export const user = db.table("User", {
+ *   name: db.string(),
+ *   email: db.string(),
+ *   age: db.int({ optional: true }),
+ *   role: db.enum(["admin", "member"]),
+ *   ...db.fields.timestamps(),
+ * });
+ * // Always export both the value and type:
+ * export type user = typeof user;
+ */
+declare function dbTable<const F extends {
+  id?: never;
+} & Record<string, TailorAnyDBField>>(name: string | [string, string], fields: F): DBTable<F>;
+/**
+ * Creates a new database table with the specified fields and description.
+ * An `id` field (UUID) is automatically added to every table.
+ * @param name - The name of the table, or a tuple of [name, pluralForm]
+ * @param description - A description of the table
+ * @param fields - The field definitions for the table
+ * @returns A new TailorDB table instance
+ */
+declare function dbTable<const F extends {
+  id?: never;
+} & Record<string, TailorAnyDBField>>(name: string | [string, string], description: string, fields: F): DBTable<F, WithDBTypeMetadata<DefinedDBTypeMetadata, "description">>;
+/** TailorDB schema builder utilities for defining tables and fields. */
+declare const db: {
+  table: typeof dbTable;
+  uuid: typeof uuid;
+  string: typeof string;
+  bool: typeof bool;
+  int: typeof int;
+  float: typeof float;
+  decimal: typeof decimal;
+  date: typeof date;
+  datetime: typeof datetime;
+  time: typeof time;
+  enum: typeof _enum;
+  object: typeof object;
+  fields: {
+    /**
+     * Creates standard timestamp fields (createdAt, updatedAt) with automatic defaults.
+     * Both fields default to the current time on create. updatedAt is also refreshed on update.
+     * User-specified values are respected when provided (e.g. seeding historical records).
+     * @returns An object with createdAt and updatedAt fields
+     * @example
+     * const model = db.table("Model", {
+     *   name: db.string(),
+     *   ...db.fields.timestamps(),
+     * });
+     */
+    timestamps: () => {
+      createdAt: TailorDBField<WithDBFieldDescription<WithDBFieldDefault<DBFieldDefined<"datetime", FieldOptions>>>, string | Date>;
+      updatedAt: TailorDBField<WithDBFieldDescription<WithDBFieldHooks<WithDBFieldDefault<DBFieldDefined<"datetime", FieldOptions>>, {
+        readonly update: ({ input, now }: {
+          input: string | Date | null;
+          oldValue: string | Date;
+          invoker: TailorPrincipal | null;
+          now: Date;
+        }) => string | Date;
+      }>>, string | Date>;
+    };
+  };
+};
+//#endregion
+export { TailorAnyDBField, TailorAnyDBType, TailorDBField, TailorDBInstance, TailorDBType, db };