@stacksjs/orm 0.70.45 → 0.70.53

package/dist/src/auto-crud.d.ts

@@ -0,0 +1,225 @@
+/**
+ * True when the error is a unique-constraint violation, across SQLite,
+ * MySQL, and Postgres:
+ *
+ * - SQLite: `SQLITE_CONSTRAINT_UNIQUE` / `SQLITE_CONSTRAINT`
+ * - MySQL: `errno: 1062` (ER_DUP_ENTRY)
+ * - Postgres: `code: '23505'` (unique_violation)
+ * - Generic fallback: message text match — covers wrapped errors from drivers
+ *   that lose the structured code.
+ *
+ * Lives here (cycle-free `@stacksjs/orm`) rather than in `@stacksjs/auth`
+ * because every framework write path needs it: auto-CRUD routes, commerce/cms
+ * write functions, and `@stacksjs/auth`'s `register()` (which re-exports this
+ * via './rbac-store-bqb' for back-compat). `@stacksjs/database` is NOT a valid
+ * home — its drivers statically import `@stacksjs/orm`, so orm routes importing
+ * from database would create a package cycle.
+ *
+ * Exported for direct unit testing and for callers that map duplicates to
+ * their own error (e.g. `register()`'s 409) instead of swallowing them.
+ */
+export declare function isUniqueViolation(err: unknown): boolean;
+/**
+ * Classify a write-path error into an HTTP status + JSON body for the
+ * auto-CRUD store/update handlers. Three branches, in priority order:
+ *
+ * 1. HttpError-like (an Error carrying an integer `status` in 400-599) —
+ *    preserve its status, message and optional `details`. Duck-typed rather
+ *    than `instanceof HttpError` so this helper stays inline-copyable into the
+ *    canonical generated routes file without importing @stacksjs/error-handling.
+ *    Covers the 400/413/422 throws from getRequestBody / validation.
+ * 2. Unique-constraint violation — 409 with a clean `${Model} already exists`
+ *    message (NO raw driver text, which would leak column names in prod).
+ * 3. Anything else — the unchanged 500 contract, including `detail: String(err)`.
+ */
+export declare function mapWriteError(err: unknown, modelName: string, op: 'create' | 'update'): { status: number, body: Record<string, unknown> };
+/**
+ * Attribute names in model definitions may be camelCase; the migration
+ * drivers (database/src/drivers/{sqlite,mysql,postgres}.ts) snake_case them
+ * into column names. Write payload keys must be mapped the same way, LAST on
+ * the write path — fillable filtering, validation, set-hooks and casts are
+ * all keyed by attribute name. Output-identical to @stacksjs/strings
+ * snakeCase for word-shaped attribute names (locked in by tests).
+ */
+export declare function toSnakeCase(s: string): string;
+/** Map every key of a write payload to its snake_case column spelling. */
+export declare function toSnakeCaseKeys(data: Record<string, any>): Record<string, any>;
+/**
+ * Filter a request body down to fillable fields. Accepts BOTH the
+ * attribute-name spelling and its snake_case column spelling on input, so
+ * read-modify-write round-trips work (GET responses expose snake_case
+ * columns). The result stays keyed by attribute name — setters, casts and
+ * validation rules all look fields up by that spelling.
+ */
+export declare function filterFillable(body: any, fillableFields: string[]): Record<string, any>;
+/**
+ * Drop attribute keys flagged `hidden: true` from an incoming write body.
+ * Must drop BOTH spellings — accepting the snake spelling in filterFillable
+ * without this would let `payment_intent_id` sneak past a camelCase hidden
+ * marker.
+ */
+export declare function dropHiddenInputs(data: Record<string, any>, hiddenFields: string[]): Record<string, any>;
+/**
+ * Strip attribute keys flagged `hidden: true` from an outgoing response
+ * record. Must drop BOTH spellings — DB rows come back keyed by snake_case
+ * column names, so deleting only the attribute-name spelling lets a
+ * camelCase hidden attribute (Transaction's `paymentDetails`) leak as
+ * `payment_details` on public reads. Response-side mirror of
+ * `dropHiddenInputs`.
+ */
+export declare function stripHidden(record: any, hiddenFields: string[]): any;
+/**
+ * Build the read-path column allowlist for a model: a map from BOTH the
+ * attribute-name spelling and its snake_case column spelling to the real
+ * snake_case column. One map serves `?sort=` and `?<column>=` filters.
+ *
+ * Why a map and not a set: attribute names may be camelCase
+ * (`discountType`) while DB columns are always snake_case (the migration
+ * drivers snake_case them — same contract as `toSnakeCaseKeys` on the
+ * write path). A set keyed by attribute spelling let `?sort=discountType`
+ * through to `orderBy('discountType')` (ghost column → 500) while
+ * REJECTING the real column spelling `discount_type`. The map accepts
+ * either spelling and always emits the column spelling.
+ *
+ * Hidden attributes are removed under BOTH spellings — sorting or
+ * equality-filtering on a hidden column (`?two_factor_secret=x`) is a
+ * blind-enumeration oracle even though the value never appears in the
+ * response body.
+ */
+export declare function buildReadColumnMap(attributes: Record<string, unknown> | null | undefined, hiddenFields: string[]): Map<string, string>;
+/**
+ * Apply a `?sort=` parameter to a query builder chain. Comma-separated
+ * tokens, each optionally `-` prefixed for descending. Tokens are resolved
+ * through the `columns` allowlist map (see `buildReadColumnMap`) so either
+ * spelling of a declared, non-hidden attribute works and everything else —
+ * unknown names, hidden attributes, non-word tokens — is silently skipped
+ * (the existing contract, matching the filter loop).
+ *
+ * Examples:
+ *   ?sort=name              → ORDER BY name ASC
+ *   ?sort=-rating           → ORDER BY rating DESC
+ *   ?sort=discountType,name → ORDER BY discount_type ASC, name ASC
+ */
+export declare function applySorting(query: any, sortParam: string | null, columns: ReadonlyMap<string, string>): any;
+/**
+ * Apply a model's `casts` to a record, in either direction:
+ *   - `'get'`  — DB shape → JS-typed values (read responses)
+ *   - `'set'`  — input → DB shape (write payloads)
+ *
+ * Casts are declared keyed by attribute name (possibly camelCase:
+ * `instantBook: 'boolean'`) but DB rows come back keyed by snake_case
+ * column names (`instant_book`) — so each cast is applied under BOTH
+ * spellings, whichever is present. A record keyed by attribute names
+ * (the write path) behaves exactly as before; a snake-keyed DB row (the
+ * read path) now gets its casts instead of leaking raw SQLite `"1"`s.
+ */
+export declare function applyCasts(record: Record<string, any> | null | undefined, casts: Record<string, string | { get: (v: unknown) => unknown, set: (v: unknown) => unknown }> | null | undefined, direction: 'get' | 'set'): any;
+/**
+ * Resolve middleware lists for a model's `useApi` trait value (which may be
+ * `true` or `{ uri, routes, middleware }`).
+ *
+ * Secure-by-default: mutating routes (store/update/destroy) get `auth`
+ * unless the model explicitly declares `useApi.middleware` — an explicit
+ * `middleware: []` is a deliberate opt-out and is honored (with a startup
+ * warning at the call site). Read routes stay public unless declared.
+ */
+export declare function resolveApiMiddleware(useApi: unknown): { read: string[], write: string[], declared: boolean };
+/**
+ * Resolve `?page=` / `?per_page=` for the index route into a clamped,
+ * NaN-safe `{ page, perPage, offset }`.
+ *
+ * - `page` is clamped to `>= 1` (a `?page=0` / negative would otherwise
+ *   produce a negative OFFSET), defaulting to 1 on missing/NaN.
+ * - `perPage` defaults to {@link INDEX_DEFAULT_PER_PAGE}, is clamped to
+ *   `>= 1`, and capped at {@link INDEX_MAX_PER_PAGE}.
+ */
+export declare function resolveIndexPageArgs(params: URLSearchParams): { page: number, perPage: number, offset: number };
+/**
+ * Build the index pagination `meta`. `hasMore` is the source of truth for
+ * "is there a next page" (derived by the route from a `LIMIT perPage + 1`
+ * probe fetch), so `next_page_url` stays consistent whether or not a total
+ * was counted. When `total` is known, `last_page` uses the
+ * `Math.max(1, ceil(total / perPage))` floor from the Paginator interface.
+ */
+export declare function buildIndexMeta(url: URL, page: number, perPage: number, rowCount: number, hasMore: boolean, total?: number): IndexPageMeta;
+/**
+ * Flat Laravel paginator shape for the index response top level. Same values
+ * as {@link buildIndexMeta} but keyed `current_page` (not `page`) so a
+ * generated-endpoint list response deep-equals a `Model.paginate()` envelope.
+ * The `page` -> `current_page` rename is the only delta; the value math lives
+ * solely in `buildIndexMeta`.
+ */
+export declare function buildIndexPaginator(url: URL, page: number, perPage: number, rowCount: number, hasMore: boolean, total?: number): IndexPaginator;
+/**
+ * Columns every auto-CRUD table carries regardless of declared attributes.
+ * Members of the read allowlist (sort/filter) alongside the model's own
+ * attribute names.
+ * @defaultValue `['id', 'uuid', 'created_at', 'updated_at', 'deleted_at']`
+ */
+export declare const SYSTEM_COLUMNS: string[];
+/**
+ * Built-in cast resolvers — kept in sync with @stacksjs/orm/define-model.
+ * A duplicate here is the simplest way to keep auto-CRUD parity with the
+ * model-driven path without introducing a circular import.
+ */
+export declare const AUTO_CRUD_CASTERS: {
+  string: { get: (v) => unknown; set: (v) => unknown };
+  number: { get: (v) => unknown; set: (v) => unknown };
+  integer: { get: (v) => unknown; set: (v) => unknown };
+  float: { get: (v) => unknown; set: (v) => unknown };
+  boolean: { get: (v) => unknown; set: (v) => unknown };
+  json: { get: (v) => unknown; set: (v) => unknown };
+  datetime: { get: (v) => unknown; set: (v) => unknown };
+  date: { get: (v) => unknown; set: (v) => unknown };
+  array: { get: (v) => unknown; set: (v) => unknown }
+};
+// Default page size for the auto-CRUD index route. Matches the
+// request-aware Model.paginate() / resolvePageArgs default (15) so the
+// REST list endpoint and the in-process paginator agree out of the box.
+export declare const INDEX_DEFAULT_PER_PAGE: 15;
+// Upper bound on ?per_page= so a single request can't ask for an
+// unbounded page and exhaust memory.
+export declare const INDEX_MAX_PER_PAGE: 100;
+/**
+ * Pagination `meta` for the auto-CRUD index envelope (`{ data, meta }`).
+ *
+ * Always carries `page` / `per_page` / `from` / `to` / `has_more_pages`
+ * plus `prev_page_url` / `next_page_url`. `total` / `last_page` and the
+ * `first_page_url` / `last_page_url` are added only when a total is known
+ * (`?with_count=true`).
+ */
+export declare interface IndexPageMeta {
+  page: number
+  per_page: number
+  from: number | null
+  to: number | null
+  has_more_pages: boolean
+  prev_page_url: string | null
+  next_page_url: string | null
+  total?: number
+  last_page?: number
+  first_page_url?: string
+  last_page_url?: string
+}
+/**
+ * Flat Laravel paginator shape lifted to the index response top level.
+ * Mirrors {@link IndexPageMeta} minus `data`/`path` (the route spreads this
+ * alongside its own `data`), but keys the current page as `current_page`
+ * instead of `page` so a generated-endpoint list response deep-equals a
+ * `Model.paginate()` envelope. `total` / `last_page` / `first_page_url` /
+ * `last_page_url` stay gated on `total` (`?with_count=true`), matching
+ * {@link SimplePaginator} when absent.
+ */
+export declare interface IndexPaginator {
+  current_page: number
+  per_page: number
+  from: number | null
+  to: number | null
+  has_more_pages: boolean
+  prev_page_url: string | null
+  next_page_url: string | null
+  total?: number
+  last_page?: number
+  first_page_url?: string
+  last_page_url?: string
+}

