@atscript/db 0.1.140 → 0.1.142

package/dist/agg.d.cts

@@ -1,3 +1,3 @@
-import { n as TResolvedBucket } from "./buckets-C-27xmtq.cjs";
+import { n as TResolvedBucket } from "./buckets-Bv4pah66.cjs";
 import { _ as TDbAggregateFn, a as AggregateResult, c as CalendarBucketLabel, d as WeekStart, f as isAggregateExpr, h as resolveAlias, i as AggregateQuery, l as ComputedExpr, m as resolveAggregateSearch, n as AggregateExpr, o as BucketExpr, p as isBucketExpr, r as AggregateFn, s as BucketUnit, t as AggregateControls, u as ResolvedBucket, v as assertAggregateFn } from "./agg-CV7y8nC6.cjs";
 export { type AggregateControls, type AggregateExpr, type AggregateFn, type AggregateQuery, type AggregateResult, type BucketExpr, type BucketUnit, type CalendarBucketLabel, type ComputedExpr, type ResolvedBucket, type TDbAggregateFn, type TResolvedBucket, type WeekStart, assertAggregateFn, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };

package/dist/agg.d.mts

@@ -1,3 +1,3 @@
-import { n as TResolvedBucket } from "./buckets-BFG2RYRW.mjs";
+import { n as TResolvedBucket } from "./buckets-CjL7F-hp.mjs";
 import { _ as TDbAggregateFn, a as AggregateResult, c as CalendarBucketLabel, d as WeekStart, f as isAggregateExpr, h as resolveAlias, i as AggregateQuery, l as ComputedExpr, m as resolveAggregateSearch, n as AggregateExpr, o as BucketExpr, p as isBucketExpr, r as AggregateFn, s as BucketUnit, t as AggregateControls, u as ResolvedBucket, v as assertAggregateFn } from "./agg-D5DHsAby.mjs";
 export { type AggregateControls, type AggregateExpr, type AggregateFn, type AggregateQuery, type AggregateResult, type BucketExpr, type BucketUnit, type CalendarBucketLabel, type ComputedExpr, type ResolvedBucket, type TDbAggregateFn, type TResolvedBucket, type WeekStart, assertAggregateFn, isAggregateExpr, isBucketExpr, resolveAggregateSearch, resolveAlias };

package/dist/{buckets-C-27xmtq.d.cts → buckets-Bv4pah66.d.cts}

