@voyant-travel/commerce 0.1.0

package/dist/pricing/routes-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-rules.d.ts","sourceRoot":"","sources":["../../src/pricing/routes-rules.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,oBAAoB,CAAA;AA6BvD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAgS1B,CAAA"}

package/dist/pricing/routes-rules.js

@@ -0,0 +1,138 @@
+import { parseJsonBody, parseQuery } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { notFound } from "./routes-shared.js";
+import { pricingService } from "./service.js";
+import { departurePriceOverrideListQuerySchema, dropoffPriceRuleListQuerySchema, extraPriceRuleListQuerySchema, insertDeparturePriceOverrideSchema, insertDropoffPriceRuleSchema, insertExtraPriceRuleSchema, insertOptionPriceRuleSchema, insertOptionStartTimeRuleSchema, insertOptionUnitPriceRuleSchema, insertOptionUnitTierSchema, insertPickupPriceRuleSchema, optionPriceRuleListQuerySchema, optionStartTimeRuleListQuerySchema, optionUnitPriceRuleListQuerySchema, optionUnitTierListQuerySchema, pickupPriceRuleListQuerySchema, updateDeparturePriceOverrideSchema, updateDropoffPriceRuleSchema, updateExtraPriceRuleSchema, updateOptionPriceRuleSchema, updateOptionStartTimeRuleSchema, updateOptionUnitPriceRuleSchema, updateOptionUnitTierSchema, updatePickupPriceRuleSchema, } from "./validation.js";
+export const pricingRuleRoutes = new Hono()
+    .get("/option-price-rules", async (c) => c.json(await pricingService.listOptionPriceRules(c.get("db"), await parseQuery(c, optionPriceRuleListQuerySchema))))
+    .post("/option-price-rules", async (c) => c.json({
+    data: await pricingService.createOptionPriceRule(c.get("db"), await parseJsonBody(c, insertOptionPriceRuleSchema), { eventBus: c.get("eventBus") }),
+}, 201))
+    .get("/option-price-rules/:id", async (c) => {
+    const row = await pricingService.getOptionPriceRuleById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Option price rule not found");
+})
+    .patch("/option-price-rules/:id", async (c) => {
+    const row = await pricingService.updateOptionPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionPriceRuleSchema), { eventBus: c.get("eventBus") });
+    return row ? c.json({ data: row }) : notFound(c, "Option price rule not found");
+})
+    .delete("/option-price-rules/:id", async (c) => {
+    const row = await pricingService.deleteOptionPriceRule(c.get("db"), c.req.param("id"), {
+        eventBus: c.get("eventBus"),
+    });
+    return row ? c.json({ success: true }) : notFound(c, "Option price rule not found");
+})
+    .get("/option-unit-price-rules", async (c) => c.json(await pricingService.listOptionUnitPriceRules(c.get("db"), await parseQuery(c, optionUnitPriceRuleListQuerySchema))))
+    .post("/option-unit-price-rules", async (c) => c.json({
+    data: await pricingService.createOptionUnitPriceRule(c.get("db"), await parseJsonBody(c, insertOptionUnitPriceRuleSchema), { eventBus: c.get("eventBus") }),
+}, 201))
+    .get("/option-unit-price-rules/:id", async (c) => {
+    const row = await pricingService.getOptionUnitPriceRuleById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Option unit price rule not found");
+})
+    .patch("/option-unit-price-rules/:id", async (c) => {
+    const row = await pricingService.updateOptionUnitPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionUnitPriceRuleSchema), { eventBus: c.get("eventBus") });
+    return row ? c.json({ data: row }) : notFound(c, "Option unit price rule not found");
+})
+    .delete("/option-unit-price-rules/:id", async (c) => {
+    const row = await pricingService.deleteOptionUnitPriceRule(c.get("db"), c.req.param("id"), {
+        eventBus: c.get("eventBus"),
+    });
+    return row ? c.json({ success: true }) : notFound(c, "Option unit price rule not found");
+})
+    .get("/option-start-time-rules", async (c) => c.json(await pricingService.listOptionStartTimeRules(c.get("db"), await parseQuery(c, optionStartTimeRuleListQuerySchema))))
+    .post("/option-start-time-rules", async (c) => c.json({
+    data: await pricingService.createOptionStartTimeRule(c.get("db"), await parseJsonBody(c, insertOptionStartTimeRuleSchema)),
+}, 201))
+    .get("/option-start-time-rules/:id", async (c) => {
+    const row = await pricingService.getOptionStartTimeRuleById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Option start time rule not found");
+})
+    .patch("/option-start-time-rules/:id", async (c) => {
+    const row = await pricingService.updateOptionStartTimeRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionStartTimeRuleSchema));
+    return row ? c.json({ data: row }) : notFound(c, "Option start time rule not found");
+})
+    .delete("/option-start-time-rules/:id", async (c) => {
+    const row = await pricingService.deleteOptionStartTimeRule(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Option start time rule not found");
+})
+    .get("/option-unit-tiers", async (c) => c.json(await pricingService.listOptionUnitTiers(c.get("db"), await parseQuery(c, optionUnitTierListQuerySchema))))
+    .post("/option-unit-tiers", async (c) => c.json({
+    data: await pricingService.createOptionUnitTier(c.get("db"), await parseJsonBody(c, insertOptionUnitTierSchema)),
+}, 201))
+    .get("/option-unit-tiers/:id", async (c) => {
+    const row = await pricingService.getOptionUnitTierById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Option unit tier not found");
+})
+    .patch("/option-unit-tiers/:id", async (c) => {
+    const row = await pricingService.updateOptionUnitTier(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateOptionUnitTierSchema));
+    return row ? c.json({ data: row }) : notFound(c, "Option unit tier not found");
+})
+    .delete("/option-unit-tiers/:id", async (c) => {
+    const row = await pricingService.deleteOptionUnitTier(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Option unit tier not found");
+})
+    .get("/pickup-price-rules", async (c) => c.json(await pricingService.listPickupPriceRules(c.get("db"), await parseQuery(c, pickupPriceRuleListQuerySchema))))
+    .post("/pickup-price-rules", async (c) => c.json({
+    data: await pricingService.createPickupPriceRule(c.get("db"), await parseJsonBody(c, insertPickupPriceRuleSchema)),
+}, 201))
+    .get("/pickup-price-rules/:id", async (c) => {
+    const row = await pricingService.getPickupPriceRuleById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Pickup price rule not found");
+})
+    .patch("/pickup-price-rules/:id", async (c) => {
+    const row = await pricingService.updatePickupPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updatePickupPriceRuleSchema));
+    return row ? c.json({ data: row }) : notFound(c, "Pickup price rule not found");
+})
+    .delete("/pickup-price-rules/:id", async (c) => {
+    const row = await pricingService.deletePickupPriceRule(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Pickup price rule not found");
+})
+    .get("/dropoff-price-rules", async (c) => c.json(await pricingService.listDropoffPriceRules(c.get("db"), await parseQuery(c, dropoffPriceRuleListQuerySchema))))
+    .post("/dropoff-price-rules", async (c) => c.json({
+    data: await pricingService.createDropoffPriceRule(c.get("db"), await parseJsonBody(c, insertDropoffPriceRuleSchema)),
+}, 201))
+    .get("/dropoff-price-rules/:id", async (c) => {
+    const row = await pricingService.getDropoffPriceRuleById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Dropoff price rule not found");
+})
+    .patch("/dropoff-price-rules/:id", async (c) => {
+    const row = await pricingService.updateDropoffPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateDropoffPriceRuleSchema));
+    return row ? c.json({ data: row }) : notFound(c, "Dropoff price rule not found");
+})
+    .delete("/dropoff-price-rules/:id", async (c) => {
+    const row = await pricingService.deleteDropoffPriceRule(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Dropoff price rule not found");
+})
+    .get("/extra-price-rules", async (c) => c.json(await pricingService.listExtraPriceRules(c.get("db"), await parseQuery(c, extraPriceRuleListQuerySchema))))
+    .post("/extra-price-rules", async (c) => c.json({
+    data: await pricingService.createExtraPriceRule(c.get("db"), await parseJsonBody(c, insertExtraPriceRuleSchema)),
+}, 201))
+    .get("/extra-price-rules/:id", async (c) => {
+    const row = await pricingService.getExtraPriceRuleById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Extra price rule not found");
+})
+    .patch("/extra-price-rules/:id", async (c) => {
+    const row = await pricingService.updateExtraPriceRule(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateExtraPriceRuleSchema));
+    return row ? c.json({ data: row }) : notFound(c, "Extra price rule not found");
+})
+    .delete("/extra-price-rules/:id", async (c) => {
+    const row = await pricingService.deleteExtraPriceRule(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Extra price rule not found");
+})
+    .get("/departure-price-overrides", async (c) => c.json(await pricingService.listDeparturePriceOverrides(c.get("db"), await parseQuery(c, departurePriceOverrideListQuerySchema))))
+    .post("/departure-price-overrides", async (c) => c.json({
+    data: await pricingService.createDeparturePriceOverride(c.get("db"), await parseJsonBody(c, insertDeparturePriceOverrideSchema)),
+}, 201))
+    .get("/departure-price-overrides/:id", async (c) => {
+    const row = await pricingService.getDeparturePriceOverrideById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Departure price override not found");
+})
+    .patch("/departure-price-overrides/:id", async (c) => {
+    const row = await pricingService.updateDeparturePriceOverride(c.get("db"), c.req.param("id"), await parseJsonBody(c, updateDeparturePriceOverrideSchema));
+    return row ? c.json({ data: row }) : notFound(c, "Departure price override not found");
+})
+    .delete("/departure-price-overrides/:id", async (c) => {
+    const row = await pricingService.deleteDeparturePriceOverride(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Departure price override not found");
+});

package/dist/pricing/routes-shared.d.ts

@@ -0,0 +1,14 @@
+import type { EventBus } from "@voyant-travel/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { Context } from "hono";
+export type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+        eventBus?: EventBus;
+    };
+};
+export declare function notFound(c: Context<Env>, message: string): Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">;
+//# sourceMappingURL=routes-shared.d.ts.map