package/dist/src/define-model.d.ts

@@ -1,4 +1,3 @@
-import type { InferRelationNames } from 'bun-query-builder';
 import { createBillableMethods } from './traits/billable';
 import { createCategorizableMethods } from './traits/categorizable';
 import { createCommentableMethods } from './traits/commentable';
@@ -6,8 +5,22 @@ import { createLikeableMethods } from './traits/likeable';
 import { createSoftDeleteMethods } from './traits/soft-deletes';
 import { createTaggableMethods } from './traits/taggable';
 import { createTwoFactorMethods } from './traits/two-factor';
+import type { InferRelationNames } from '@stacksjs/query-builder';
 // Re-export types from bun-query-builder for convenience
-export type { ModelDefinition, InferRelationNames, ModelAttributes, InferModelAttributes, SystemFields, ColumnName, AttributeKeys, FillableKeys, HiddenKeys, ModelInstance, ModelQueryBuilder } from 'bun-query-builder';
+export type { ModelDefinition, InferRelationNames, ModelAttributes, InferModelAttributes, SystemFields, ColumnName, AttributeKeys, FillableKeys, HiddenKeys, ModelInstance, ModelQueryBuilder } from '@stacksjs/query-builder';
+/**
+ * Run a callback with model lifecycle events suppressed for its entire
+ * (synchronous + async) duration. Any nested awaits inside the callback
+ * inherit the suppression via the AsyncLocalStorage propagation.
+ *
+ * @example
+ * ```ts
+ * await User.withoutEvents(async () => {
+ *   for (const row of importedRows) await User.create(row) // no events fire
+ * })
+ * ```
+ */
+export declare function withoutEvents<T>(fn: () => T | Promise<T>): Promise<T>;
 /**
  * Stacks-enhanced model definition.
  *
@@ -81,7 +94,7 @@ declare interface StacksModelDefinition {
   primaryKey?: string
   autoIncrement?: boolean
   traits?: Record<string, unknown>
-  indexes?: Array<{ name: string, columns: string[] }>
+  indexes?: Array<{ name: string, columns: string[], unique?: boolean, where?: string }>
   casts?: Record<string, CastType | CasterInterface>
   attributes: {
     [key: string]: {
@@ -102,6 +115,27 @@ export declare interface TraitMethods {
 }
 /**
  * Built-in cast types for model attributes.
+ *
+ * ### Timezone contract (stacksjs/stacks#1876 O-5, D-5)
+ *
+ * `datetime` and `date` casts persist values in **UTC** regardless of
+ * which driver is connected. The `set` direction uses
+ * `Date.toISOString()`, which always emits `Z`-suffixed UTC. The
+ * `get` direction parses the stored string back into a JavaScript
+ * `Date`, which represents an instant on the universal timeline —
+ * timezone presentation is the caller's responsibility (typically via
+ * `Intl.DateTimeFormat` at the render layer, or a Temporal-API
+ * adapter).
+ *
+ * **Why UTC-only:** Per-driver behavior diverges sharply on
+ * timezone-aware columns. PostgreSQL has `timestamptz` (timezone-
+ * aware); MySQL stores `TIMESTAMP` as UTC but presents in the
+ * session timezone; SQLite has no timezone concept at all and stores
+ * ISO strings verbatim. The ORM normalizes them to a single
+ * convention (UTC on the wire) so multi-driver apps behave the same
+ * across environments. Apps that need original-timezone preservation
+ * should store the user's TZ as a separate column and convert at
+ * the render layer.
  */
 export type CastType = 'string' | 'number' | 'boolean' | 'json' | 'datetime' | 'date' | 'array' | 'integer' | 'float';
 declare type ModelDefinition = StacksModelDefinition;