@@ -75,13 +75,39 @@ interface TGenericLogger {
 declare const NoopLogger: TGenericLogger;
 //#endregion
 //#region src/strategies/field-mapping.d.ts
+/**
+ * The raw (logical, pre-translation) read controls a row was fetched with —
+ * what {@link FieldMappingStrategy.reconstructFromRead} needs to fill
+ * `@db.column.derived` fields on document adapters and to prune the source
+ * paths the caller did not ask for. `$select` is the uniqu shape (array,
+ * inclusion or exclusion object); `$groupBy` the grouped query's dimensions.
+ * @since 0.1.141
+ */
+interface TReadControls {
+  $select?: unknown;
+  $groupBy?: unknown;
+}
 /**
  * Strategy for mapping data between logical field shapes and physical storage.
  * Two implementations: {@link DocumentFieldMapper} (nested objects, NoSQL)
  * and `RelationalFieldMapper` (flattened columns, SQL).
  */
 declare abstract class FieldMappingStrategy {
-  abstract reconstructFromRead(row: Record<string, unknown>, meta: TableMetadata): Record<string, unknown>;
+  /**
+   * Physical row → logical row. `controls` (since 0.1.141) are the raw read
+   * controls the row was fetched with — document adapters fill
+   * `@db.column.derived` fields from their source paths and prune sources
+   * the caller did not select; relational adapters ignore them (the derived
+   * column is a real column).
+   */
+  abstract reconstructFromRead(row: Record<string, unknown>, meta: TableMetadata, controls?: TReadControls): Record<string, unknown>;
+  /**
+   * {@link reconstructFromRead} over every row of one read — the per-read
+   * work (the derived read plan on document adapters) is done once for all
+   * of them. The default maps the rows one by one.
+   * @since 0.1.141
+   */
+  reconstructRows(rows: Record<string, unknown>[], meta: TableMetadata, controls?: TReadControls): Record<string, unknown>[];
   abstract translateQuery(query: Uniquery, meta: TableMetadata): DbQuery;
   /**
    * The physical path of a logical field path — a `__`-joined column
@@ -176,7 +202,19 @@ declare abstract class FieldMappingStrategy {
  * value coercion.
  */
 declare class DocumentFieldMapper extends FieldMappingStrategy {
-  reconstructFromRead(row: Record<string, unknown>, meta: TableMetadata): Record<string, unknown>;
+  reconstructFromRead(row: Record<string, unknown>, meta: TableMetadata, controls?: TReadControls): Record<string, unknown>;
+  reconstructRows(rows: Record<string, unknown>[], meta: TableMetadata, controls?: TReadControls): Record<string, unknown>[];
+  private _derivedPlanFor;
+  private _reconstruct;
+  /** See {@link TDerivedReadPlan}. */
+  private derivedReadPlan;
+  /**
+   * {@link FieldMappingStrategy.physicalSelect} plus the derived-field rules
+   * of an exclusion projection: a derived key is not a stored path (dropping
+   * it just leaves the field unfilled), and the source subtree of a wanted
+   * derived field is fetched even when excluded (pruned after the read).
+   */
+  protected physicalSelect(select: NonNullable<UniqueryControls["$select"]>, meta: TableMetadata): NonNullable<UniqueryControls["$select"]>;
   /**
    * Every field-path position goes through `@db.column` renames
    * ({@link TableMetadata.documentPath}): filter keys, `$select` fields
@@ -384,11 +422,22 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
    */
   get metaIdPhysical(): string | null;
   /**
-   * Physical column name of the field annotated with `@db.column.version`, or
-   * `undefined` when the table has no version column. Used by adapters and the
-   * REST integration to drive optimistic concurrency control (OCC).
+   * Logical field name of the field annotated with `@db.column.version`, or
+   * `undefined` when the table has no version column. This is the key used in
+   * `$cas: { <versionColumn>: N }`, in write payloads, in rows read back, and in
+   * `/meta`'s `versionColumn` — a `@db.column 'physical_name'` rename on the
+   * field changes only the storage column (see {@link versionColumnPhysical}).
    */
   get versionColumn(): string | undefined;
+  /**
+   * Physical column name of the `@db.column.version` field (after any
+   * `@db.column` rename), or `undefined` when the table has no version column.
+   * Adapters use it for the auto-bump, the CAS predicate, and the insert-time
+   * `0` backfill — all of which operate on already-mapped physical rows.
+   *
+   * @internal Adapter-facing surface; not part of the consumer API.
+   */
+  get versionColumnPhysical(): string | undefined;
   /** Dimension fields from `@db.column.dimension`. */
   get dimensions(): readonly string[];
   /** Measure fields from `@db.column.measure`. */
@@ -401,6 +450,11 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
   get defaults(): ReadonlyMap<string, TDbDefaultValue>;
   /** Fields excluded from DB via `@db.ignore`. */
   get ignoredFields(): ReadonlySet<string>;
+  /**
+   * `@db.column.derived` fields (logical name → what they read) — computed
+   * from a JSON leaf of the same row, never written. Since 0.1.141.
+   */
+  get derivedFields(): ReadonlyMap<string, TDerivedColumn>;
   /** Navigational fields (`@db.rel.to` / `@db.rel.from`) — not stored as columns. */
   get navFields(): ReadonlySet<string>;
   /** Physical field names used to invert exclude-mode `$select` into a SELECT list. */
@@ -424,10 +478,30 @@ declare class AtscriptDbReadable<T extends TAtscriptAnnotatedType = TAtscriptAnn
   get physicalToPath(): ReadonlyMap<string, string>;
   /** Descriptor for the primary ID field(s). */
   getIdDescriptor(): TIdDescriptor;
+  /**
+   * Physical rows of one read → logical rows: the field mapper's per-read
+   * work (the derived read plan on document adapters) is done once for all
+   * of them. Every read path funnels through here.
+   */
+  private _fromRead;
   /**
    * Pre-computed field metadata for adapter use.
    */
   get fieldDescriptors(): readonly TDbFieldMeta[];
+  /**
+   * The descriptors schema sync manages as columns: non-ignored, and on
+   * nested-object adapters without the `@db.column.derived` fields (they store
+   * nothing there). See `TableMetadata.columnDescriptors`.
+   * @since 0.1.141
+   */
+  get columnDescriptors(): readonly TDbFieldMeta[];
+  /**
+   * The columns that hold a value of their own (non-ignored, not derived) —
+   * what a table recreation copies and a full replace assigns. See
+   * `TableMetadata.storedDescriptors`.
+   * @since 0.1.141
+   */
+  get storedDescriptors(): readonly TDbFieldMeta[];
   /**
    * The target table of the navigation relation `navField` (since 0.1.134),
    * resolved through the table resolver this readable was built with (the
@@ -887,7 +961,15 @@ declare function isFieldRef(value: unknown): value is AtscriptQueryFieldRef;
 /** A single join in a view query plan. */
 interface TViewJoin {
   targetType: () => TAtscriptAnnotatedType;
+  /** Physical table (or view) joined. */
   targetTable: string;
+  /**
+   * The name the join is addressed by in conditions, filters and column
+   * mappings: {@link targetTable} for a plain target, the alias's type name
+   * for a `@db.alias` target (`JOIN "employees" AS "Manager"`).
+   * @since 0.1.141
+   */
+  scope: string;
   condition: AtscriptQueryNode;
   /**
    * `inner` (default) drops entry rows without a match; `left` keeps them
@@ -941,10 +1023,14 @@ interface TViewSource {
    */
   optional: boolean;
 }
+/**
+ * The table / view a `@db.alias` type stands for, or `undefined` when `type`
+ * is not an alias.
+ * @since 0.1.141
+ */
+declare function aliasTargetOf(type: TAtscriptAnnotatedType | undefined): TAtscriptAnnotatedType | undefined;
 //#endregion
 //#region src/table/db-view.d.ts
-/** Primitive result type of a JSON-leaf extraction. */
-type TViewJsonType = "string" | "number" | "boolean";
 interface TViewColumnMapping {
   /**
    * The view's own physical column — its `@db.column` / flattened `__` name
@@ -1027,10 +1113,13 @@ declare class AtscriptDbView<T extends TAtscriptAnnotatedType = TAtscriptAnnotat
   private get _nested();
   /**
    * Resolves a view query field ref (join condition, `@db.view.filter`,
-   * conditional-aggregate predicate) to its table name and PHYSICAL source on
+   * conditional-aggregate predicate) to its scope name and PHYSICAL source on
    * this view's adapter — the column (or document path) with `TableMetadata`'s
    * layout rules, the path inside a JSON column, and whether the value may be
-   * absent. An unqualified ref resolves against the entry table.
+   * absent. An unqualified ref resolves against the entry table. `table` is
+   * the physical table / view name, or the alias name for a `@db.alias`
+   * target (since 0.1.141); a source that is itself a managed view resolves
+   * to that view's own columns.
    * @throws for a ref without storage (`@db.ignore`, navigation relation) or
    *   inside an `@db.encrypted` field (relational adapters).
    * @since 0.1.136
@@ -1926,12 +2015,6 @@ declare abstract class BaseDbAdapter {
 }
 //#endregion
 //#region src/table/table-metadata.d.ts
-/**
- * Finds the nearest ancestor of `path` that belongs to `set`.
- * Used by both the build pipeline (in `_classifyFields`) and
- * runtime reconstruction on the Readable.
- */
-declare function findAncestorInSet(path: string, set: ReadonlySet<string>): string | undefined;
 /** Returns true if the annotated type IS the `db.geoPoint` primitive (tag-based). */
 declare function isGeoPointType(fieldType: TAtscriptAnnotatedType): boolean;
 /**
@@ -1955,6 +2038,22 @@ declare class TableMetadata {
   readonly nestedObjects: boolean;
   flatMap: Map<string, TAtscriptAnnotatedType>;
   fieldDescriptors: readonly TDbFieldMeta[];
+  /**
+   * The descriptors schema sync manages as columns of this table: the
+   * non-ignored ones — on nested-object adapters without the
+   * `@db.column.derived` fields, which store nothing there (their
+   * `physicalName` is the source's document path). The desired side of every
+   * column diff and the column list of a fresh create.
+   * @since 0.1.141
+   */
+  columnDescriptors: readonly TDbFieldMeta[];
+  /**
+   * The columns that hold a value of their own — non-ignored and not derived
+   * (a generated column is computed, never assigned): what a table recreation
+   * copies and a full replace assigns.
+   * @since 0.1.141
+   */
+  storedDescriptors: readonly TDbFieldMeta[];
   primaryKeys: string[];
   preferredId: string[];
   originalMetaIdFields: string[];
@@ -1975,6 +2074,13 @@ declare class TableMetadata {
   quantityRefByField: Map<string, string>;
   /** Logical paths annotated with `@db.encrypted` — stored as one opaque ciphertext column. */
   encryptedFields: Set<string>;
+  /**
+   * `@db.column.derived` fields (top-level logical name → what they read),
+   * since 0.1.141. A generated column on relational adapters; on nested-object
+   * adapters nothing is stored — {@link physicalPath} maps the name to the
+   * source's document path and reads fill the field from it.
+   */
+  derivedFields: Map<string, TDerivedColumn>;
   pathToPhysical: Map<string, string>;
   physicalToPath: Map<string, string>;
   flattenedParents: Set<string>;
@@ -2027,7 +2133,10 @@ declare class TableMetadata {
   private _columnFromMap;
   constructor(nestedObjects: boolean);
   get isBuilt(): boolean;
-  /** {@link documentPath} over this table's `columnMap`. */
+  /**
+   * {@link documentPath} over this table's `columnMap`. A `@db.column.derived`
+   * field has no stored path of its own: it maps to its source leaf.
+   */
   documentPath(path: string): string;
   /**
    * Physical name of a logical path: the document path on nested-object
@@ -2035,6 +2144,13 @@ declare class TableMetadata {
    * `@db.column` override).
    */
   physicalPath(logical: string): string;
+  /**
+   * Drops the `@db.column.derived` keys of a write payload in place (a
+   * derived field is always top-level): the column is computed from the row
+   * and never written, so a row read back can be written back as-is.
+   * @since 0.1.141
+   */
+  stripDerived(data: Record<string, unknown>): void;
   /**
    * Runs the full metadata compilation pipeline. Called once by
    * `AtscriptDbReadable._ensureBuilt()` on first metadata access.
@@ -2067,6 +2183,14 @@ declare class TableMetadata {
    * from pre-compiled types still fail fast.
    */
   private _validateEncryptedField;
+  /**
+   * Build-time diagnostics for `@db.column.derived` (rules D1–D8 of the
+   * derived-column design) — the runtime mirror of the compile-time check, so
+   * pre-compiled models fail fast — and the resolution of what the field
+   * reads: the source leaf's JSON column + path (relational layout, via the
+   * views' `resolveViewSource`) and its declared type.
+   */
+  private _validateDerivedField;
   /** Build-time diagnostics for `@db.index.geo` (§3 of the geo-index spec). */
   private _validateGeoIndexField;
   private _addIndexField;
@@ -2188,6 +2312,13 @@ interface TFieldMeta {
    * (`bucketUnits`). Since 0.1.132.
    */
   bucketable?: true;
+  /**
+   * Present (true) when the field is a `@db.column.derived` column: its value
+   * is computed from a `@db.json` field of the same row and is never written
+   * — a write payload carrying it is accepted and the key is dropped. UIs
+   * render it read-only. Since 0.1.141.
+   */
+  derived?: true;
 }
 /** Built-in CRUD operation names; map 1:1 to public method names. */
 type TCrudOp = "query" | "pages" | "one" | "geo" | "insert" | "update" | "replace" | "remove";
@@ -2213,9 +2344,11 @@ interface TMetaResponse {
   actions: TDbActionInfo[];
   crud: TCrudPermissions;
   /**
-   * Physical column name annotated with `@db.column.version`, when the table
-   * opts into optimistic concurrency control (OCC). Absent for tables without
-   * the annotation, i.e. last-write-wins (default) behavior.
+   * Logical field name of the `@db.column.version` field, when the table opts
+   * into optimistic concurrency control (OCC) — the key a client sends in a
+   * write body / `$cas` and reads back on rows. A `@db.column` rename on the
+   * field changes only the storage column, never this name. Absent for tables
+   * without the annotation, i.e. last-write-wins (default) behavior.
    */
   versionColumn?: string;
   /**
@@ -2288,11 +2421,13 @@ interface TDbActionInfo {
   /**
    * Stringified gate predicate (`fn.toString()`). Present only for `'row'`
    * and `'rows'` level actions whose decorator declared a `disabled` function.
-   * The function is the batch shape `(rows: TRow[]) => boolean[]` (sync). The
+   * The function is the batch shape `(rows: TRow[]) => (boolean | string)[]`
+   * (sync). Per entry: truthy = disabled — test truthiness, not `=== true`; a
+   * non-empty string is also the human-readable reason (since 0.1.141). The
    * UI evaluates against a level-specific scope to grey-out / hide the
    * button. The server has already enforced this predicate before the
    * action's handler ran — the server is authoritative; this field is purely
-   * a UI hint.
+   * a UI hint. Server-evaluated reasons arrive per row in `$disabledReasons`.
    */
   disabled?: string;
   /**
@@ -2385,6 +2520,26 @@ interface TIdentification {
   source: string;
 }
 type TDbStorageType = "column" | "flattened" | "json";
+/** Primitive result type of a JSON-leaf extraction (view JSON leaves, derived columns). */
+type TViewJsonType = "string" | "number" | "boolean";
+/**
+ * Where a `@db.column.derived` field reads its value from: a primitive leaf
+ * inside a `@db.json` field of the SAME table (since 0.1.141).
+ */
+interface TDerivedColumn {
+  /** Logical path of the source leaf (`payload.customer.id`). */
+  sourcePath: string;
+  /**
+   * Physical column of the JSON field the leaf lives in (relational layout:
+   * `@db.column` rename applied, unqualified) — what the generated column's
+   * expression reads.
+   */
+  sourceColumn: string;
+  /** Segments inside {@link sourceColumn} down to the leaf. */
+  jsonPath: string[];
+  /** Declared leaf type — the extraction's type guard. */
+  type: TViewJsonType;
+}
 interface TDbFieldMeta {
   /** The dot-notation path to this field (logical name). */
   path: string;
@@ -2454,6 +2609,16 @@ interface TDbFieldMeta {
    * Adapters map this to their native geo storage (e.g. MongoDB GeoJSON Point).
    */
   isGeoPoint?: boolean;
+  /**
+   * `@db.column.derived` (since 0.1.141): the value is computed from a JSON
+   * leaf of the same row. Relational adapters store it as a generated column
+   * (`physicalName` is that column); document adapters store nothing —
+   * `physicalName` is the source's document path, which filters, sorts,
+   * projections and indexes address, and reads fill the field from it.
+   * Never written: write payloads drop it, `$inc` / `$dec` / `$mul` on it are
+   * rejected.
+   */
+  derived?: TDerivedColumn;
 }
 interface TValueFormatterPair {
   /** Converts a JS value to storage representation (write + filter paths). */
@@ -2486,7 +2651,23 @@ interface TExistingColumn {
   pk: boolean;
   /** Serialized default value (e.g., "'active'", "NULL"). */
   dflt_value?: string;
+  /**
+   * `true` for a generated (computed) column — what a `@db.column.derived`
+   * field is stored as on relational adapters. Adapters that introspect it
+   * set it (SQLite `table_xinfo.hidden`, MySQL `EXTRA`, PostgreSQL
+   * `is_generated`); the column diff then decides kind changes by it.
+   * @since 0.1.141
+   */
+  generated?: boolean;
 }
+/**
+ * Why a `@db.column.derived` column is dropped and re-added by schema sync:
+ * `kind` — a regular column became derived or a derived one became regular;
+ * `expression` — the source column, path or leaf type changed (compared with
+ * the stored snapshot); `type` — the mapped column type differs.
+ * @since 0.1.141
+ */
+type TDerivedChangeReason = "kind" | "expression" | "type";
 /** Result of comparing desired schema against existing database columns. */
 interface TColumnDiff {
   added: TDbFieldMeta[];
@@ -2513,6 +2694,28 @@ interface TColumnDiff {
     oldName: string;
     conflictsWith: string;
   }>;
+  /**
+   * Derived columns whose live column no longer matches the model and must
+   * be dropped and re-added (a generated column's expression cannot be
+   * altered in place): `kind` — a regular column became derived or a derived
+   * one became regular (the column-drop policy applies: normal mode rebuilds,
+   * safe mode skips); `expression` — the source path or leaf type in the
+   * stored snapshot differs (engines normalize expression text, so the
+   * snapshot is the baseline); `type` — the mapped column type differs.
+   * Absent (or empty) when nothing changed.
+   *
+   * Invariant: a derived field, and a live generated column, is reported
+   * HERE only — never in `typeChanged`, `nullableChanged` or
+   * `defaultChanged` (a generated column is nullable and has no DEFAULT). On
+   * nested-object adapters derived fields are not part of the diff at all
+   * (`TableMetadata.columnDescriptors` leaves them out: they store nothing
+   * there), so `added` never carries one either.
+   * @since 0.1.141
+   */
+  derivedChanged?: Array<{
+    field: TDbFieldMeta;
+    reason: TDerivedChangeReason;
+  }>;
   /**
    * The primary-key FIELD SET differs between the live table and the model
    * (set semantics — a composite-key reorder is not a change, consistent with
@@ -2906,4 +3109,4 @@ declare function isJsonValueField(fd: TDbFieldMeta): boolean;
  */
 declare function jsonValueAncestor(path: string, jsonValueParents: ReadonlySet<string>): string | undefined;
 //#endregion
-export { TDbWriteGuard as $, AtscriptDbReadable as $t, TDbActionInfo as A, findAncestorInSet as At, TDbIndex as B, TViewJsonType as Bt, OwnPropsOf$1 as C, TWriteOptions as Ct, TColumnDiff as D, UniqueryControls$1 as Dt, TCascadeTarget as E, Uniquery$1 as Et, TDbDefaultFn as F, DbSpace as Ft, TDbObjectKind as G, AtscriptRef as Gt, TDbIndexType as H, AtscriptQueryComparison as Ht, TDbDefaultValue as I, TAdapterFactory as It, TDbRemoveGuard as J, isFieldRef as Jt, TDbReferentialAction as K, TViewJoin as Kt, TDbDeleteResult as L, TDbSpaceOptions as Lt, TDbActionLevel as M, isGeoPointType as Mt, TDbActionProcessor as N, ALL_BUCKET_UNITS as Nt, TCrudOp as O, WithRelation$1 as Ot, TDbCollation as P, BaseDbAdapter as Pt, TDbWriteAction as Q, NativeIntegrity as Qt, TDbFieldMeta as R, AtscriptDbView as Rt, NullableOptional as S, TValueFormatterPair as St, TCascadeResolver as T, TypedWithRelation as Tt, TDbInsertManyResult as U, AtscriptQueryFieldRef$1 as Ut, TDbIndexField as V, isAtscriptDbView as Vt, TDbInsertResult as W, AtscriptQueryNode$1 as Wt, TDbStorageType as X, AtscriptDbTable as Xt, TDbRemoveGuardContext as Y, translateQueryTree as Yt, TDbUpdateResult as Z, IntegrityStrategy as Zt, DbRow as _, TSearchIndexInfo as _t, jsonValueAncestor as a, FieldMappingStrategy as an, TExistingTableOption as at, FlatOf$1 as b, TTableResolver as bt, AggregateControls as c, UniquSelect as cn, TFkLookupTarget as ct, AggregateQuery$1 as d, TIdentification as dt, DbResponse as en, TDbWriteGuardContext as et, AggregateResult as f, TMetaResponse as ft, DbQuery as g, TRelationInfo as gt, DbPatch as h, TReferencingForeignKey as ht, isJsonValueField as i, DocumentFieldMapper as in, TExistingForeignKey as it, TDbActionIntent as j, isGeoIndexableType as jt, TCrudPermissions as k, TableMetadata as kt, AggregateExpr$1 as l, TIdDescriptor as lt, DbControls as m, TPrimaryKeyChange as mt, TResolvedBucket as n, DbEncryption as nn, TEnsureTableOptions as nt, normalizeComputedSelect as o, NoopLogger as on, TFieldMeta as ot, AtscriptDbWritable as p, TMetadataOverrides as pt, TDbRelation as q, TViewPlan as qt, isBucketableField as r, TDbEncryptionOptions as rn, TExistingColumn as rt, resolveCalendarBuckets as s, TGenericLogger as sn, TFkLookupResolver as st, TBucketFieldSource as t, resolveDesignType as tn, TDeleteOptions as tt, AggregateFn$1 as u, TIdResolveOptions as ut, FieldOpsFor as v, TSyncColumnResult as vt, PrimaryKeyOf$1 as w, TWriteTableResolver as wt, NavPropsOf$1 as x, TTouchManyOptions as xt, FilterExpr$1 as y, TTableOptionDiff as yt, TDbForeignKey as z, TViewColumnMapping as zt };
+export { TDbWriteGuard as $, IntegrityStrategy as $t, TDbActionInfo as A, UniqueryControls$1 as At, TDbIndex as B, AtscriptDbView as Bt, OwnPropsOf$1 as C, TTouchManyOptions as Ct, TColumnDiff as D, TWriteTableResolver as Dt, TCascadeTarget as E, TWriteOptions as Et, TDbDefaultFn as F, ALL_BUCKET_UNITS as Ft, TDbObjectKind as G, AtscriptQueryFieldRef$1 as Gt, TDbIndexType as H, isAtscriptDbView as Ht, TDbDefaultValue as I, BaseDbAdapter as It, TDbRemoveGuard as J, TViewJoin as Jt, TDbReferentialAction as K, AtscriptQueryNode$1 as Kt, TDbDeleteResult as L, DbSpace as Lt, TDbActionLevel as M, TableMetadata as Mt, TDbActionProcessor as N, isGeoIndexableType as Nt, TCrudOp as O, TypedWithRelation as Ot, TDbCollation as P, isGeoPointType as Pt, TDbWriteAction as Q, AtscriptDbTable as Qt, TDbFieldMeta as R, TAdapterFactory as Rt, NullableOptional as S, TTableResolver as St, TCascadeResolver as T, TViewJsonType as Tt, TDbInsertManyResult as U, aliasTargetOf as Ut, TDbIndexField as V, TViewColumnMapping as Vt, TDbInsertResult as W, AtscriptQueryComparison as Wt, TDbStorageType as X, isFieldRef as Xt, TDbRemoveGuardContext as Y, TViewPlan as Yt, TDbUpdateResult as Z, translateQueryTree as Zt, DbRow as _, TReferencingForeignKey as _t, jsonValueAncestor as a, TDbEncryptionOptions as an, TExistingColumn as at, FlatOf$1 as b, TSyncColumnResult as bt, AggregateControls as c, TReadControls as cn, TFieldMeta as ct, AggregateQuery$1 as d, UniquSelect as dn, TIdDescriptor as dt, NativeIntegrity as en, TDbWriteGuardContext as et, AggregateResult as f, TIdResolveOptions as ft, DbQuery as g, TPrimaryKeyChange as gt, DbPatch as h, TMetadataOverrides as ht, isJsonValueField as i, DbEncryption as in, TEnsureTableOptions as it, TDbActionIntent as j, WithRelation$1 as jt, TCrudPermissions as k, Uniquery$1 as kt, AggregateExpr$1 as l, NoopLogger as ln, TFkLookupResolver as lt, DbControls as m, TMetaResponse as mt, TResolvedBucket as n, DbResponse as nn, TDerivedChangeReason as nt, normalizeComputedSelect as o, DocumentFieldMapper as on, TExistingForeignKey as ot, AtscriptDbWritable as p, TIdentification as pt, TDbRelation as q, AtscriptRef as qt, isBucketableField as r, resolveDesignType as rn, TDerivedColumn as rt, resolveCalendarBuckets as s, FieldMappingStrategy as sn, TExistingTableOption as st, TBucketFieldSource as t, AtscriptDbReadable as tn, TDeleteOptions as tt, AggregateFn$1 as u, TGenericLogger as un, TFkLookupTarget as ut, FieldOpsFor as v, TRelationInfo as vt, PrimaryKeyOf$1 as w, TValueFormatterPair as wt, NavPropsOf$1 as x, TTableOptionDiff as xt, FilterExpr$1 as y, TSearchIndexInfo as yt, TDbForeignKey as z, TDbSpaceOptions as zt };