@palbase/backend 38.0.15 → 39.0.0

package/dist/{index-CUy50OLU.d.ts → index-eN4KzGa5.d.ts}

@@ -824,6 +824,33 @@ declare class PolicyExprRef {
     or(...others: PolicyExprRef[]): PolicyExprRef;
     not(): PolicyExprRef;
 }
+/**
+ * Bir tablonun `existsIn` için ANNOTATION hâli — iki bildirim birbirini
+ * başlatırken çıkarım döngüsünü kıran şey.
+ *
+ * ÖLÇÜLDÜ: `memberships.household_id` `households.id`'ye referans verirken
+ * `households`'ın politikası `existsIn(memberships, …)` yazarsa TypeScript
+ * ikisini de TS7022 ile `any`'ye düşürüyor. Kesinti sadece hata mesajı değil:
+ * `m.col(…)` de `any` olduğu için politika gövdesindeki YANLIŞ YAZILMIŞ bir
+ * kolon adı sessizce derleniyor — RLS yolunda fail-open. Aynı ölçümde
+ * `existsIn`'in jeneriğini kaldırmak (tamamen jeneriksiz imza dahil) döngüyü
+ * KIRMADI: döngü çıkarımdan değil, iki `const`'un birbirini başlatmasından
+ * geliyor ve TypeScript'te tek çaresi bir tip annotation'ı.
+ *
+ * Bu, `references((): AnyColumn => y.id)`'nin tablo düzeyindeki karşılığı — ama
+ * `AnyColumn`'dan farklı olarak KOLON ADLARINI SİLMEZ:
+ *
+ * ```ts
+ * const memberships: TableRef<"id" | "household_id" | "user_id", "memberships"> =
+ *   defineTable("memberships", { columns: { … } });
+ * ```
+ *
+ * Adlar `Cols`'ta durduğu için `m.col("user")` hâlâ DERLENMEZ, ve `N` verildiği
+ * için tablo `defineSchema` içinde anahtarını kaybetmez. Kolon adlarını silen
+ * gevşek bir `AnyTable` KASITLI OLARAK YOK: onu yazan kişi döngüyü susturur ve
+ * politikasının kolon denetimini kapattığını fark etmez.
+ */
+type TableRef<Cols extends string, N extends string = string> = TableHandle<Record<Cols, ColumnMap[string]>, N>;
 /** `.eq()` gibi metotların sağ tarafı: başka bir ifade ya da düz bir değer. */
 type PolicyOperand = PolicyExprRef | string | number | boolean | null;
 /**
@@ -855,6 +882,11 @@ interface PolicyExprCtx<Cols extends string = string> {
      * tipli ve SQL'de farklı nitelenirler. Karışsalardı `team_id = team_id`
      * üretilir ve politika hiçbir şeyi süzmezdi.
      *
+     * ÇIKARIM DÖNGÜSÜ: `table` iki bildirim birbirini başlatıyorsa (üyelik tablosu
+     * bu tabloya `references` veriyor, bu tablo da ona `existsIn` atıyor) o
+     * bildirime {@link TableRef} annotation'ı gerekir — yoksa TypeScript ikisini
+     * de TS7022 ile `any`'ye düşürür ve `m.col(…)` sessizce her adı kabul eder.
+     *
      * ÖZYİNELEME TUZAĞI: üyelik tablosunun KENDİ politikası `existsIn`
      * KULLANMAZ — `user_id = auth.uid()` yazar. İki tablo birbirini
      * sorgularsa Postgres sorgu anında
@@ -1004,6 +1036,44 @@ declare class PolicyBuilder {
  *             `(table, name)`, so names must be unique per table.
  */
 declare function policy(name: string): PolicyBuilder;
+/**
+ * Adlandırılmış bir CHECK kısıtı — telin bugünkü şekli, HARFİYEN.
+ *
+ * `expr` STRING kalıyor: `TableJSON.checks` bugün de `{ name, expr }[]` ve Go
+ * tarafındaki `CheckJSON.Expr` bir string. Tipli `check()` ifadeyi bildirim
+ * anında SQL'e derleyip aynı yere koyuyor, yani string dalıyla tipli dal telde
+ * AYNI şeye iniyor: `NormalizeDeclaredChecks` ikisini de canlı Postgres'e
+ * sorarak kanonikleştiriyor (böylece değişmemiş bir CHECK churn olarak
+ * yeniden diff'lenmiyor) ve `schema-json.ts` yeni bir alan taşımıyor.
+ */
+interface CheckDef {
+    name: string;
+    /** Derlenmiş SQL. Tipli dalda `check()` üretir, string dalda yazar verir. */
+    expr: string;
+}
+/**
+ * `check("<ad>", <ifade>)` — TİPLİ CHECK kısıtı (FR-009).
+ *
+ * İfade POLİTİKA ifade cebirinin ta kendisiyle yazılıyor; bu DSL'de iki ayrı
+ * ifade dili olmaması kurulu ilke. Kolon adları `checks` callback'inin verdiği
+ * bağlamdan geliyor, yani yanlış yazılmış bir ad DERLENMİYOR — bugün string
+ * biçiminde o hata ancak `ALTER TABLE ... ADD CONSTRAINT` anında Postgres'ten
+ * geliyor.
+ *
+ * ```ts
+ * defineTable("payments", {
+ *   columns: { amount: integer().notNull(), currency: text().notNull() },
+ *   checks: (c) => [
+ *     check("payments_amount_pos", c.col("amount").gt(0)),
+ *     check("payments_currency_set", c.col("currency").isNull(true)),
+ *   ],
+ * })
+ * ```
+ *
+ * @param name Kısıtın adı. CHECK'ler ADA göre uzlaştırılıyor (gövde farkı
+ *             DROP + ADD demek), o yüzden ad tablo başına tekil olmalı.
+ */
+declare function check(name: string, expr: PolicyExprRef): CheckDef;
 /**
  * `can` alanının YANIT şeması (FR-004, D-14).
  *
@@ -1057,22 +1127,336 @@ declare const EXTENSION_DEPENDENCIES: Partial<Record<PalbaseExtension, PalbaseEx
 /** Runtime guard: is `name` a supported Palbase extension? */
 declare function isPalbaseExtension(name: string): name is PalbaseExtension;
 