@@ -114,3 +148,25 @@ export declare class ModelNotFoundError extends Error {
   readonly id: number | string | undefined;
   constructor(model: string, id?: number | string);
 }
+/**
+ * Thrown when a write payload (`Model.create` / `Model.update` /
+ * `firstOrCreate` / `updateOrCreate`) contains an attribute the model
+ * forbids from mass assignment. There are two reasons this fires:
+ *
+ *   • `guarded`  — the attribute is explicitly marked `guarded: true`.
+ *   • `not-fillable` — the model is in *allowlist* mode (at least one
+ *     attribute has `fillable: true`) and the write payload contains a
+ *     non-allowlisted field.
+ *
+ * The check exists to stop unfiltered request payloads from landing
+ * directly in the DB. If you genuinely need to write a normally-protected
+ * column, use the `force*` escape hatches (`Model.forceCreate(...)`,
+ * `Model.forceUpdate(id, ...)`) — those bypass the check by design and
+ * make the bypass auditable in code review.
+ */
+export declare class MassAssignmentException extends Error {
+  readonly model: string;
+  readonly attribute: string;
+  readonly reason: 'guarded' | 'not-fillable';
+  constructor(model: string, attribute: string, reason: 'guarded' | 'not-fillable');
+}

package/dist/src/generate-database-schema.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Walk userland + framework-default models, return the rendered
+ * `database/types.d.ts` content plus a structured per-table summary
+ * the CLI can render.
+ */
+export declare function buildDatabaseSchema(options?: GenerateSchemaOptions): Promise<GenerateSchemaResult>;
+/**
+ * Pure renderer — for tests that don't want to round-trip through the
+ * model loader.
+ */
+export declare function renderDatabaseTypeFile(tables: Array<{ table: string, columns: Record<string, string> }>): string;
+export declare interface GenerateSchemaOptions {
+  modelsDir?: string
+  defaultsDir?: string
+  outFile?: string
+  dryRun?: boolean
+}
+export declare interface GenerateSchemaResult {
+  outFile: string
+  tables: Array<{ table: string, model: string, columns: Record<string, string> }>
+  errors: Array<{ file: string, error: string }>
+  content: string
+}