package/dist/pricing/routes-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-shared.d.ts","sourceRoot":"","sources":["../../src/pricing/routes-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,MAAM,MAAM,GAAG,GAAG;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM;;gBAExD"}

package/dist/pricing/routes-shared.js

@@ -0,0 +1,3 @@
+export function notFound(c, message) {
+    return c.json({ error: message }, 404);
+}

package/dist/pricing/routes.d.ts

@@ -0,0 +1,7 @@
+import { Hono } from "hono";
+import type { publicPricingRoutes } from "./routes-public.js";
+import type { Env } from "./routes-shared.js";
+export declare const pricingRoutes: Hono<Env, import("hono/types").BlankSchema, "/">;
+export type PricingRoutes = typeof pricingRoutes;
+export type PublicPricingRoutes = typeof publicPricingRoutes;
+//# sourceMappingURL=routes.d.ts.map

package/dist/pricing/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/pricing/routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAG3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAE7D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAA;AAE7C,eAAO,MAAM,aAAa,kDAAkB,CAAA;AAI5C,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAA;AAChD,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAA"}

package/dist/pricing/routes.js

@@ -0,0 +1,6 @@
+import { Hono } from "hono";
+import { pricingCoreRoutes } from "./routes-core.js";
+import { pricingRuleRoutes } from "./routes-rules.js";
+export const pricingRoutes = new Hono();
+pricingRoutes.route("/", pricingCoreRoutes);
+pricingRoutes.route("/", pricingRuleRoutes);