+/** `ON UPDATE` / `ON DELETE` eylemleri — Postgres'in kabul ettiği kapalı küme. */
+type FkAction = "cascade" | "restrict" | "set null" | "set default" | "no action";
+/** `MATCH` türü. `partial` Postgres'te HENÜZ uygulanmadı, o yüzden yok. */
+type FkMatch = "simple" | "full";
+/** Bir tablo düzeyi FOREIGN KEY bildirimi — C-1/C-2 (FR-001). */
+interface ForeignKeyDef {
+    name: string;
+    columns: string[];
+    refTable: string;
+    refColumns: string[];
+    onUpdate?: FkAction;
+    onDelete?: FkAction;
+    match?: FkMatch;
+}
+/**
+ * `foreignKey("<ad>")` — tablo düzeyinde, ÇOK SÜTUNLU FOREIGN KEY (C-1, FR-001).
+ *
+ * ```ts
+ * foreignKeys: (c) => [
+ *   foreignKey("settlement_entry_household")
+ *     .on(c.col("household_id"), c.col("entry_id"))
+ *     .references(entries, "household_id", "id")
+ *     .onDelete("cascade"),
+ * ]
+ * ```
+ *
+ * NEDEN KOLON ÜZERİNDEKİ `.references()` YETMİYOR. O tek sütunlu ve tek
+ * hedeflidir. Çok kiracılı bütünlüğün istediği şey
+ * `FOREIGN KEY (household_id, entry_id) REFERENCES entries (household_id, id)`:
+ * çocuğun ebeveyni yalnız var olmakla kalmaz, AYNI KİRACIYA ait olmak
+ * zorundadır. Kolon başına model bunu ifade edemez.
+ *
+ * İki yol BİRBİRİNİ DÜŞÜRMEZ: bu bildirim kendi adıyla izlenir, kolon
+ * üzerindekiler `<tablo>_<kolon>_fkey` ile. Aynı tabloda ikisi birden olabilir.
+ */
+declare class ForeignKeyBuilder {
+    readonly _def: ForeignKeyDef;
+    constructor(name: string);
+    /** Yerel sütunlar. SIRA KORUNUR — hedef sütunlarla birebir eşleşir. */
+    on(...cols: PolicyExprRef[]): this;
+    /**
+     * Hedef tablo ve sütunları. Sütun sayısı `.on()`'unkiyle eşit OLMALI ve bu
+     * burada, bildirim yazılırken kontrol edilir — bozuk bir FK wire'a hiç çıkmaz.
+     */
+    references<C extends ColumnMap, N extends string>(table: TableHandle<C, N>, ...cols: (Extract<keyof C, string>)[]): this;
+    onUpdate(action: FkAction): this;
+    onDelete(action: FkAction): this;
+    /**
+     * `MATCH FULL`: referans veren sütunların HEPSİ NULL olmadıkça kısıt
+     * değerlendirilir. Varsayılan `MATCH SIMPLE`'da tek bir NULL kısıtı atlatır —
+     * `freeze` bunu bilerek kullanır, sıradan bir FK'da genelde istenmez.
+     */
+    match(m: FkMatch): this;
+}
+declare function foreignKey(name: string): ForeignKeyBuilder;
+/**
+ * Bir KOŞULLU ("donan") FOREIGN KEY bildirimi — C-5 (FR-012).
+ *
+ * `columns` çocuğun donan sütunları, `refColumns` ebeveynin onlara karşılık
+ * gelen anahtar sütunları; ikisi SIRAYLA eşleşir. `when` doğruyken FK
+ * değerlendirilir, yanlışken hiç değerlendirilmez.
+ */
+interface FreezeDef {
+    name: string;
+    when: PolicyExpr;
+    columns: string[];
+    refTable: string;
+    refColumns: string[];
+}
+/** Builder'ın YAZILMAKTA olan hâli: `when` henüz atanmamış olabilir. */
+type FreezeDraft = Omit<FreezeDef, "when"> & {
+    when?: PolicyExpr;
+};
+/**
+ * `freeze("<ad>")` — KOŞULLU FK: bir koşul sağlandığı sürece bir demeti dondurur
+ * (C-5, FR-012).
+ *
+ * ```ts
+ * freeze: (c) => [
+ *   freeze("pay_settled_inv")
+ *     .when(c.col("status").eq("settled"))
+ *     .columns("inv_id", "amount", "currency")
+ *     .references(invoices, "id", "amount", "currency"),
+ * ]
+ * ```
+ *
+ * NEDEN TRIGGER DEĞİL. Üretilen şey bir CONSTRAINT: ebeveyndeki demet üzerinde
+ * bir UNIQUE, çocukta `when` sağlanmıyorken NULL veren `STORED` generated
+ * sütunlar, ve bunlardan `ON UPDATE RESTRICT ON DELETE RESTRICT` bir FK.
+ * `MATCH SIMPLE`'ın NULL kaçışı — "referans veren sütunlardan biri NULL ise satır
+ * kısıtı sağlamak zorunda değildir" — "koşullu FK"yı `WHERE` olmadan veriyor.
+ *
+ * Trigger'a göre üç bedava üstünlük (canlı pg'de ölçüldü, spec Research
+ * Appendix): TERS YÖN de kapanır (uyuşmayan bir çocuk `settled` yapılamaz —
+ * trigger yalnız ebeveyni korurdu); koşul kalkınca donma KENDİLİĞİNDEN çözülür;
+ * `pg_dump`/restore'da FK gibi davranır.
+ *
+ * Donan sütunlar `NOT NULL` OLMALI: nullable bir sütun `MATCH SIMPLE`'ın aynı
+ * kaçışını koşuldan BAĞIMSIZ olarak açar ve donma sessizce hiç kurulmaz. Push o
+ * bildirimi reddeder (FR-014).
+ */
+declare class FreezeBuilder {
+    readonly _def: FreezeDraft;
+    constructor(name: string);
+    /**
+     * DONMA KOŞULU — çocuk satırının kendi kolonları üzerinde bir yüklem.
+     *
+     * Generated sütunlara `CASE WHEN <koşul> THEN <sütun> END` olarak iner; yani
+     * koşul yanlışken sütunlar NULL olur ve FK o satır için hiç değerlendirilmez.
+     */
+    when(pred: PolicyExprRef): this;
+    /** Çocuğun DONAN sütunları. SIRA KORUNUR — hedef sütunlarla birebir eşleşir. */
+    columns(...cols: string[]): this;
+    /**
+     * Ebeveyn tablo ve donan demetin ORADAKİ karşılığı. Zincirin SON halkası:
+     * bildirim burada tamamlanır ve tutarlılığı burada doğrulanır, yani
+     * `.references()`'ı unutmuş bir freeze `FreezeDef` üretmediği için tabloya
+     * hiç giremez.
+     */
+    references<C extends ColumnMap, N extends string>(table: TableHandle<C, N>, ...cols: (Extract<keyof C, string>)[]): FreezeDef;
+}
+declare function freeze(name: string): FreezeBuilder;
+
+/**
+ * guard.ts — DAR REDDEDİCİ YÜZEY (C-3, FR-015…FR-021).
+ *
+ * Bildirimsel kısıtların yetişemediği beş madde kaldı: write-once alanlar,
+ * durum makinesi geçişleri, sabit olmayan yüklemle çapraz satır kontrolü, işlem
+ * düzeyinde toplam, ve alan diline ait teşhis. RLS yolu bunlara KAPALI: `OLD` ve
+ * `NEW` bir politika ifadesinde ad olarak YOKTUR (ölçüldü — red, ad çözümleme
+ * düzeyinde `CREATE POLICY` anında gelir: `missing FROM-clause entry for table
+ * "new"`), ve `USING`/`WITH CHECK` iki ayrı satıra karşı ayrı ayrı
+ * değerlendirilir; tek ifadede iki satırı yan yana getiren bir kapsam yok.
+ *
+ * YAZAR ÜÇ ŞEY YAZAR: hangi olay · hangi koşul · ne diyerek reddet. Kalan sekiz
+ * knob'un güvenli varsayılanı var ve bu yüzeyde HİÇ görünmüyor: `BEFORE` ·
+ * `FOR EACH ROW` (Postgres'in varsayılanı `STATEMENT` ve bir guard için yanlış) ·
+ * `UPDATE OF` listesi `WHEN`'den türetilir · `SET search_path = pg_catalog,
+ * pg_temp` HER ZAMAN · `SECURITY INVOKER` (asla `DEFINER`) · `NOT DEFERRABLE` ·
+ * `REFERENCING`/`FROM` üretilmez · `DROP IF EXISTS` + `CREATE`. Bir yeteneği
+ * yüzeye çıkarmak onu politika hâline getirir; bunlar politika DEĞİL, güvenli
+ * varsayılan (FR-017).
+ *
+ * Global bir kaçış kapısı KASITLI OLARAK YOK: django-pgtrigger'ın
+ * `SET pgtrigger.ignore`'u herhangi bir oturumun guard'ı atlamasına izin veriyor
+ * ve bir BaaS'ta bu kabul edilemez.
+ */
+/** Guard'ın tetiklendiği yazma fiili. */
+type GuardEvent = "insert" | "update" | "delete";
+/**
+ * Bir guard bildirimi — C-3/C-4 (FR-015).
+ *
+ * `when` satırın KENDİ kolonları üzerinde bir yüklem (trigger'ın `WHEN` yan
+ * tümcesine iner), `exists` ise çapraz satır yüklemi (gövdedeki `EXISTS`
+ * bloğuna). İkisi ayrı alan çünkü Postgres bir trigger'ın `WHEN` yan tümcesinde
+ * ALT SORGUYA İZİN VERMİYOR (`ERROR: cannot use subquery in trigger WHEN
+ * condition` — ölçüldü); ayrımı wire'da yapmak, emitter'ın yükleme bakıp
+ * tahmin etmesinden daha dürüst (FR-019).
+ */
+interface GuardDef {
+    name: string;
+    event: GuardEvent;
+    when?: PolicyExpr;
+    exists?: PolicyExpr;
+    message: string;
+    detail?: string;
+    hint?: string;
+    column?: string;
+}
+/** Builder'ın YAZILMAKTA olan hâli: olay ve mesaj henüz atanmamış olabilir. */
+type GuardDraft = Omit<GuardDef, "event" | "message"> & {
+    event?: GuardEvent;
+    message?: string;
+};
+/**
+ * `guard("<ad>")` — bir yazmayı ALAN DİLİYLE reddeden trigger (C-3, FR-015).
+ *
+ * ```ts
+ * guards: (g) => [
+ *   guard("documents_frozen_body")
+ *     .on("update")
+ *     .when(g.col("status").eq("archived"))
+ *     .refuse("Arşivlenmiş belgenin gövdesi değiştirilemez", { column: "body" }),
+ * ]
+ * ```
+ *
+ * ADI ZORUNLU (FR-016). Postgres aynı olaya bağlı trigger'ları ADA GÖRE
+ * alfabetik sırayla koşar ve başka bir sıra tutamacı YOKTUR: adsız üretilmiş bir
+ * guard, sırası kendi kontrolünde olmayan bir guard demektir.
+ *
+ * Teşhis: red `PB001` SQLSTATE'i ile gelir — `23514` KULLANILMAZ, o gerçek bir
+ * CHECK ihlalinin kodu ve istemci ikisini ayırt edemezdi. Guard'ın adı
+ * `CONSTRAINT` alanına gider, yani istemci mesajı PARSE ETMEDEN hangi guard'ın
+ * reddettiğini okur (FR-021).
+ */
+declare class GuardBuilder {
+    readonly _def: GuardDraft;
+    constructor(name: string);
+    /** Hangi yazma fiilinde bakılacak. */
+    on(event: GuardEvent): this;
+    /**
+     * Satırın KENDİ kolonları üzerinde koşul — trigger'ın `WHEN` yan tümcesi.
+     *
+     * Emitter karşılaştırmaları `IS DISTINCT FROM` ile yazar (`<>` NULL'da yanlış
+     * cevap verir) ve geçen sütunlardan bir `UPDATE OF (…)` listesi türetir
+     * (FR-018).
+     */
+    when(pred: PolicyExprRef): this;
+    /**
+     * ÇAPRAZ SATIR koşulu — gövdedeki `EXISTS` bloğuna iner, `WHEN`'e DEĞİL:
+     * Postgres trigger `WHEN`'inde alt sorgu kabul etmiyor (FR-019).
+     *
+     * Yüklem içinde takma adsız kalan kolon guard'ın KENDİ satırıdır (`NEW`/`OLD`);
+     * `r.col(...)` hedef tablonun kolonlarını verir ve ayrı nitelenir. Bu yüzden
+     * düğümün `outer` alanı BOŞ kalır: bir guard'ın "dış satır"ı bir tablo takma
+     * adı değildir.
+     */
+    exists<C extends ColumnMap, N extends string>(table: TableHandle<C, N>, predicate: (row: PolicyExprCtx<Extract<keyof C, string>>) => PolicyExprRef): this;
+    /**
+     * REDDİN KENDİSİ ve zincirin son halkası: mesaj olmadan bir guard tamamlanmaz.
+     *
+     * `detail`/`hint` Postgres'in aynı adlı alanlarına, `column` ise `COLUMN`
+     * alanına gider — istemci hangi alanın reddedildiğini mesajı parse etmeden
+     * okur.
+     */
+    refuse(message: string, opts?: {
+        detail?: string;
+        hint?: string;
+        column?: string;
+    }): GuardDef;
+}
+declare function guard(name: string): GuardBuilder;
+
+/**
+ * backfill.ts — DDL'DEN AYRI, İZLENEN, BİR KEZ KOŞAN fiil (C-6, FR-033/FR-034).
+ *
+ * Bir sütun eklemek bildirimseldir; o sütunu DOLDURMAK değildir. Doldurma
+ * bugüne kadar `raw()` içinde yaşıyordu ve `raw()` her deploy'da yeniden
+ * koşulan bir DDL bloğu — yani veri düzeltmesi ya elle bir kez çalıştırılıyor
+ * (kayıt yok, tekrarı belirsiz) ya da idempotent yazılmak zorunda kalıyordu.
+ *
+ * `backfills:` o işi kendi aşamasına alır: DDL'den SONRA, kendi işleminde ve
+ * ADI BAŞINA BİR KEZ. Kayıt `public.palbase_backfills` tablosunda tutulur, yani
+ * "koştu mu" sorusunun cevabı veritabanının kendisinde durur.
+ */
+/** Bir backfill bildirimi — C-6 (FR-033). */
+interface BackfillDef {
+    name: string;
+    sql: string;
+}
+/**
+ * `backfill("<ad>", "<sql>")` — bir kez koşacak veri düzeltmesi.
+ *
+ * ```ts
+ * backfills: [
+ *   backfill("ledger_currency_try", "UPDATE ledger SET currency = 'TRY' WHERE currency IS NULL"),
+ * ]
+ * ```
+ *
+ * AD, KAYDIN TA KENDİSİ. "Bu koştu mu?" sorusu ada göre cevaplanıyor, gövdeye
+ * göre değil: adı sabit tutup SQL'i değiştirmek İKİNCİ bir koşu ÜRETMEZ. Bir
+ * düzeltmeyi düzeltmek istiyorsan yeni bir ad verirsin — aynı adın altında
+ * değişen bir gövde, canlıda hangi sürümün koştuğunu belirsiz bırakırdı.
+ *
+ * Bu yüzden BOŞ SQL de reddediliyor: boş bir gövde adı kayda geçirir ve o adı
+ * KALICI olarak yakar — sonradan yazılan gerçek SQL "zaten koştu" diye hiç
+ * çalışmaz, hiçbir yerde hata da vermez.
+ *
+ * SQL verbatim emit edilir (`raw()` ve `policy().using("…")` ile aynı güven
+ * duruşu) ve `raw()` ile AYNI ayrıcalıklı DDL bağlantısında koşar — yalnızca
+ * KENDİ AŞAMASINDA, yani DDL'den ayrı bir `Exec`'te. Ayrım budur ve tek başına
+ * bir güvenlik iddiası DEĞİLDİR.
+ *
+ * Bu yorum daha önce "ayrıcalıklı DDL bağlantısında değil" diyordu ve YANLIŞTI.
+ * Yanlış olduğu ölçüldü, ve niçin kayda geçtiği önemli: tam olarak bir
+ * inceleyicinin "backfill güvenli" diye geçmesine sebep olacak cümleydi.
+ *
+ * Bu yüzden gövde `raw()` ile AYNI AST yetki kapısından geçiyor: rol yaratan,
+ * sahiplik devreden, yetki dağıtan ya da `search_path` kaydıran bir ifade
+ * taşıyan bir backfill push'u reddeder. Veri düzeltmesi veri düzeltmesidir.
+ */
+declare function backfill(name: string, sql: string): BackfillDef;
+
 /**
  * A named raw-SQL DDL object declared in a schema file (`db/public.ts`,
- * `db/billing.ts`, …) for anything the typed DSL
- * cannot express (EXCLUDE, CHECK, partial/expression indexes, triggers, views).
+ * `db/billing.ts`, …) for what the typed DSL cannot express: an index method
+ * other than btree (`gin`, `gist`, `brin`, `hash`), an opclass, `CONCURRENTLY`,
+ * `EXCLUDE` constraints, views, and PL/pgSQL functions.
+ *
+ * REACH FOR THE TYPED FIELD FIRST. Most of what this list used to name is
+ * declarative today and should not come through here:
+ *   - a CHECK constraint      → `checks: [{ name, expr }]`, or the typed
+ *                               `checks: (c) => [check(name, c.col("n").gt(0))]`
+ *   - a partial index         → `index(n).on(…).where(…)`
+ *   - an expression index     → `index(n).onExpression("lower(email)")`
+ *   - a covering index        → `index(n).on(…).include([…])`
+ *   - a UNIQUE or PARTIAL UNIQUE index → `index(n).unique().where(…)`
+ *   - a composite FOREIGN KEY → `foreignKeys: (c) => [foreignKey(n).on(…).references(…)]`
+ *   - a conditional FK        → `freeze: (c) => [freeze(n).when(…).columns(…).references(…)]`
+ *   - a trigger that refuses a write → `guards: (g) => [guard(n).on(…).refuse(…)]`
+ *   - a one-off data fix      → `backfills: [backfill(name, sql)]`
+ *   - dropping a constraint   → `dropConstraints: ["name"]`
+ * Those are diffed, validated against the live database before the push, and
+ * their mistakes answer you where you write them. A `raw()` is none of that.
+ *
  * The deploy emits `up` verbatim on the privileged DDL connection — same trust
- * posture as policy().using(). Tracked by NAME (not by diffing the body), so a
- * changed body needs a new name or an explicit drop+add.
+ * posture as policy().using(). How a CHANGED body is treated depends on what
+ * `name` addresses:
+ *   - names a constraint or an index → tracked by NAME only; the deploy sees
+ *     the catalog object and skips, so an edited body does nothing. Use a new
+ *     name, or drop and re-add explicitly.
+ *   - names nothing in the catalog (functions, triggers, grants, compound
+ *     statements) → the last applied body is recorded in
+ *     `public.palbase_raw_objects` in the same DDL transaction, and an edited
+ *     body IS re-applied.
+ *
+ * There is no teardown option — not on the call, and not on this type. One used
+ * to be accepted and was carried into a generated `Down` that NOTHING ever ran:
+ * the engine's `MigrationFiles.Down` has no consumer and the rollback path names
+ * a `runner.go` that does not exist, so an author who wrote one believed they had
+ * a teardown they did not have. `raw()` stopped ACCEPTING it first, and the field
+ * outlived the parameter — an object literal (`raw: [{ name, up, down }]`) still
+ * compiled and still set a field nothing read. Drop what a `raw()` created by
+ * declaring the drop as its own `raw()`.
  */
 interface RawConstraintDef {
     name: string;
     up: string;
-    down?: string;
 }