package/dist/src/index.d.ts

@@ -3,6 +3,9 @@ export type { PrunableOptions } from './utils/prunable';
 export type { AuditHelpers } from './traits/audit';
 // Re-export soft-delete option types so user code can `satisfies SoftDeleteOptions`.
 export type { SoftDeleteOptions, SoftDeleteHelpers } from './traits/soft-deletes';
+export type { GenerateSchemaOptions, GenerateSchemaResult } from './generate-database-schema';
+export type { CursorPaginator, Paginator, SimplePaginator } from './paginator';
+export type { ResolvedPageArgs } from './paginator-request';
 // Re-export type utilities from bun-query-builder so consumers can infer
 // model types directly from defineModel() definitions
 export type {
@@ -11,71 +14,120 @@ export type {
   InferRelationNames,
   InferTableName,
   ModelDefinition,
-} from 'bun-query-builder';
-export declare const User: unknown;
-// Same lazy-export pattern for the two queue framework models. The CLI
-// commands `buddy queue:status`, `queue:failed`, `queue:flush`,
-// `queue:inspect`, `queue:monitor`, `queue:clear` import them as
-// `import { Job, FailedJob } from '@stacksjs/orm'`. Prefer the userland
-// publication (`app/Models/Job.ts`, dropped in by `buddy publish:model
-// Job`) so projects that customize the queue model — renamed columns,
-// extra observers, custom traits — see their version.
-export declare const Job: unknown;
-export declare const FailedJob: unknown;
-export declare const Activity: unknown;
-export declare const Author: unknown;
-export declare const Campaign: unknown;
-export declare const Cart: unknown;
-export declare const CartItem: unknown;
-export declare const Category: unknown;
-export declare const Comment: unknown;
-export declare const Coupon: unknown;
-export declare const Customer: unknown;
-export declare const DeliveryRoute: unknown;
-export declare const Deployment: unknown;
-export declare const DigitalDelivery: unknown;
-export declare const Driver: unknown;
-export declare const CampaignSend: unknown;
-export declare const EmailList: unknown;
-export declare const EmailListSubscriber: unknown;
-export declare const ErrorModel: unknown;
-export declare const GiftCard: unknown;
-export declare const LicenseKey: unknown;
-export declare const Log: unknown;
-export declare const LoyaltyPoint: unknown;
-export declare const LoyaltyReward: unknown;
-export declare const Manufacturer: unknown;
-export declare const Notification: unknown;
-export declare const Order: unknown;
-export declare const OrderItem: unknown;
-export declare const Page: unknown;
-export declare const Payment: unknown;
-export declare const PaymentMethod: unknown;
-export declare const PaymentProduct: unknown;
-export declare const PaymentTransaction: unknown;
-export declare const Post: unknown;
-export declare const PrintDevice: unknown;
-export declare const Product: unknown;
-export declare const ProductUnit: unknown;
-export declare const ProductVariant: unknown;
-export declare const Receipt: unknown;
-export declare const Release: unknown;
-export declare const Request: unknown;
-export declare const Review: unknown;
-export declare const ShippingMethod: unknown;
-export declare const ShippingRate: unknown;
-export declare const ShippingZone: unknown;
-export declare const SocialPost: unknown;
-export declare const Subscriber: unknown;
-export declare const SubscriberEmail: unknown;
-export declare const Subscription: unknown;
-export declare const Tag: unknown;
-export declare const TaxRate: unknown;
-export declare const Team: unknown;
-export declare const Transaction: unknown;
-export declare const WaitlistProduct: unknown;
-export declare const WaitlistRestaurant: unknown;
-export declare const Websocket: unknown;
+} from '@stacksjs/query-builder';
+/**
+ * Resolves once all framework-default models have been loaded into the
+ * lazy-export proxies. Server bootstrap code that wants to ensure model
+ * exports are populated before serving the first request should
+ * `await ormReady` early. Per-request code doesn't need to — by the
+ * time any HTTP handler runs, the microtask queue has long drained.
+ */
+export declare const ormReady: Promise<void>;
+export declare const User: any;
+// Queue framework models. The CLI commands `buddy queue:status`,
+// `queue:failed`, `queue:flush`, `queue:inspect`, `queue:monitor`,
+// `queue:clear` import them as `import { Job, FailedJob } from
+// '@stacksjs/orm'`. Prefer the userland publication
+// (`app/Models/Job.ts`, dropped in by `buddy publish:model Job`) so
+// projects that customize the queue model see their version.
+//
+// Gated on the 'queue' feature flag — projects that don't run a queue
+// (most marketing sites, plain CMS apps) leave it off and skip the
+// defineModel pipeline for these two entirely. The lazyModel proxy
+// returns `undefined` for unloaded models, and the CLI queue commands
+// can check `await ormReady; if (!Job) throw …` to surface a clear
+// "run ./buddy queue:install" error.
+export declare const Job: any;
+export declare const FailedJob: any;
+export declare const Activity: any;
+export declare const Author: any;
+export declare const Campaign: any;
+export declare const Cart: any;
+export declare const CartItem: any;
+export declare const Category: any;
+export declare const Comment: any;
+export declare const Coupon: any;
+export declare const Customer: any;
+export declare const DeliveryRoute: any;
+export declare const Deployment: any;
+export declare const DigitalDelivery: any;
+export declare const Driver: any;
+export declare const CampaignSend: any;
+export declare const EmailList: any;
+export declare const EmailListSubscriber: any;
+export declare const ErrorModel: any;
+export declare const GiftCard: any;
+export declare const LicenseKey: any;
+export declare const Log: any;
+export declare const LoyaltyPoint: any;
+export declare const LoyaltyReward: any;
+export declare const Manufacturer: any;
+export declare const Notification: any;
+export declare const Order: any;
+export declare const OrderItem: any;
+export declare const Page: any;
+export declare const Payment: any;
+export declare const PaymentMethod: any;
+export declare const PaymentProduct: any;
+export declare const PaymentTransaction: any;
+export declare const Post: any;
+export declare const PrintDevice: any;
+export declare const Product: any;
+export declare const ProductUnit: any;
+export declare const ProductVariant: any;
+export declare const Receipt: any;
+export declare const Release: any;
+export declare const Request: any;
+export declare const Review: any;
+export declare const ShippingMethod: any;
+export declare const ShippingRate: any;
+export declare const ShippingZone: any;
+export declare const SocialPost: any;
+export declare const Subscriber: any;
+export declare const SubscriberEmail: any;
+export declare const Subscription: any;
+export declare const Tag: any;
+export declare const TaxRate: any;
+export declare const Team: any;
+export declare const Transaction: any;
+export declare const WaitlistProduct: any;
+export declare const WaitlistRestaurant: any;
+export declare const Websocket: any;
+/**
+ * Framework-default User row shape. Matches the attributes declared on
+ * `storage/framework/defaults/app/Models/User.ts` plus the system
+ * fields contributed by `useUuid` / `useTimestamps` / `useAuth` traits.
+ *
+ * For project-specific narrowing, prefer `ModelRow<typeof User>` so
+ * any added attributes flow through automatically.
+ */
+export declare interface UserModel {
+  id: number
+  uuid: string
+  name: string
+  email: string
+  password: string
+  avatar?: string | null
+  email_verified_at?: string | null
+  two_factor_secret?: string | null
+  public_key?: string | null
+  created_at: string
+  updated_at: string | null
+  [key: string]: unknown
+}
+/**
+ * Framework-default insertable User shape — fillable attributes from
+ * the default User model, all optional (DB-side defaults can fill in
+ * the rest). For project-specific narrowing, prefer
+ * `NewModelData<typeof User>`.
+ */
+export declare interface NewUser {
+  name?: string
+  email?: string
+  password?: string
+  avatar?: string | null
+  [key: string]: unknown
+}
 /** Row type for the polymorphic categories table (categorizable trait). */
 export declare interface CategorizableTable {
   id?: number
@@ -121,22 +173,6 @@ export declare interface TaggableTable {
   created_at?: string
   updated_at?: string
 }
-// The following type utilities are referenced by the framework but are not
-// yet exported by the installed `bun-query-builder` version. Until upstream
-// catches up we ship structural stubs so consumer code still type-checks.
-// These intentionally fall back to `any` to avoid spurious narrowing errors;
-// once `bun-query-builder` exports the real shapes, remove these stubs.
-export type InferFillableAttributes<_M> = any;
-export type InferNumericColumns<_M> = string;
-export type InferColumnNames<_M> = string;
-export type ModelRow<_M> = any;
-export type ModelRowLoose<_M> = any;
-export type ModelCreateData<_M> = any;
-export type ModelCreateDataLoose<_M> = any;
-/** User model row type — inferred from the User model definition. */
-export type UserModel = ModelRowLoose<unknown>;
-/** Data required to create a new User — inferred fillable attributes. */
-export type NewUser = ModelCreateDataLoose<unknown>;
 export * from './utils/prunable';
 export {
   collectEncryptedAttributes,
@@ -147,6 +183,12 @@ export {
 // Audit trait public API: setAuditUser is the queue/cron escape hatch for
 // attributing audit rows to a user when there's no current HTTP request.
 export { setAuditUser, createAuditMethods } from './traits/audit';
+// Shared write-error classifiers (stacksjs/stacks#1957). Named exports only —
+// `export *` would collide with the snakeCase helpers also exported from
+// './auto-crud' via other barrels. `isUniqueViolation` is re-exported by
+// `@stacksjs/auth`'s './rbac-store-bqb' for back-compat; `mapWriteError`
+// powers the auto-CRUD store/update 409 mapping.
+export { isUniqueViolation, mapWriteError } from './auto-crud';
 export * from './batch-loader';
 export * from './db';
 export * from './subquery';
@@ -155,3 +197,23 @@ export * from './model-types';
 export * from './types';
 export * from './utils';
 export * from './define-model';
+// Codegen for `database/types.d.ts` — augments
+// `@stacksjs/database`'s `DatabaseSchema` so `db.selectFrom(...)` gets
+// table-name autocomplete (stacksjs/stacks#1923).
+export { buildDatabaseSchema, renderDatabaseTypeFile } from './generate-database-schema';
+// Canonical paginator shapes + adapters (stacksjs/stacks#1905 P1).
+export {
+  isCursorPaginator,
+  isPaginator,
+  isSimplePaginator,
+  toCursorPaginator,
+  toPaginator,
+  toSimplePaginator,
+} from './paginator';
+// Request-aware pagination helpers (stacksjs/stacks#1906 P2 + #1907 P3).
+export {
+  enrichPaginatorUrls,
+  parseCursor,
+  resolveCursorArgs,
+  resolvePageArgs,
+} from './paginator-request';