package/dist/pricing/schema-catalogs.d.ts

@@ -0,0 +1,467 @@
+export declare const priceCatalogs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "price_catalogs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "price_catalogs";
+            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;
+        }, {}, {}>;
+        code: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code";
+            tableName: "price_catalogs";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "price_catalogs";
+            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;
+        }, {}, {}>;
+        currencyCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "currency_code";
+            tableName: "price_catalogs";
+            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;
+        }, {}, {}>;
+        catalogType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "catalog_type";
+            tableName: "price_catalogs";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "internal" | "other" | "public" | "contract" | "net" | "gross" | "promo";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["public", "contract", "net", "gross", "promo", "internal", "other"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isDefault: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_default";
+            tableName: "price_catalogs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        active: import("drizzle-orm/pg-core").PgColumn<{
+            name: "active";
+            tableName: "price_catalogs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "price_catalogs";
+            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;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "price_catalogs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "price_catalogs";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "price_catalogs";
+            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 declare const priceSchedules: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "price_schedules";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        priceCatalogId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        code: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code";
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        recurrenceRule: import("drizzle-orm/pg-core").PgColumn<{
+            name: "recurrence_rule";
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        timezone: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timezone";
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        validFrom: import("drizzle-orm/pg-core").PgColumn<{
+            name: "valid_from";
+            tableName: "price_schedules";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        validTo: import("drizzle-orm/pg-core").PgColumn<{
+            name: "valid_to";
+            tableName: "price_schedules";
+            dataType: "string";
+            columnType: "PgDateString";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        weekdays: import("drizzle-orm/pg-core").PgColumn<{
+            name: "weekdays";
+            tableName: "price_schedules";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        priority: import("drizzle-orm/pg-core").PgColumn<{
+            name: "priority";
+            tableName: "price_schedules";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        active: import("drizzle-orm/pg-core").PgColumn<{
+            name: "active";
+            tableName: "price_schedules";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "price_schedules";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, unknown>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, unknown>;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "price_schedules";
+            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;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "price_schedules";
+            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 PriceCatalog = typeof priceCatalogs.$inferSelect;
+export type NewPriceCatalog = typeof priceCatalogs.$inferInsert;
+export type PriceSchedule = typeof priceSchedules.$inferSelect;
+export type NewPriceSchedule = typeof priceSchedules.$inferInsert;
+//# sourceMappingURL=schema-catalogs.d.ts.map

package/dist/pricing/schema-catalogs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-catalogs.d.ts","sourceRoot":"","sources":["../../src/pricing/schema-catalogs.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBzB,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+B1B,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC5D,MAAM,MAAM,eAAe,GAAG,OAAO,aAAa,CAAC,YAAY,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC9D,MAAM,MAAM,gBAAgB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA"}