-declare function raw(name: string, up: string, opts?: {
-    down?: string;
-}): RawConstraintDef;
+declare function raw(name: string, up: string): RawConstraintDef;
 
 /** Embedding sağlayıcı DESKRIPTORU — canlı istemci değil, düz veri: şemayla
  * birlikte serileşir, çağrıyı Go worker (yazma) ve engine (sorgu) yapar.
@@ -1201,6 +1585,12 @@ interface MemoryDecl {
  */
 interface IndexDef {
     name: string;
+    /**
+     * `CREATE UNIQUE INDEX` (FR-007). `unique: [{name, columns}]` bir UNIQUE
+     * CONSTRAINT üretir ve constraint'in `WHERE`'i olamaz; `index()` partial
+     * olabilir ama unique olamıyordu. İki yarım vardı, birleşmiyorlardı.
+     */
+    unique?: boolean;
     columns?: string[];
     expression?: string;
     where?: PolicyExpr;
@@ -1230,6 +1620,12 @@ interface IndexDef {
 declare class IndexBuilder {
     readonly _def: IndexDef;
     constructor(name: string);
+    /**
+     * `CREATE UNIQUE INDEX` (FR-007). `.where()` ile birlikte PARTIAL UNIQUE
+     * index verir (FR-007b) — "NULL'lar serbest, non-NULL'lar tekil" kalıbının
+     * tek bildirimsel yolu.
+     */
+    unique(): this;
     /** Index'in kolonları. SIRA KORUNUR — çok kolonlu bir index'in anlamı sırasıdır. */
     on(...cols: PolicyExprRef[]): this;
     /**
@@ -1305,13 +1701,25 @@ interface TableInput<C extends ColumnMap = ColumnMap> {
     /**
      * Named first-class CHECK constraints. Diffed by NAME with a BODY compare:
      * a changed `expr` (after pg normalization) recreates the constraint
-     * (DROP + ADD). `expr` is trusted SQL emitted verbatim (like policy USING),
-     * `name` is identifier-validated.
+     * (DROP + ADD). `name` is identifier-validated.
+     *
+     * İKİ BİÇİM, TEK TEL (FR-009, FR-011):
+     *
+     * - DİZİ — `expr` verbatim yayılan güvenilen SQL (policy `using` gibi).
+     *   Bugünkü biçim, olduğu gibi kabul edilmeye devam ediyor.
+     * - CALLBACK — `(c) => [check(name, c.col("amount").gt(0))]`: ifade POLİTİKA
+     *   ifade cebiriyle yazılıyor ve kolon adları DERLEME anında doğrulanıyor.
+     *   Callback olması bunun şartı: `checks` düz bir dizi olsaydı TypeScript
+     *   `columns`'tan kolon adlarını çıkarıp ifadeyi onlarla bağlamlandıramazdı.
+     *
+     * Yanlış yazılmış bir kolon adı string biçiminde ancak
+     * `ALTER TABLE … ADD CONSTRAINT` anında — deploy'un ORTASINDA — Postgres'ten
+     * dönüyor. Tipli biçim aynı cevabı yazma anına taşıyor.
+     *
+     * Tipli ifade CHECK bağlamının DAR kümesine tabi: `existsIn` ve `auth.uid()`
+     * alt sorgu oldukları için `check()` tarafından reddediliyor (FR-010).
      */
-    checks?: {
-        name: string;
-        expr: string;
-    }[];
+    checks?: CheckDef[] | ((c: PolicyExprCtx<Extract<keyof C, string>>) => CheckDef[]);
     /**
      * Plain (non-unique) btree indexes over an ordered column list, emitted as
      * standalone `CREATE INDEX [IF NOT EXISTS] name ON table (col1, col2)`
@@ -1319,12 +1727,85 @@ interface TableInput<C extends ColumnMap = ColumnMap> {
      * Structural compare by NAME (no expression normalization). `name` and each
      * column are identifier-validated by the Go differ.
      *
-     * Scope: columns-only plain btree. Partial (`where`) and expression indexes
-     * are a deliberate follow-up — modelling them needs the same raw-SQL
-     * normalization round-trip CHECK uses (Task 10), so they are NOT in this
-     * type yet to avoid a half-working partial-index path.
+     * NAME is the WHOLE diff key. Editing `.where()`, `.onExpression()`,
+     * `.include()` or the sort under a name that is already live does NOTHING —
+     * the deploy matches the name, sees the index, and skips. Give a changed
+     * definition a new name.
+     *
+     * Scope, via `index(name)`: `.on(...cols)` · `.onExpression(sql)` (expression
+     * index) · `.where(pred)` (partial index, typed predicate) · `.unique()`
+     * (UNIQUE, and WITH `.where()` a PARTIAL UNIQUE index) · `.include(cols)`
+     * (covering) · `.asc()`/`.desc()`/`.nulls()`. Predicates and expressions are
+     * probed against the live database before the push — as a prepared statement
+     * AND as a real CREATE INDEX on an empty `LIKE` clone, which is what catches
+     * a subquery predicate or a non-IMMUTABLE function before the apply.
+     *
+     * `index(n).unique().where(p)` is the ONE declarative way to say "NULLs are
+     * free, non-NULLs are unique" — the table-level `unique:` cannot carry a
+     * predicate, because it renders a CONSTRAINT and PostgreSQL has no partial
+     * unique CONSTRAINT (only a partial unique INDEX).
+     *
+     * NOT expressible here: another index method (gin/gist/brin/hash), an
+     * opclass, or CONCURRENTLY.
      */
     indexes?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (IndexBuilder | IndexDef)[];
+    /**
+     * Canlıdan DÜŞÜRÜLECEK constraint adları (FR-008).
+     *
+     * Differ additive: canlıda olup bildirimde olmayan bir constraint asla
+     * düşürülmez — beyan dosyası veritabanının nesnelerine sahip değildir. Bu
+     * alan o kuralın TEK istisnası ve açıkça yazılmış olması gerekiyor.
+     *
+     * Ad bilinçli olarak `retired` DEĞİL: bu DSL'de `retired` zaten "emekliye
+     * ayrılmış ÇAĞRI biçimi" demek (`schema-retired-call.test.ts`).
+     */
+    dropConstraints?: string[];
+    /**
+     * Tablo düzeyinde, ÇOK SÜTUNLU FOREIGN KEY'ler (FR-001).
+     *
+     * Kolon üzerindeki `.references()` tek sütunlu ve tek hedeflidir; çok kiracılı
+     * bütünlüğün istediği `FOREIGN KEY (tenant_id, child_id) REFERENCES parent
+     * (tenant_id, id)`'yi ifade edemez. İki yol birbirini DÜŞÜRMEZ: bu bildirim
+     * kendi adıyla, kolon üzerindekiler `<tablo>_<kolon>_fkey` ile izlenir.
+     */
+    foreignKeys?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (ForeignKeyBuilder | ForeignKeyDef)[];
+    /**
+     * KOŞULLU FK'lar — bir koşul sağlandığı sürece donan demetler (FR-012).
+     *
+     * "Ödeme `settled` olduğu sürece faturanın tutarı değişemez" bir trigger
+     * istemiyor: koşul sağlanmıyorken NULL veren `STORED` generated sütunlar ve
+     * onlardan `ON UPDATE RESTRICT` bir FK, `MATCH SIMPLE`'ın NULL kaçışı
+     * üzerinden aynı şeyi CONSTRAINT olarak veriyor.
+     *
+     * `foreignKeys` ile aynı sebeple callback: `when` yüklemi TABLONUN KENDİ
+     * kolonlarından çözülüyor ve yanlış ad derleme hatası oluyor.
+     */
+    freeze?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (FreezeBuilder | FreezeDef)[];
+    /**
+     * Bu tablonun GUARD'ları — bildirimsel kısıtın yetişemediği yazma redleri
+     * (FR-015).
+     *
+     * Yazar üç şey yazar: hangi olay · hangi koşul · ne diyerek reddet. `BEFORE`,
+     * `FOR EACH ROW`, `SECURITY INVOKER`, pinlenmiş `search_path` ve `UPDATE OF`
+     * türetimi güvenli VARSAYILAN — bu yüzeyde görünmezler (FR-017).
+     *
+     * `policies` ile aynı sebeple callback: koşul TABLONUN KENDİ kolonlarından
+     * çözülüyor ve yanlış bir ad derleme hatası oluyor. Bir guard'da yanlış kolon
+     * adı, hiç ateşlemeyen bir guard demektir — güvenlik yolunda fail-open.
+     */
+    guards?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (GuardBuilder | GuardDef)[];
+    /**
+     * BİR KEZ koşacak veri düzeltmeleri — DDL'den AYRI bir aşamada (FR-033).
+     *
+     * Sütun eklemek bildirimseldir, o sütunu DOLDURMAK değildir: doldurma bugüne
+     * kadar her deploy'da yeniden koşan bir `raw()` bloğunun içindeydi. Burası o
+     * işin kendi aşaması; kayıt ada göre tutuluyor ve aynı ad ikinci kez koşmuyor
+     * (FR-034).
+     *
+     * `policies`/`guards`'ın aksine düz bir dizi: bir backfill'in yüklemi yok,
+     * gövdesi verbatim SQL — bağlamlandıracak bir kolon adı da yok.
+     */
+    backfills?: BackfillDef[];
     /**
      * appendOnly (FR-030): tablo yalnız INSERT kabul eder — UPDATE/DELETE hem
      * veritabanı yetkisiyle hem üretilen tipte reddedilir (T017/T018).
@@ -1363,13 +1844,21 @@ interface TableDef<C extends ColumnMap = ColumnMap> {
     }[];
     /** Named raw-SQL DDL objects emitted verbatim on deploy. Tracked by name. */
     raw?: RawConstraintDef[];
-    /** Named first-class CHECK constraints. Diffed by name + (normalized) body. */
-    checks?: {
-        name: string;
-        expr: string;
-    }[];
+    /** Named first-class CHECK constraints. Diffed by name + (normalized) body.
+     * İki yazım biçimi de (dizi / callback) BURAYA iner — bkz. TableInput.checks. */
+    checks?: CheckDef[];
     /** Index bildirimleri; partial/expression/sıra/covering alanlarıyla (FR-041…043). */
     indexes?: IndexDef[];
+    /** Canlıdan düşürülecek constraint adları (FR-008). */
+    dropConstraints?: string[];
+    /** Tablo düzeyi çok sütunlu FOREIGN KEY bildirimleri (FR-001). */
+    foreignKeys?: ForeignKeyDef[];
+    /** Koşullu FK ("donan demet") bildirimleri (FR-012). */
+    freeze?: FreezeDef[];
+    /** Guard bildirimleri — bildirimsel kısıtın yetişemediği yazma redleri (FR-015). */
+    guards?: GuardDef[];
+    /** Bir kez koşacak veri düzeltmeleri, DDL'den ayrı aşamada (FR-033). */
+    backfills?: BackfillDef[];
     /** appendOnly (FR-030) — bkz. TableInput. */
     appendOnly?: boolean;
     /** Arama beyanı, doğrulanmış ve taşınmış hali. */
@@ -1410,10 +1899,10 @@ type TablesByName<T extends readonly TableHandle[]> = {
  *       title: text().notNull(),
  *     },
  *     rls: true,
- *     policies: [
+ *     policies: (p) => [
  *       policy("owner_all").for("all").to("authenticated")
- *         .using("owner = (select auth.uid())")
- *         .withCheck("owner = (select auth.uid())"),
+ *         .using(p.col("owner").eq(p.auth.uid()))
+ *         .withCheck(p.col("owner").eq(p.auth.uid())),
  *     ],
  *   });
  *
@@ -4288,6 +4777,7 @@ type EnvServiceDatabase = EnvSchemaSurface & {
     $supersede: DBClient["supersede"];
     $claim: DBClient["claim"];
     $lockRows: DBClient["lockRows"];
+    $lockRowsWhere: DBClient["lockRowsWhere"];
     $advisoryXactLock: DBClient["advisoryXactLock"];
     $attempt: DBClient["attempt"];
     $command<T>(fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T, options?: CommandOptions): Promise<Materialized<T>>;
@@ -4359,6 +4849,7 @@ type EnvTypedDatabase = EnvSchemaSurface & {
     $supersede: DBClient["supersede"];
     $claim: DBClient["claim"];
     $lockRows: DBClient["lockRows"];
+    $lockRowsWhere: DBClient["lockRowsWhere"];
     $advisoryXactLock: DBClient["advisoryXactLock"];
     $attempt: DBClient["attempt"];
     $command<T>(fn: (tx: TxPlan) => T extends Promise<unknown> ? never : T, options?: CommandOptions): Promise<Materialized<T>>;
@@ -4984,8 +5475,12 @@ declare class SerializationFailure extends Conflict implements RetryableError {
  * Postgres birini seçip iptal etti.
  *
  * Bu hatayı GÖRMEK bir tasarım sinyali: kilit sırası deterministik değilse
- * tekrar denemek yalnız maliyeti öteler. `Database.$lockRows(...)` (FR-035)
- * ya da çok satırlı yazmanın CTE'si (FR-015) sırayı sabitler.
+ * tekrar denemek yalnız maliyeti öteler. Sırayı sabitleyen üç şey var ve
+ * hangisinin geçerli olduğunu ELİNDEKİ belirler: satırların id'leri elindeyse
+ * `Database.$lockRows(tablo, id'ler)`, elinde bir FİLTRE varsa
+ * `Database.$lockRowsWhere(tablo, filtre)` (FR-037 — birincil anahtara göre
+ * sıralayarak kilitler, yani `updateMany` ile aynı sırayı paylaşır), ya da çok
+ * satırlı yazmanın CTE'si (FR-015).
  */
 declare class DeadlockDetected extends Conflict implements RetryableError {
     readonly retryable: true;
@@ -5203,6 +5698,37 @@ interface DBOps {
      * `FOR NO KEY UPDATE` — `updateMany`'nin CTE'siyle aynı mod.
      */
     lockRows(table: string, ids: readonly string[]): Promise<void>;
+    /**
+     * Bir FİLTRENİN eşleştiği satırları kilitle — sırayı yine KATMAN koyar
+     * (FR-037).
+     *
+     * `lockRows` kilitlenecek kümeyi çağıranın SAYMASINI istiyor. "Bu hesabın
+     * bekleyen bütün hareketlerini kilitle" bunu yapamaz: id listesi ancak bir
+     * sorguyla çıkar, ve o sorgu ile kilit arasındaki boşluk tam olarak kilidin
+     * kapatması gereken yarıştır. Bu biçim kümeyi TEK statement'ta hem seçer hem
+     * kilitler.
+     *
+     * ```ts
+     * await db.lockRowsWhere("entries", { account_id: id, status: "pending" });
+     * const rows = await db.findMany("entries", { account_id: id, status: "pending" });
+     * ```
+     *
+     * `ORDER BY <pk>` — `updateMany`'nin kilit CTE'siyle AYNI sıra, yani aynı
+     * satır kümesine giren iki yol birbirini deadlock'a sokmaz (FR-037b, canlı
+     * kanıt: `v2/internal/schema/lock_order_test.go`).
+     *
+     * MOD ÇAĞIRANIN SEÇİMİ ve eşitlenmez: `"update"` (varsayılan, `FOR UPDATE`),
+     * `"share"` (`FOR SHARE` — "ben okurken kimse değiştirmesin"), `"noKeyUpdate"`
+     * (`FOR NO KEY UPDATE` — `updateMany`'nin modu, anahtar dışı alanları
+     * değiştirecek yazmalar için). Herkesi tek moda zorlamak, okuma kilidi
+     * isteyeni ihtiyacından fazlasını almaya zorlardı.
+     *
+     * BOŞ FİLTRE REDDEDİLİR: bütün tabloyu kilitlemek kazayla ulaşılacak bir yer
+     * değil.
+     */
+    lockRowsWhere(table: string, where: Record<string, unknown>, opts?: {
+        mode?: "update" | "share" | "noKeyUpdate";
+    }): Promise<void>;
     /**
      * Bir ADI kilitle — satırı değil (FR-054). Kilitlenecek satırı olmayan
      * işler için ("aynı anda tek bir fatura kapanışı koşsun").
@@ -5614,4 +6140,4 @@ type Middleware = (ctx: MiddlewareContext, next: () => Promise<void>) => Promise
  */
 type AuthSpec = boolean | Partial<AuthConfig>;
 
-export { Flags as $, type AuthSpec as A, BadRequest as B, type CommandOptions as C, type DatabaseBudget as D, type EnvServiceDatabase as E, Conflict as F, Database as G, HttpError as H, type DatabaseQueryEvent as I, DeadlockDetected as J, Documents as K, EXTENSION_DEPENDENCIES as L, type EmbeddingModelRef as M, type EnvSchemas as N, type EnvTables as O, type Page as P, type EnvTypedDatabase as Q, type RateLimitConfig as R, type SchemaDef as S, type TransactionIsolation as T, type EnvTypedTable as U, type ErrorDef as V, type ErrorMap as W, type ErrorThrowers as X, type FileContext as Y, type FindManyOpts as Z, __runWithRuntime as _, type DBClient as a, type PalbaseFlagValue as a$, Forbidden as a0, type HttpMethod as a1, IndexBuilder as a2, type IndexDef as a3, type InsertManyOptions as a4, type InsertShape as a5, type InsertValues as a6, type LifecycleHook as a7, Log as a8, type Logger as a9, type PalbaseBatchSetOverridesResult as aA, type PalbaseBindDeviceParams as aB, type PalbaseBucketClient as aC, type PalbaseClearAllOverridesResult as aD, type PalbaseClearOverrideResult as aE, type PalbaseCohortQueryInput as aF, type PalbaseCohortResult as aG, type PalbaseCollectionRef as aH, type PalbaseCountQueryInput as aI, type PalbaseCountResult as aJ, type PalbaseCreateLinkParams as aK, type PalbaseDeviceInfo as aL, type PalbaseDeviceTokenView as aM, type PalbaseDocsClient as aN, type PalbaseDocumentRef as aO, type PalbaseDocumentSnapshot as aP, type PalbaseEmailClient as aQ, type PalbaseEmailSendParams as aR, type PalbaseEmailSendResponse as aS, type PalbaseEventNamesResult as aT, type PalbaseEventsQueryInput as aU, type PalbaseEventsResult as aV, type PalbaseExtension as aW, type PalbaseFileObject as aX, type PalbaseFlag as aY, type PalbaseFlagContext as aZ, type PalbaseFlagSource as a_, type Materialized as aa, type Middleware as ab, type MiddlewareContext as ac, type MiddlewareHandler as ad, type MutateInput as ae, NotFound as af, Notifications as ag, type OnDeleteAction as ah, type OrderBySpec as ai, PALBASE_EXTENSIONS as aj, type PBRequest as ak, type PageInfo as al, type PageInput as am, type PageNavigation as an, PalError as ao, type PalbaseAnalyticsClient as ap, type PalbaseAnalyticsManagementNamespace as aq, type PalbaseAnalyticsProperties as ar, type PalbaseAnalyticsQueryNamespace as as, type PalbaseAttestAndroidParams as at, type PalbaseAttestAndroidResult as au, type PalbaseAttestiOSParams as av, type PalbaseAttestiOSResult as aw, type PalbaseAuthAdminClient as ax, type PalbaseAuthClient as ay, type PalbaseBatchOverrideOperation as az, type RuntimeServices as b, type PolicyDef as b$, type PalbaseFlagVariant as b0, type PalbaseFlagsClient as b1, type PalbaseFlagsServiceClient as b2, type PalbaseFunctionsClient as b3, type PalbaseFunnelQueryInput as b4, type PalbaseFunnelResult as b5, type PalbaseIdentifyTraits as b6, type PalbaseInboxClient as b7, type PalbaseInboxListOptions as b8, type PalbaseInboxListResult as b9, type PalbaseRetentionQueryInput as bA, type PalbaseRetentionResult as bB, type PalbaseSession as bC, type PalbaseSetOverrideResult as bD, type PalbaseSetOverridesResult as bE, type PalbaseSignedUrlResponse as bF, type PalbaseSmsClient as bG, type PalbaseSmsSendParams as bH, type PalbaseSmsSendResponse as bI, type PalbaseStorageClient as bJ, type PalbaseTransformOptions as bK, type PalbaseUpdateLinkParams as bL, type PalbaseUploadOptions as bM, type PalbaseUser as bN, type PalbaseUserDetailResult as bO, type PalbaseUsersQueryInput as bP, type PalbaseUsersResult as bQ, type PalbaseVerifyRequestSignatureParams as bR, type PalbaseWhatsAppClient as bS, type PalbaseWhatsAppEvent as bT, type PalbaseWhatsAppSendParams as bU, type PalbaseWhatsAppSendResponse as bV, type PalbaseWhatsAppTemplate as bW, type PalbaseWhereOperator as bX, type PolicyBinOp as bY, PolicyBuilder as bZ, type PolicyCommand as b_, type PalbaseInboxMessage as ba, type PalbaseInboxSendParams as bb, type PalbaseInboxSendResponse as bc, type PalbaseInitialLink as bd, type PalbaseInvokeOptions as be, type PalbaseLink as bf, type PalbaseLinkAnalytics as bg, type PalbaseLinkDetails as bh, type PalbaseLinksClient as bi, type PalbaseListLinksOptions as bj, type PalbaseListLinksResult as bk, type PalbaseListOptions as bl, type PalbaseMatchParams as bm, type PalbaseMultiChannelResponse as bn, type PalbaseNotificationChannel as bo, type PalbaseNotificationsClient as bp, type PalbaseOverviewResult as bq, type PalbasePreferences as br, type PalbasePreferencesClient as bs, type PalbasePushClient as bt, type PalbasePushSendParams as bu, type PalbasePushSendResponse as bv, type PalbaseQrCodeOptions as bw, type PalbaseQuerySnapshot as bx, type PalbaseRealtimeClient as by, type PalbaseRegisterDeviceParams as bz, type DatabaseDiagnosticsOptions as c, col as c$, type PolicyExprCtx as c0, PolicyExprRef as c1, type PolicyMode as c2, type PolicyOperand as c3, type QueryInput as c4, type RawConstraintDef as c5, Realtime as c6, type Ref as c7, type RequestStore as c8, type RowShape as c9, type TxSetShape as cA, type TxSetValue as cB, type TxTable as cC, type TxTables as cD, type TxWhere as cE, type TxWireExpr as cF, type TxWireGuard as cG, type TxWireOp as cH, type TxWireRef as cI, type TxWireValue as cJ, type TypedDB as cK, type TypedTable as cL, type TypedTx as cM, Unauthorized as cN, UniqueViolation as cO, type UniqueWhere as cP, type User as cQ, type VerifiedDevice as cR, type WhereFilter as cS, type WhereOp as cT, __getRuntime as cU, __resetLifecycleHooks as cV, __runStartHooks as cW, __setRuntime as cX, bigint as cY, boolean as cZ, can as c_, Secrets as ca, type SecretsService as cb, SerializationFailure as cc, type SetShape as cd, type SetValue as ce, type ShutdownRunner as cf, type SqlFragment as cg, Storage as ch, TABLE_META as ci, type TableDef as cj, type TableHandle as ck, type TableInput as cl, TooManyRequests as cm, type TxColumnExpr as cn, type TxInsertShape as co, type TxInsertValue as cp, type TxNow as cq, type TxPlan as cr, TxPlanError as cs, type TxPlanHandle as ct, type TxPlanOpResult as cu, type TxPlanRejection as cv, TxRefError as cw, type TxRow as cx, type TxRows as cy, type TxSelectOptions as cz, type DatabaseDiagnostics as d, dec as d0, decrement as d1, defineMiddleware as d2, defineSchema as d3, defineTable as d4, enumType as d5, exprCtx as d6, inc as d7, increment as d8, index as d9, installationRef as da, integer as db, isPalbaseExtension as dc, isRetryable as dd, jsonb as de, makeTypedDB as df, now as dg, numeric as dh, onShutdown as di, onStart as dj, openai as dk, ownedByUser as dl, policy as dm, raw as dn, sqlFragment as dp, text as dq, timestamp as dr, userRef as ds, uuid as dt, vector as du, withRetry as dv, type DBOps as e, type RawPageOptions as f, type TxPlanBody as g, type TxPlanResponse as h, type CacheClient as i, __requestALS as j, type PalbaseResult as k, type PolicyExpr as l, type AggregateInput as m, type AggregateResult as n, type AnyColumn as o, type AtomicDatabase as p, type AtomicOptions as q, Auth as r, type AuthConfig as s, Cache as t, type ClientInfo as u, type ColRef as v, ColumnBuilder as w, type ColumnDef as x, type ColumnMap as y, type ColumnType as z };
+export { type FileContext as $, type AuthSpec as A, type BackfillDef as B, type CommandOptions as C, type DatabaseBudget as D, type EnvServiceDatabase as E, type ColumnMap as F, type ColumnType as G, HttpError as H, Conflict as I, Database as J, type DatabaseQueryEvent as K, DeadlockDetected as L, Documents as M, EXTENSION_DEPENDENCIES as N, type EmbeddingModelRef as O, type Page as P, type EnvSchemas as Q, type RateLimitConfig as R, type SchemaDef as S, type TransactionIsolation as T, type EnvTables as U, type EnvTypedDatabase as V, type EnvTypedTable as W, type ErrorDef as X, type ErrorMap as Y, type ErrorThrowers as Z, __runWithRuntime as _, type DBClient as a, type PalbaseEmailClient as a$, type FindManyOpts as a0, type FkAction as a1, type FkMatch as a2, Flags as a3, Forbidden as a4, ForeignKeyBuilder as a5, type ForeignKeyDef as a6, FreezeBuilder as a7, type FreezeDef as a8, GuardBuilder as a9, type PalbaseAnalyticsClient as aA, type PalbaseAnalyticsManagementNamespace as aB, type PalbaseAnalyticsProperties as aC, type PalbaseAnalyticsQueryNamespace as aD, type PalbaseAttestAndroidParams as aE, type PalbaseAttestAndroidResult as aF, type PalbaseAttestiOSParams as aG, type PalbaseAttestiOSResult as aH, type PalbaseAuthAdminClient as aI, type PalbaseAuthClient as aJ, type PalbaseBatchOverrideOperation as aK, type PalbaseBatchSetOverridesResult as aL, type PalbaseBindDeviceParams as aM, type PalbaseBucketClient as aN, type PalbaseClearAllOverridesResult as aO, type PalbaseClearOverrideResult as aP, type PalbaseCohortQueryInput as aQ, type PalbaseCohortResult as aR, type PalbaseCollectionRef as aS, type PalbaseCountQueryInput as aT, type PalbaseCountResult as aU, type PalbaseCreateLinkParams as aV, type PalbaseDeviceInfo as aW, type PalbaseDeviceTokenView as aX, type PalbaseDocsClient as aY, type PalbaseDocumentRef as aZ, type PalbaseDocumentSnapshot as a_, type GuardDef as aa, type GuardEvent as ab, type HttpMethod as ac, IndexBuilder as ad, type IndexDef as ae, type InsertManyOptions as af, type InsertShape as ag, type InsertValues as ah, type LifecycleHook as ai, Log as aj, type Logger as ak, type Materialized as al, type Middleware as am, type MiddlewareContext as an, type MiddlewareHandler as ao, type MutateInput as ap, NotFound as aq, Notifications as ar, type OnDeleteAction as as, type OrderBySpec as at, PALBASE_EXTENSIONS as au, type PBRequest as av, type PageInfo as aw, type PageInput as ax, type PageNavigation as ay, PalError as az, type RuntimeServices as b, type PalbaseUsersResult as b$, type PalbaseEmailSendParams as b0, type PalbaseEmailSendResponse as b1, type PalbaseEventNamesResult as b2, type PalbaseEventsQueryInput as b3, type PalbaseEventsResult as b4, type PalbaseExtension as b5, type PalbaseFileObject as b6, type PalbaseFlag as b7, type PalbaseFlagContext as b8, type PalbaseFlagSource as b9, type PalbaseNotificationsClient as bA, type PalbaseOverviewResult as bB, type PalbasePreferences as bC, type PalbasePreferencesClient as bD, type PalbasePushClient as bE, type PalbasePushSendParams as bF, type PalbasePushSendResponse as bG, type PalbaseQrCodeOptions as bH, type PalbaseQuerySnapshot as bI, type PalbaseRealtimeClient as bJ, type PalbaseRegisterDeviceParams as bK, type PalbaseRetentionQueryInput as bL, type PalbaseRetentionResult as bM, type PalbaseSession as bN, type PalbaseSetOverrideResult as bO, type PalbaseSetOverridesResult as bP, type PalbaseSignedUrlResponse as bQ, type PalbaseSmsClient as bR, type PalbaseSmsSendParams as bS, type PalbaseSmsSendResponse as bT, type PalbaseStorageClient as bU, type PalbaseTransformOptions as bV, type PalbaseUpdateLinkParams as bW, type PalbaseUploadOptions as bX, type PalbaseUser as bY, type PalbaseUserDetailResult as bZ, type PalbaseUsersQueryInput as b_, type PalbaseFlagValue as ba, type PalbaseFlagVariant as bb, type PalbaseFlagsClient as bc, type PalbaseFlagsServiceClient as bd, type PalbaseFunctionsClient as be, type PalbaseFunnelQueryInput as bf, type PalbaseFunnelResult as bg, type PalbaseIdentifyTraits as bh, type PalbaseInboxClient as bi, type PalbaseInboxListOptions as bj, type PalbaseInboxListResult as bk, type PalbaseInboxMessage as bl, type PalbaseInboxSendParams as bm, type PalbaseInboxSendResponse as bn, type PalbaseInitialLink as bo, type PalbaseInvokeOptions as bp, type PalbaseLink as bq, type PalbaseLinkAnalytics as br, type PalbaseLinkDetails as bs, type PalbaseLinksClient as bt, type PalbaseListLinksOptions as bu, type PalbaseListLinksResult as bv, type PalbaseListOptions as bw, type PalbaseMatchParams as bx, type PalbaseMultiChannelResponse as by, type PalbaseNotificationChannel as bz, type DatabaseDiagnosticsOptions as c, type UniqueWhere as c$, type PalbaseVerifyRequestSignatureParams as c0, type PalbaseWhatsAppClient as c1, type PalbaseWhatsAppEvent as c2, type PalbaseWhatsAppSendParams as c3, type PalbaseWhatsAppSendResponse as c4, type PalbaseWhatsAppTemplate as c5, type PalbaseWhereOperator as c6, type PolicyBinOp as c7, PolicyBuilder as c8, type PolicyCommand as c9, type TxInsertShape as cA, type TxInsertValue as cB, type TxNow as cC, type TxPlan as cD, TxPlanError as cE, type TxPlanHandle as cF, type TxPlanOpResult as cG, type TxPlanRejection as cH, TxRefError as cI, type TxRow as cJ, type TxRows as cK, type TxSelectOptions as cL, type TxSetShape as cM, type TxSetValue as cN, type TxTable as cO, type TxTables as cP, type TxWhere as cQ, type TxWireExpr as cR, type TxWireGuard as cS, type TxWireOp as cT, type TxWireRef as cU, type TxWireValue as cV, type TypedDB as cW, type TypedTable as cX, type TypedTx as cY, Unauthorized as cZ, UniqueViolation as c_, type PolicyDef as ca, type PolicyExprCtx as cb, PolicyExprRef as cc, type PolicyMode as cd, type PolicyOperand as ce, type QueryInput as cf, type RawConstraintDef as cg, Realtime as ch, type Ref as ci, type RequestStore as cj, type RowShape as ck, Secrets as cl, type SecretsService as cm, SerializationFailure as cn, type SetShape as co, type SetValue as cp, type ShutdownRunner as cq, type SqlFragment as cr, Storage as cs, TABLE_META as ct, type TableDef as cu, type TableHandle as cv, type TableInput as cw, type TableRef as cx, TooManyRequests as cy, type TxColumnExpr as cz, type DatabaseDiagnostics as d, type User as d0, type VerifiedDevice as d1, type WhereFilter as d2, type WhereOp as d3, __getRuntime as d4, __resetLifecycleHooks as d5, __runStartHooks as d6, __setRuntime as d7, backfill as d8, bigint as d9, onShutdown as dA, onStart as dB, openai as dC, ownedByUser as dD, policy as dE, raw as dF, sqlFragment as dG, text as dH, timestamp as dI, userRef as dJ, uuid as dK, vector as dL, withRetry as dM, boolean as da, can as db, check as dc, col as dd, dec as de, decrement as df, defineMiddleware as dg, defineSchema as dh, defineTable as di, enumType as dj, exprCtx as dk, foreignKey as dl, freeze as dm, guard as dn, inc as dp, increment as dq, index as dr, installationRef as ds, integer as dt, isPalbaseExtension as du, isRetryable as dv, jsonb as dw, makeTypedDB as dx, now as dy, numeric as dz, type DBOps as e, type RawPageOptions as f, type TxPlanBody as g, type TxPlanResponse as h, type CacheClient as i, __requestALS as j, type PalbaseResult as k, type PolicyExpr as l, type AggregateInput as m, type AggregateResult as n, type AnyColumn as o, type AtomicDatabase as p, type AtomicOptions as q, Auth as r, type AuthConfig as s, BadRequest as t, Cache as u, type CheckDef as v, type ClientInfo as w, type ColRef as x, ColumnBuilder as y, type ColumnDef as z };