@voyantjs/pricing 0.2.0 → 0.3.1

package/dist/schema-option-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-option-rules.d.ts","sourceRoot":"","sources":["../src/schema-option-rules.ts"],"names":[],"mappings":"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"}

package/dist/schema-option-rules.js

@@ -0,0 +1,174 @@
+import { typeId, typeIdRef } from "@voyantjs/db/lib/typeid-column";
+import { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { priceCatalogs, priceSchedules } from "./schema-catalogs";
+import { pricingCategories } from "./schema-categories";
+import { cancellationPolicies } from "./schema-policies";
+import { addonPricingModeEnum, optionPricingModeEnum, optionStartTimeRuleModeEnum, optionUnitPricingModeEnum, priceAdjustmentTypeEnum, } from "./schema-shared";
+export const optionPriceRules = pgTable("option_price_rules", {
+    id: typeId("option_price_rules"),
+    productId: text("product_id").notNull(),
+    optionId: text("option_id").notNull(),
+    priceCatalogId: typeIdRef("price_catalog_id")
+        .notNull()
+        .references(() => priceCatalogs.id, { onDelete: "cascade" }),
+    priceScheduleId: typeIdRef("price_schedule_id").references(() => priceSchedules.id, {
+        onDelete: "set null",
+    }),
+    cancellationPolicyId: typeIdRef("cancellation_policy_id").references(() => cancellationPolicies.id, { onDelete: "set null" }),
+    code: text("code"),
+    name: text("name").notNull(),
+    description: text("description"),
+    pricingMode: optionPricingModeEnum("pricing_mode").notNull().default("per_person"),
+    baseSellAmountCents: integer("base_sell_amount_cents"),
+    baseCostAmountCents: integer("base_cost_amount_cents"),
+    minPerBooking: integer("min_per_booking"),
+    maxPerBooking: integer("max_per_booking"),
+    allPricingCategories: boolean("all_pricing_categories").notNull().default(true),
+    isDefault: boolean("is_default").notNull().default(false),
+    active: boolean("active").notNull().default(true),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_option_price_rules_product").on(table.productId),
+    index("idx_option_price_rules_option").on(table.optionId),
+    index("idx_option_price_rules_catalog").on(table.priceCatalogId),
+    index("idx_option_price_rules_schedule").on(table.priceScheduleId),
+    index("idx_option_price_rules_policy").on(table.cancellationPolicyId),
+    index("idx_option_price_rules_active").on(table.active),
+    uniqueIndex("uidx_option_price_rules_option_code").on(table.optionId, table.code),
+]);
+export const optionUnitPriceRules = pgTable("option_unit_price_rules", {
+    id: typeId("option_unit_price_rules"),
+    optionPriceRuleId: typeIdRef("option_price_rule_id")
+        .notNull()
+        .references(() => optionPriceRules.id, { onDelete: "cascade" }),
+    optionId: text("option_id").notNull(),
+    unitId: text("unit_id").notNull(),
+    pricingCategoryId: typeIdRef("pricing_category_id").references(() => pricingCategories.id, {
+        onDelete: "set null",
+    }),
+    pricingMode: optionUnitPricingModeEnum("pricing_mode").notNull().default("per_unit"),
+    sellAmountCents: integer("sell_amount_cents"),
+    costAmountCents: integer("cost_amount_cents"),
+    minQuantity: integer("min_quantity"),
+    maxQuantity: integer("max_quantity"),
+    active: boolean("active").notNull().default(true),
+    sortOrder: integer("sort_order").notNull().default(0),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_option_unit_price_rules_rule").on(table.optionPriceRuleId),
+    index("idx_option_unit_price_rules_option").on(table.optionId),
+    index("idx_option_unit_price_rules_unit").on(table.unitId),
+    index("idx_option_unit_price_rules_category").on(table.pricingCategoryId),
+    index("idx_option_unit_price_rules_active").on(table.active),
+]);
+export const optionStartTimeRules = pgTable("option_start_time_rules", {
+    id: typeId("option_start_time_rules"),
+    optionPriceRuleId: typeIdRef("option_price_rule_id")
+        .notNull()
+        .references(() => optionPriceRules.id, { onDelete: "cascade" }),
+    optionId: text("option_id").notNull(),
+    startTimeId: text("start_time_id").notNull(),
+    ruleMode: optionStartTimeRuleModeEnum("rule_mode").notNull().default("included"),
+    adjustmentType: priceAdjustmentTypeEnum("adjustment_type"),
+    sellAdjustmentCents: integer("sell_adjustment_cents"),
+    costAdjustmentCents: integer("cost_adjustment_cents"),
+    adjustmentBasisPoints: integer("adjustment_basis_points"),
+    active: boolean("active").notNull().default(true),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_option_start_time_rules_rule").on(table.optionPriceRuleId),
+    index("idx_option_start_time_rules_option").on(table.optionId),
+    index("idx_option_start_time_rules_start_time").on(table.startTimeId),
+    uniqueIndex("uidx_option_start_time_rules_rule_start_time").on(table.optionPriceRuleId, table.startTimeId),
+]);
+export const optionUnitTiers = pgTable("option_unit_tiers", {
+    id: typeId("option_unit_tiers"),
+    optionUnitPriceRuleId: typeIdRef("option_unit_price_rule_id")
+        .notNull()
+        .references(() => optionUnitPriceRules.id, { onDelete: "cascade" }),
+    minQuantity: integer("min_quantity").notNull(),
+    maxQuantity: integer("max_quantity"),
+    sellAmountCents: integer("sell_amount_cents"),
+    costAmountCents: integer("cost_amount_cents"),
+    active: boolean("active").notNull().default(true),
+    sortOrder: integer("sort_order").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_option_unit_tiers_rule").on(table.optionUnitPriceRuleId),
+    index("idx_option_unit_tiers_active").on(table.active),
+]);
+export const pickupPriceRules = pgTable("pickup_price_rules", {
+    id: typeId("pickup_price_rules"),
+    optionPriceRuleId: typeIdRef("option_price_rule_id")
+        .notNull()
+        .references(() => optionPriceRules.id, { onDelete: "cascade" }),
+    optionId: text("option_id").notNull(),
+    pickupPointId: text("pickup_point_id").notNull(),
+    pricingMode: addonPricingModeEnum("pricing_mode").notNull().default("included"),
+    sellAmountCents: integer("sell_amount_cents"),
+    costAmountCents: integer("cost_amount_cents"),
+    active: boolean("active").notNull().default(true),
+    sortOrder: integer("sort_order").notNull().default(0),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_pickup_price_rules_rule").on(table.optionPriceRuleId),
+    index("idx_pickup_price_rules_option").on(table.optionId),
+    index("idx_pickup_price_rules_pickup").on(table.pickupPointId),
+    uniqueIndex("uidx_pickup_price_rules_rule_pickup").on(table.optionPriceRuleId, table.pickupPointId),
+]);
+export const dropoffPriceRules = pgTable("dropoff_price_rules", {
+    id: typeId("dropoff_price_rules"),
+    optionPriceRuleId: typeIdRef("option_price_rule_id")
+        .notNull()
+        .references(() => optionPriceRules.id, { onDelete: "cascade" }),
+    optionId: text("option_id").notNull(),
+    facilityId: text("facility_id"),
+    dropoffCode: text("dropoff_code"),
+    dropoffName: text("dropoff_name").notNull(),
+    pricingMode: addonPricingModeEnum("pricing_mode").notNull().default("included"),
+    sellAmountCents: integer("sell_amount_cents"),
+    costAmountCents: integer("cost_amount_cents"),
+    active: boolean("active").notNull().default(true),
+    sortOrder: integer("sort_order").notNull().default(0),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_dropoff_price_rules_rule").on(table.optionPriceRuleId),
+    index("idx_dropoff_price_rules_option").on(table.optionId),
+    index("idx_dropoff_price_rules_facility").on(table.facilityId),
+]);
+export const extraPriceRules = pgTable("extra_price_rules", {
+    id: typeId("extra_price_rules"),
+    optionPriceRuleId: typeIdRef("option_price_rule_id")
+        .notNull()
+        .references(() => optionPriceRules.id, { onDelete: "cascade" }),
+    optionId: text("option_id").notNull(),
+    productExtraId: text("product_extra_id"),
+    optionExtraConfigId: text("option_extra_config_id"),
+    pricingMode: addonPricingModeEnum("pricing_mode").notNull().default("included"),
+    sellAmountCents: integer("sell_amount_cents"),
+    costAmountCents: integer("cost_amount_cents"),
+    active: boolean("active").notNull().default(true),
+    sortOrder: integer("sort_order").notNull().default(0),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_extra_price_rules_rule").on(table.optionPriceRuleId),
+    index("idx_extra_price_rules_option").on(table.optionId),
+    index("idx_extra_price_rules_product_extra").on(table.productExtraId),
+    index("idx_extra_price_rules_option_extra_config").on(table.optionExtraConfigId),
+]);

package/dist/schema-policies.d.ts

@@ -0,0 +1,395 @@
+export declare const cancellationPolicies: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "cancellation_policies";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "cancellation_policies";
+            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: "cancellation_policies";
+            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: "cancellation_policies";
+            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;
+        }, {}, {}>;
+        policyType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "policy_type";
+            tableName: "cancellation_policies";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "simple" | "advanced" | "non_refundable" | "custom";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["simple", "advanced", "non_refundable", "custom"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        simpleCutoffHours: import("drizzle-orm/pg-core").PgColumn<{
+            name: "simple_cutoff_hours";
+            tableName: "cancellation_policies";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isDefault: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_default";
+            tableName: "cancellation_policies";
+            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: "cancellation_policies";
+            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: "cancellation_policies";
+            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: "cancellation_policies";
+            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: "cancellation_policies";
+            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: "cancellation_policies";
+            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 cancellationPolicyRules: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "cancellation_policy_rules";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "cancellation_policy_rules";
+            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;
+        }, {}, {}>;
+        cancellationPolicyId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "cancellation_policy_rules";
+            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;
+        }, {}, {}>;
+        sortOrder: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sort_order";
+            tableName: "cancellation_policy_rules";
+            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;
+        }, {}, {}>;
+        cutoffMinutesBefore: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cutoff_minutes_before";
+            tableName: "cancellation_policy_rules";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        chargeType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "charge_type";
+            tableName: "cancellation_policy_rules";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "none" | "amount" | "percentage";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["none", "amount", "percentage"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        chargeAmountCents: import("drizzle-orm/pg-core").PgColumn<{
+            name: "charge_amount_cents";
+            tableName: "cancellation_policy_rules";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        chargePercentBasisPoints: import("drizzle-orm/pg-core").PgColumn<{
+            name: "charge_percent_basis_points";
+            tableName: "cancellation_policy_rules";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        active: import("drizzle-orm/pg-core").PgColumn<{
+            name: "active";
+            tableName: "cancellation_policy_rules";
+            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: "cancellation_policy_rules";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "cancellation_policy_rules";
+            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: "cancellation_policy_rules";
+            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 CancellationPolicy = typeof cancellationPolicies.$inferSelect;
+export type NewCancellationPolicy = typeof cancellationPolicies.$inferInsert;
+export type CancellationPolicyRule = typeof cancellationPolicyRules.$inferSelect;
+export type NewCancellationPolicyRule = typeof cancellationPolicyRules.$inferInsert;
+//# sourceMappingURL=schema-policies.d.ts.map

package/dist/schema-policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-policies.d.ts","sourceRoot":"","sources":["../src/schema-policies.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBhC,CAAA;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBnC,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAA;AACzE,MAAM,MAAM,qBAAqB,GAAG,OAAO,oBAAoB,CAAC,YAAY,CAAA;AAC5E,MAAM,MAAM,sBAAsB,GAAG,OAAO,uBAAuB,CAAC,YAAY,CAAA;AAChF,MAAM,MAAM,yBAAyB,GAAG,OAAO,uBAAuB,CAAC,YAAY,CAAA"}

package/dist/schema-policies.js

@@ -0,0 +1,38 @@
+import { typeId, typeIdRef } from "@voyantjs/db/lib/typeid-column";
+import { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { cancellationChargeTypeEnum, cancellationPolicyTypeEnum } from "./schema-shared";
+export const cancellationPolicies = pgTable("cancellation_policies", {
+    id: typeId("cancellation_policies"),
+    code: text("code"),
+    name: text("name").notNull(),
+    policyType: cancellationPolicyTypeEnum("policy_type").notNull().default("custom"),
+    simpleCutoffHours: integer("simple_cutoff_hours"),
+    isDefault: boolean("is_default").notNull().default(false),
+    active: boolean("active").notNull().default(true),
+    notes: text("notes"),
+    metadata: jsonb("metadata").$type(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_cancellation_policies_active").on(table.active),
+    index("idx_cancellation_policies_default").on(table.isDefault),
+    uniqueIndex("uidx_cancellation_policies_code").on(table.code),
+]);
+export const cancellationPolicyRules = pgTable("cancellation_policy_rules", {
+    id: typeId("cancellation_policy_rules"),
+    cancellationPolicyId: typeIdRef("cancellation_policy_id")
+        .notNull()
+        .references(() => cancellationPolicies.id, { onDelete: "cascade" }),
+    sortOrder: integer("sort_order").notNull().default(0),
+    cutoffMinutesBefore: integer("cutoff_minutes_before"),
+    chargeType: cancellationChargeTypeEnum("charge_type").notNull().default("none"),
+    chargeAmountCents: integer("charge_amount_cents"),
+    chargePercentBasisPoints: integer("charge_percent_basis_points"),
+    active: boolean("active").notNull().default(true),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_cancellation_policy_rules_policy").on(table.cancellationPolicyId),
+    index("idx_cancellation_policy_rules_active").on(table.active),
+]);

package/dist/schema-relations.d.ts

@@ -0,0 +1,55 @@
+export declare const pricingCategoriesRelations: import("drizzle-orm").Relations<"pricing_categories", {
+    childDependencies: import("drizzle-orm").Many<"pricing_category_dependencies">;
+    masterDependencies: import("drizzle-orm").Many<"pricing_category_dependencies">;
+    unitPriceRules: import("drizzle-orm").Many<"option_unit_price_rules">;
+}>;
+export declare const pricingCategoryDependenciesRelations: import("drizzle-orm").Relations<"pricing_category_dependencies", {
+    pricingCategory: import("drizzle-orm").One<"pricing_categories", true>;
+    masterPricingCategory: import("drizzle-orm").One<"pricing_categories", true>;
+}>;
+export declare const cancellationPoliciesRelations: import("drizzle-orm").Relations<"cancellation_policies", {
+    rules: import("drizzle-orm").Many<"cancellation_policy_rules">;
+    optionPriceRules: import("drizzle-orm").Many<"option_price_rules">;
+}>;
+export declare const cancellationPolicyRulesRelations: import("drizzle-orm").Relations<"cancellation_policy_rules", {
+    cancellationPolicy: import("drizzle-orm").One<"cancellation_policies", true>;
+}>;
+export declare const priceCatalogsRelations: import("drizzle-orm").Relations<"price_catalogs", {
+    schedules: import("drizzle-orm").Many<"price_schedules">;
+    optionPriceRules: import("drizzle-orm").Many<"option_price_rules">;
+}>;
+export declare const priceSchedulesRelations: import("drizzle-orm").Relations<"price_schedules", {
+    priceCatalog: import("drizzle-orm").One<"price_catalogs", true>;
+    optionPriceRules: import("drizzle-orm").Many<"option_price_rules">;
+}>;
+export declare const optionPriceRulesRelations: import("drizzle-orm").Relations<"option_price_rules", {
+    priceCatalog: import("drizzle-orm").One<"price_catalogs", true>;
+    priceSchedule: import("drizzle-orm").One<"price_schedules", false>;
+    cancellationPolicy: import("drizzle-orm").One<"cancellation_policies", false>;
+    unitRules: import("drizzle-orm").Many<"option_unit_price_rules">;
+    startTimeRules: import("drizzle-orm").Many<"option_start_time_rules">;
+    pickupRules: import("drizzle-orm").Many<"pickup_price_rules">;
+    dropoffRules: import("drizzle-orm").Many<"dropoff_price_rules">;
+    extraRules: import("drizzle-orm").Many<"extra_price_rules">;
+}>;
+export declare const optionUnitPriceRulesRelations: import("drizzle-orm").Relations<"option_unit_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+    pricingCategory: import("drizzle-orm").One<"pricing_categories", false>;
+    tiers: import("drizzle-orm").Many<"option_unit_tiers">;
+}>;
+export declare const optionStartTimeRulesRelations: import("drizzle-orm").Relations<"option_start_time_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+export declare const optionUnitTiersRelations: import("drizzle-orm").Relations<"option_unit_tiers", {
+    optionUnitPriceRule: import("drizzle-orm").One<"option_unit_price_rules", true>;
+}>;
+export declare const pickupPriceRulesRelations: import("drizzle-orm").Relations<"pickup_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+export declare const dropoffPriceRulesRelations: import("drizzle-orm").Relations<"dropoff_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+export declare const extraPriceRulesRelations: import("drizzle-orm").Relations<"extra_price_rules", {
+    optionPriceRule: import("drizzle-orm").One<"option_price_rules", true>;
+}>;
+//# sourceMappingURL=schema-relations.d.ts.map