@voyant-travel/catalog 0.117.2

package/dist/overlay/schema.d.ts

@@ -0,0 +1,266 @@
+/**
+ * Overlay store schema — editorial overrides keyed by
+ * `(entity_module, entity_id, field_path, locale, audience, market)`.
+ *
+ * One overlay table serves every vertical. Rows hold the override value plus
+ * provenance about *which* writer (admin UI / CMS plugin / bulk import / AI /
+ * external API) produced the override, for audit and revert workflows.
+ *
+ * See `docs/architecture/catalog-architecture.md` §5.2 for the full design.
+ */
+import type { Visibility } from "../contract.js";
+/**
+ * Audit identifier indicating where an overlay row came from. Discriminated
+ * by `kind`; consumers may pattern-match for revert / filter workflows.
+ */
+export type OverlayOrigin = {
+    kind: "admin-ui";
+    user_id: string;
+} | {
+    kind: "cms";
+    provider: string;
+    cms_doc_id: string;
+} | {
+    kind: "bulk-import";
+    batch_id: string;
+} | {
+    kind: "ai-generated";
+    model: string;
+    prompt_hash?: string;
+} | {
+    kind: "external-api";
+    api_key_id: string;
+};
+/**
+ * Sentinel value used in `locale`, `audience`, and `market` columns to mark
+ * "no specific scope" — the broadest fallback in the resolver chain.
+ */
+export declare const OVERLAY_DEFAULT_SCOPE = "default";
+/**
+ * `catalog_overlay` — single table holding editorial overrides for every
+ * vertical. Composite uniqueness on `(entity_module, entity_id, field_path,
+ * locale, audience, market)` prevents duplicate overlays for the same scope.
+ */
+export declare const catalogOverlayTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "catalog_overlay";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "catalog_overlay";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_module: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_module";
+            tableName: "catalog_overlay";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "catalog_overlay";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        field_path: import("drizzle-orm/pg-core").PgColumn<{
+            name: "field_path";
+            tableName: "catalog_overlay";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        locale: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locale";
+            tableName: "catalog_overlay";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        audience: import("drizzle-orm/pg-core").PgColumn<{
+            name: "audience";
+            tableName: "catalog_overlay";
+            dataType: "string";
+            columnType: "PgText";
+            data: "default" | Visibility;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: "default" | Visibility;
+        }>;
+        market: import("drizzle-orm/pg-core").PgColumn<{
+            name: "market";
+            tableName: "catalog_overlay";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm/pg-core").PgColumn<{
+            name: "value";
+            tableName: "catalog_overlay";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        origin: import("drizzle-orm/pg-core").PgColumn<{
+            name: "origin";
+            tableName: "catalog_overlay";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: OverlayOrigin;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: OverlayOrigin;
+        }>;
+        deleted_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deleted_at";
+            tableName: "catalog_overlay";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        created_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "catalog_overlay";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updated_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "catalog_overlay";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type InsertCatalogOverlay = typeof catalogOverlayTable.$inferInsert;
+export type SelectCatalogOverlay = typeof catalogOverlayTable.$inferSelect;
+/**
+ * Foreign-key column helper for tables that reference an overlay row.
+ * Rare — consumers typically query overlays by entity, not by FK.
+ */
+export declare const overlayIdRef: (columnName: string) => import("drizzle-orm/pg-core").PgTextBuilderInitial<string, [string, ...string[]]>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/overlay/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/overlay/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD;;;GAGG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7D;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhD;;;GAGG;AACH,eAAO,MAAM,qBAAqB,YAAY,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4D/B,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAA;AAC1E,MAAM,MAAM,oBAAoB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAA;AAE1E;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,YAAY,MAAM,sFAA0B,CAAA"}

package/dist/overlay/schema.js

@@ -0,0 +1,71 @@
+/**
+ * Overlay store schema — editorial overrides keyed by
+ * `(entity_module, entity_id, field_path, locale, audience, market)`.
+ *
+ * One overlay table serves every vertical. Rows hold the override value plus
+ * provenance about *which* writer (admin UI / CMS plugin / bulk import / AI /
+ * external API) produced the override, for audit and revert workflows.
+ *
+ * See `docs/architecture/catalog-architecture.md` §5.2 for the full design.
+ */
+import { typeId, typeIdRef } from "@voyant-travel/db/lib/typeid-column";
+import { sql } from "drizzle-orm";
+import { index, jsonb, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+/**
+ * Sentinel value used in `locale`, `audience`, and `market` columns to mark
+ * "no specific scope" — the broadest fallback in the resolver chain.
+ */
+export const OVERLAY_DEFAULT_SCOPE = "default";
+/**
+ * `catalog_overlay` — single table holding editorial overrides for every
+ * vertical. Composite uniqueness on `(entity_module, entity_id, field_path,
+ * locale, audience, market)` prevents duplicate overlays for the same scope.
+ */
+export const catalogOverlayTable = pgTable("catalog_overlay", {
+    id: typeId("catalog_overlay"),
+    // Entity identity (which vertical, which entity).
+    entity_module: text("entity_module").notNull(),
+    entity_id: text("entity_id").notNull(),
+    // Field-policy path the override targets. Validated against the vertical's
+    // field policy at write time (the policy must exist and must allow
+    // overrides for the requesting editor role).
+    field_path: text("field_path").notNull(),
+    // Variant axes. Each defaults to OVERLAY_DEFAULT_SCOPE for entries that
+    // apply across the broadest scope.
+    locale: text("locale").notNull().default(OVERLAY_DEFAULT_SCOPE),
+    audience: text("audience")
+        .$type()
+        .notNull()
+        .default(OVERLAY_DEFAULT_SCOPE),
+    market: text("market").notNull().default(OVERLAY_DEFAULT_SCOPE),
+    // Override value. JSONB to accommodate every field type (strings, lists,
+    // structured objects, etc.). The resolver pairs this with the field policy
+    // to apply the correct merge rule.
+    value: jsonb("value").notNull(),
+    // Provenance: where this override came from.
+    origin: jsonb("origin").$type().notNull(),
+    // Soft-delete. When set, the row is preserved for retention / restore but
+    // no longer active in the resolver merge.
+    deleted_at: timestamp("deleted_at", { withTimezone: true }),
+    created_at: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updated_at: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    // The variant-tuple identifies one overlay row uniquely. `WHERE deleted_at
+    // IS NULL` is enforced via partial unique index so soft-deleted rows can
+    // be re-created without conflict.
+    uniqueIndex("catalog_overlay_variant_uniq")
+        .on(table.entity_module, table.entity_id, table.field_path, table.locale, table.audience, table.market)
+        // agent-quality: raw-sql reviewed -- owner: catalog; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        .where(sql `${table.deleted_at} IS NULL`),
+    // Lookup index for the resolver: given an entity, find all its active
+    // overlays in one query.
+    index("catalog_overlay_entity_idx").on(table.entity_module, table.entity_id, table.deleted_at),
+    // Lookup index for cross-source queries: find overlays by origin (e.g.
+    // "all overlays from this CMS plugin" for revert / re-sync workflows).
+    index("catalog_overlay_origin_idx").on(table.origin),
+]);
+/**
+ * Foreign-key column helper for tables that reference an overlay row.
+ * Rare — consumers typically query overlays by entity, not by FK.
+ */
+export const overlayIdRef = (columnName) => typeIdRef(columnName);

package/dist/provenance.d.ts

@@ -0,0 +1,2 @@
+export * from "@voyant-travel/catalog-contracts/provenance";
+//# sourceMappingURL=provenance.d.ts.map

package/dist/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../src/provenance.ts"],"names":[],"mappings":"AAAA,cAAc,6CAA6C,CAAA"}

package/dist/provenance.js

@@ -0,0 +1 @@
+export * from "@voyant-travel/catalog-contracts/provenance";

package/dist/schema-sourced-entries.d.ts

@@ -0,0 +1,344 @@
+/**
+ * Sourced-entry store — durable provenance + projection capture for every
+ * non-owned entity that lands in the catalog plane via `discover()`.
+ *
+ * This is the load-bearing prerequisite for the content cache, the read
+ * service, drift invalidation, and snapshot capture. All of them assume
+ * there's a durable local row per sourced entity that records *what we
+ * know about it locally* — provenance (which adapter, which connection,
+ * which upstream id), lifecycle (when first seen, when last seen, whether
+ * still active), and the canonical local copy of the indexed projection.
+ *
+ * Owned entities do NOT have a row here — `provenance.source_kind ===
+ * "owned"` reads provenance from the vertical's owned schema. The
+ * sourced-entry store is sourced-only.
+ *
+ * See `docs/architecture/catalog-sourced-content.md` §2.5 for the full
+ * design.
+ */
+import type { SourceFreshness } from "./contract.js";
+/**
+ * Lifecycle status for a sourced entry. Independent of any drift / hold
+ * the booking engine might apply — this tracks whether the upstream still
+ * advertises the entity, not whether it's bookable right now.
+ */
+export type SourcedEntryStatus = "active" | "withdrawn" | "delisted";
+/**
+ * `catalog_sourced_entries` — single durable record per sourced entity,
+ * keyed two ways: by Voyant-side `(entity_module, entity_id)` for
+ * read-path lookup, and by upstream-side `(source_kind,
+ * source_connection_id, source_ref)` for discover-time idempotency.
+ *
+ * The `projection` JSONB column is the canonical local copy of what
+ * `adapter.discover()` returned. Read it for thin-content synthesis (when
+ * the adapter declares `supportsContentFetch: false`) and for
+ * provenance-aware dispatch — never the search index. Search indexes are
+ * optimized for full-text/facet queries, not point-reads of rich detail.
+ */
+export declare const catalogSourcedEntriesTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "catalog_sourced_entries";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_module: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_module";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entity_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "entity_id";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_kind";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string;
+        }>;
+        source_provider: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_provider";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_connection_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_connection_id";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_ref: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_ref";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        source_freshness: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source_freshness";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: SourceFreshness;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: SourceFreshness;
+        }>;
+        last_sourced_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_sourced_at";
+            tableName: "catalog_sourced_entries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: SourcedEntryStatus;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: SourcedEntryStatus;
+        }>;
+        first_seen_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "first_seen_at";
+            tableName: "catalog_sourced_entries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        last_seen_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_seen_at";
+            tableName: "catalog_sourced_entries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        projection: import("drizzle-orm/pg-core").PgColumn<{
+            name: "projection";
+            tableName: "catalog_sourced_entries";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        projection_etag: import("drizzle-orm/pg-core").PgColumn<{
+            name: "projection_etag";
+            tableName: "catalog_sourced_entries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        projection_seen_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "projection_seen_at";
+            tableName: "catalog_sourced_entries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        created_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "catalog_sourced_entries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updated_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "catalog_sourced_entries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type InsertCatalogSourcedEntry = typeof catalogSourcedEntriesTable.$inferInsert;
+export type SelectCatalogSourcedEntry = typeof catalogSourcedEntriesTable.$inferSelect;
+//# sourceMappingURL=schema-sourced-entries.d.ts.map