@voyantjs/distribution 0.2.0 → 0.3.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-inventory.d.ts","sourceRoot":"","sources":["../src/schema-inventory.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCtC,CAAA;AAED,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2B5C,CAAA;AAED,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBxC,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6B7C,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA;AACtF,MAAM,MAAM,4BAA4B,GAAG,OAAO,0BAA0B,CAAC,YAAY,CAAA;AACzF,MAAM,MAAM,+BAA+B,GAAG,OAAO,gCAAgC,CAAC,YAAY,CAAA;AAClG,MAAM,MAAM,kCAAkC,GAC5C,OAAO,gCAAgC,CAAC,YAAY,CAAA;AACtD,MAAM,MAAM,2BAA2B,GAAG,OAAO,4BAA4B,CAAC,YAAY,CAAA;AAC1F,MAAM,MAAM,8BAA8B,GAAG,OAAO,4BAA4B,CAAC,YAAY,CAAA;AAC7F,MAAM,MAAM,gCAAgC,GAAG,OAAO,iCAAiC,CAAC,YAAY,CAAA;AACpG,MAAM,MAAM,mCAAmC,GAC7C,OAAO,iCAAiC,CAAC,YAAY,CAAA"}

package/dist/schema-inventory.js

@@ -0,0 +1,105 @@
+import { availabilitySlots, availabilityStartTimes } from "@voyantjs/availability/schema";
+import { typeId, typeIdRef } from "@voyantjs/db/lib/typeid-column";
+import { productOptions, products } from "@voyantjs/products/schema";
+import { boolean, date, index, integer, jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { channelContracts, channels } from "./schema-core";
+import { channelAllotmentReleaseModeEnum, channelAllotmentUnsoldActionEnum, channelReleaseExecutionActionEnum, channelReleaseExecutionStatusEnum, } from "./schema-shared";
+export const channelInventoryAllotments = pgTable("channel_inventory_allotments", {
+    id: typeId("channel_inventory_allotments"),
+    channelId: typeIdRef("channel_id")
+        .notNull()
+        .references(() => channels.id, { onDelete: "cascade" }),
+    contractId: typeIdRef("contract_id").references(() => channelContracts.id, {
+        onDelete: "set null",
+    }),
+    productId: typeIdRef("product_id")
+        .notNull()
+        .references(() => products.id, { onDelete: "cascade" }),
+    optionId: typeIdRef("option_id").references(() => productOptions.id, { onDelete: "set null" }),
+    startTimeId: typeIdRef("start_time_id").references(() => availabilityStartTimes.id, {
+        onDelete: "set null",
+    }),
+    validFrom: date("valid_from"),
+    validTo: date("valid_to"),
+    guaranteedCapacity: integer("guaranteed_capacity"),
+    maxCapacity: integer("max_capacity"),
+    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_channel_inventory_allotments_channel").on(table.channelId),
+    index("idx_channel_inventory_allotments_contract").on(table.contractId),
+    index("idx_channel_inventory_allotments_product").on(table.productId),
+    index("idx_channel_inventory_allotments_option").on(table.optionId),
+    index("idx_channel_inventory_allotments_start_time").on(table.startTimeId),
+    index("idx_channel_inventory_allotments_active").on(table.active),
+]);
+export const channelInventoryAllotmentTargets = pgTable("channel_inventory_allotment_targets", {
+    id: typeId("channel_inventory_allotment_targets"),
+    allotmentId: typeIdRef("allotment_id")
+        .notNull()
+        .references(() => channelInventoryAllotments.id, { onDelete: "cascade" }),
+    slotId: typeIdRef("slot_id").references(() => availabilitySlots.id, { onDelete: "cascade" }),
+    startTimeId: typeIdRef("start_time_id").references(() => availabilityStartTimes.id, {
+        onDelete: "set null",
+    }),
+    dateLocal: date("date_local"),
+    guaranteedCapacity: integer("guaranteed_capacity"),
+    maxCapacity: integer("max_capacity"),
+    soldCapacity: integer("sold_capacity"),
+    remainingCapacity: integer("remaining_capacity"),
+    active: boolean("active").notNull().default(true),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_channel_inventory_allotment_targets_allotment").on(table.allotmentId),
+    index("idx_channel_inventory_allotment_targets_slot").on(table.slotId),
+    index("idx_channel_inventory_allotment_targets_start_time").on(table.startTimeId),
+    index("idx_channel_inventory_allotment_targets_date").on(table.dateLocal),
+    index("idx_channel_inventory_allotment_targets_active").on(table.active),
+]);
+export const channelInventoryReleaseRules = pgTable("channel_inventory_release_rules", {
+    id: typeId("channel_inventory_release_rules"),
+    allotmentId: typeIdRef("allotment_id")
+        .notNull()
+        .references(() => channelInventoryAllotments.id, { onDelete: "cascade" }),
+    releaseMode: channelAllotmentReleaseModeEnum("release_mode").notNull().default("automatic"),
+    releaseDaysBeforeStart: integer("release_days_before_start"),
+    releaseHoursBeforeStart: integer("release_hours_before_start"),
+    unsoldAction: channelAllotmentUnsoldActionEnum("unsold_action")
+        .notNull()
+        .default("release_to_general_pool"),
+    notes: text("notes"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => [
+    index("idx_channel_inventory_release_rules_allotment").on(table.allotmentId),
+    index("idx_channel_inventory_release_rules_mode").on(table.releaseMode),
+]);
+export const channelInventoryReleaseExecutions = pgTable("channel_inventory_release_executions", {
+    id: typeId("channel_inventory_release_executions"),
+    allotmentId: typeIdRef("allotment_id")
+        .notNull()
+        .references(() => channelInventoryAllotments.id, { onDelete: "cascade" }),
+    releaseRuleId: typeIdRef("release_rule_id").references(() => channelInventoryReleaseRules.id, {
+        onDelete: "set null",
+    }),
+    targetId: typeIdRef("target_id").references(() => channelInventoryAllotmentTargets.id, {
+        onDelete: "set null",
+    }),
+    slotId: typeIdRef("slot_id").references(() => availabilitySlots.id, { onDelete: "set null" }),
+    actionTaken: channelReleaseExecutionActionEnum("action_taken").notNull().default("released"),
+    status: channelReleaseExecutionStatusEnum("status").notNull().default("pending"),
+    releasedCapacity: integer("released_capacity"),
+    executedAt: timestamp("executed_at", { withTimezone: 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_channel_inventory_release_executions_allotment").on(table.allotmentId),
+    index("idx_channel_inventory_release_executions_rule").on(table.releaseRuleId),
+    index("idx_channel_inventory_release_executions_target").on(table.targetId),
+    index("idx_channel_inventory_release_executions_status").on(table.status),
+]);

package/dist/schema-relations.d.ts

@@ -0,0 +1,99 @@
+export declare const channelsRelations: import("drizzle-orm").Relations<"channels", {
+    contracts: import("drizzle-orm").Many<"channel_contracts">;
+    productMappings: import("drizzle-orm").Many<"channel_product_mappings">;
+    bookingLinks: import("drizzle-orm").Many<"channel_booking_links">;
+    webhookEvents: import("drizzle-orm").Many<"channel_webhook_events">;
+    inventoryAllotments: import("drizzle-orm").Many<"channel_inventory_allotments">;
+    settlementRuns: import("drizzle-orm").Many<"channel_settlement_runs">;
+    reconciliationRuns: import("drizzle-orm").Many<"channel_reconciliation_runs">;
+    settlementPolicies: import("drizzle-orm").Many<"channel_settlement_policies">;
+    reconciliationPolicies: import("drizzle-orm").Many<"channel_reconciliation_policies">;
+    remittanceExceptions: import("drizzle-orm").Many<"channel_remittance_exceptions">;
+}>;
+export declare const channelContractsRelations: import("drizzle-orm").Relations<"channel_contracts", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    supplier: import("drizzle-orm").One<"suppliers", false>;
+    commissionRules: import("drizzle-orm").Many<"channel_commission_rules">;
+    inventoryAllotments: import("drizzle-orm").Many<"channel_inventory_allotments">;
+    settlementRuns: import("drizzle-orm").Many<"channel_settlement_runs">;
+    reconciliationRuns: import("drizzle-orm").Many<"channel_reconciliation_runs">;
+}>;
+export declare const channelCommissionRulesRelations: import("drizzle-orm").Relations<"channel_commission_rules", {
+    contract: import("drizzle-orm").One<"channel_contracts", true>;
+    product: import("drizzle-orm").One<"products", false>;
+}>;
+export declare const channelProductMappingsRelations: import("drizzle-orm").Relations<"channel_product_mappings", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    product: import("drizzle-orm").One<"products", true>;
+}>;
+export declare const channelBookingLinksRelations: import("drizzle-orm").Relations<"channel_booking_links", {
+    channel: import("drizzle-orm").One<"channels", true>;
+}>;
+export declare const channelInventoryAllotmentsRelations: import("drizzle-orm").Relations<"channel_inventory_allotments", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+    product: import("drizzle-orm").One<"products", true>;
+    option: import("drizzle-orm").One<"product_options", false>;
+    startTime: import("drizzle-orm").One<"availability_start_times", false>;
+    targets: import("drizzle-orm").Many<"channel_inventory_allotment_targets">;
+    releaseRules: import("drizzle-orm").Many<"channel_inventory_release_rules">;
+    releaseExecutions: import("drizzle-orm").Many<"channel_inventory_release_executions">;
+}>;
+export declare const channelInventoryAllotmentTargetsRelations: import("drizzle-orm").Relations<"channel_inventory_allotment_targets", {
+    allotment: import("drizzle-orm").One<"channel_inventory_allotments", true>;
+    slot: import("drizzle-orm").One<"availability_slots", false>;
+    startTime: import("drizzle-orm").One<"availability_start_times", false>;
+}>;
+export declare const channelInventoryReleaseRulesRelations: import("drizzle-orm").Relations<"channel_inventory_release_rules", {
+    allotment: import("drizzle-orm").One<"channel_inventory_allotments", true>;
+    schedules: import("drizzle-orm").Many<"channel_release_schedules">;
+}>;
+export declare const channelSettlementRunsRelations: import("drizzle-orm").Relations<"channel_settlement_runs", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+    items: import("drizzle-orm").Many<"channel_settlement_items">;
+    approvals: import("drizzle-orm").Many<"channel_settlement_approvals">;
+}>;
+export declare const channelSettlementItemsRelations: import("drizzle-orm").Relations<"channel_settlement_items", {
+    settlementRun: import("drizzle-orm").One<"channel_settlement_runs", true>;
+    bookingLink: import("drizzle-orm").One<"channel_booking_links", false>;
+    commissionRule: import("drizzle-orm").One<"channel_commission_rules", false>;
+}>;
+export declare const channelReconciliationRunsRelations: import("drizzle-orm").Relations<"channel_reconciliation_runs", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+    items: import("drizzle-orm").Many<"channel_reconciliation_items">;
+}>;
+export declare const channelReconciliationItemsRelations: import("drizzle-orm").Relations<"channel_reconciliation_items", {
+    reconciliationRun: import("drizzle-orm").One<"channel_reconciliation_runs", true>;
+    bookingLink: import("drizzle-orm").One<"channel_booking_links", false>;
+}>;
+export declare const channelInventoryReleaseExecutionsRelations: import("drizzle-orm").Relations<"channel_inventory_release_executions", {
+    allotment: import("drizzle-orm").One<"channel_inventory_allotments", true>;
+    releaseRule: import("drizzle-orm").One<"channel_inventory_release_rules", false>;
+    target: import("drizzle-orm").One<"channel_inventory_allotment_targets", false>;
+    slot: import("drizzle-orm").One<"availability_slots", false>;
+}>;
+export declare const channelSettlementPoliciesRelations: import("drizzle-orm").Relations<"channel_settlement_policies", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+}>;
+export declare const channelReconciliationPoliciesRelations: import("drizzle-orm").Relations<"channel_reconciliation_policies", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    contract: import("drizzle-orm").One<"channel_contracts", false>;
+}>;
+export declare const channelReleaseSchedulesRelations: import("drizzle-orm").Relations<"channel_release_schedules", {
+    releaseRule: import("drizzle-orm").One<"channel_inventory_release_rules", true>;
+}>;
+export declare const channelRemittanceExceptionsRelations: import("drizzle-orm").Relations<"channel_remittance_exceptions", {
+    channel: import("drizzle-orm").One<"channels", true>;
+    settlementItem: import("drizzle-orm").One<"channel_settlement_items", false>;
+    reconciliationItem: import("drizzle-orm").One<"channel_reconciliation_items", false>;
+}>;
+export declare const channelSettlementApprovalsRelations: import("drizzle-orm").Relations<"channel_settlement_approvals", {
+    settlementRun: import("drizzle-orm").One<"channel_settlement_runs", true>;
+}>;
+export declare const channelWebhookEventsRelations: import("drizzle-orm").Relations<"channel_webhook_events", {
+    channel: import("drizzle-orm").One<"channels", true>;
+}>;
+//# sourceMappingURL=schema-relations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-relations.d.ts","sourceRoot":"","sources":["../src/schema-relations.ts"],"names":[],"mappings":"AAgCA,eAAO,MAAM,iBAAiB;;;;;;;;;;;EAW3B,CAAA;AAEH,eAAO,MAAM,yBAAyB;;;;;;;EAUnC,CAAA;AAEH,eAAO,MAAM,+BAA+B;;;EASzC,CAAA;AAEH,eAAO,MAAM,+BAA+B;;;EASzC,CAAA;AAEH,eAAO,MAAM,4BAA4B;;EAKtC,CAAA;AAEH,eAAO,MAAM,mCAAmC;;;;;;;;;EA2B/C,CAAA;AAED,eAAO,MAAM,yCAAyC;;;;EAgBrD,CAAA;AAED,eAAO,MAAM,qCAAqC;;;EASjD,CAAA;AAED,eAAO,MAAM,8BAA8B;;;;;EAWxC,CAAA;AAEH,eAAO,MAAM,+BAA+B;;;;EAazC,CAAA;AAEH,eAAO,MAAM,kCAAkC;;;;EAa9C,CAAA;AAED,eAAO,MAAM,mCAAmC;;;EAY/C,CAAA;AAED,eAAO,MAAM,0CAA0C;;;;;EAoBtD,CAAA;AAED,eAAO,MAAM,kCAAkC;;;EAY9C,CAAA;AAED,eAAO,MAAM,sCAAsC;;;EAYlD,CAAA;AAED,eAAO,MAAM,gCAAgC;;EAK1C,CAAA;AAEH,eAAO,MAAM,oCAAoC;;;;EAgBhD,CAAA;AAED,eAAO,MAAM,mCAAmC;;EAQ/C,CAAA;AAED,eAAO,MAAM,6BAA6B;;EAKvC,CAAA"}

package/dist/schema-relations.js

@@ -0,0 +1,220 @@
+import { availabilitySlots, availabilityStartTimes } from "@voyantjs/availability/schema";
+import { productOptions, products } from "@voyantjs/products/schema";
+import { suppliers } from "@voyantjs/suppliers/schema";
+import { relations } from "drizzle-orm";
+import { channelReconciliationPolicies, channelReleaseSchedules, channelSettlementPolicies, } from "./schema-automation";
+import { channelBookingLinks, channelCommissionRules, channelContracts, channelProductMappings, channels, channelWebhookEvents, } from "./schema-core";
+import { channelReconciliationItems, channelReconciliationRuns, channelRemittanceExceptions, channelSettlementApprovals, channelSettlementItems, channelSettlementRuns, } from "./schema-finance";
+import { channelInventoryAllotments, channelInventoryAllotmentTargets, channelInventoryReleaseExecutions, channelInventoryReleaseRules, } from "./schema-inventory";
+export const channelsRelations = relations(channels, ({ many }) => ({
+    contracts: many(channelContracts),
+    productMappings: many(channelProductMappings),
+    bookingLinks: many(channelBookingLinks),
+    webhookEvents: many(channelWebhookEvents),
+    inventoryAllotments: many(channelInventoryAllotments),
+    settlementRuns: many(channelSettlementRuns),
+    reconciliationRuns: many(channelReconciliationRuns),
+    settlementPolicies: many(channelSettlementPolicies),
+    reconciliationPolicies: many(channelReconciliationPolicies),
+    remittanceExceptions: many(channelRemittanceExceptions),
+}));
+export const channelContractsRelations = relations(channelContracts, ({ one, many }) => ({
+    channel: one(channels, { fields: [channelContracts.channelId], references: [channels.id] }),
+    supplier: one(suppliers, {
+        fields: [channelContracts.supplierId],
+        references: [suppliers.id],
+    }),
+    commissionRules: many(channelCommissionRules),
+    inventoryAllotments: many(channelInventoryAllotments),
+    settlementRuns: many(channelSettlementRuns),
+    reconciliationRuns: many(channelReconciliationRuns),
+}));
+export const channelCommissionRulesRelations = relations(channelCommissionRules, ({ one }) => ({
+    contract: one(channelContracts, {
+        fields: [channelCommissionRules.contractId],
+        references: [channelContracts.id],
+    }),
+    product: one(products, {
+        fields: [channelCommissionRules.productId],
+        references: [products.id],
+    }),
+}));
+export const channelProductMappingsRelations = relations(channelProductMappings, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelProductMappings.channelId],
+        references: [channels.id],
+    }),
+    product: one(products, {
+        fields: [channelProductMappings.productId],
+        references: [products.id],
+    }),
+}));
+export const channelBookingLinksRelations = relations(channelBookingLinks, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelBookingLinks.channelId],
+        references: [channels.id],
+    }),
+}));
+export const channelInventoryAllotmentsRelations = relations(channelInventoryAllotments, ({ one, many }) => ({
+    channel: one(channels, {
+        fields: [channelInventoryAllotments.channelId],
+        references: [channels.id],
+    }),
+    contract: one(channelContracts, {
+        fields: [channelInventoryAllotments.contractId],
+        references: [channelContracts.id],
+    }),
+    product: one(products, {
+        fields: [channelInventoryAllotments.productId],
+        references: [products.id],
+    }),
+    option: one(productOptions, {
+        fields: [channelInventoryAllotments.optionId],
+        references: [productOptions.id],
+    }),
+    startTime: one(availabilityStartTimes, {
+        fields: [channelInventoryAllotments.startTimeId],
+        references: [availabilityStartTimes.id],
+    }),
+    targets: many(channelInventoryAllotmentTargets),
+    releaseRules: many(channelInventoryReleaseRules),
+    releaseExecutions: many(channelInventoryReleaseExecutions),
+}));
+export const channelInventoryAllotmentTargetsRelations = relations(channelInventoryAllotmentTargets, ({ one }) => ({
+    allotment: one(channelInventoryAllotments, {
+        fields: [channelInventoryAllotmentTargets.allotmentId],
+        references: [channelInventoryAllotments.id],
+    }),
+    slot: one(availabilitySlots, {
+        fields: [channelInventoryAllotmentTargets.slotId],
+        references: [availabilitySlots.id],
+    }),
+    startTime: one(availabilityStartTimes, {
+        fields: [channelInventoryAllotmentTargets.startTimeId],
+        references: [availabilityStartTimes.id],
+    }),
+}));
+export const channelInventoryReleaseRulesRelations = relations(channelInventoryReleaseRules, ({ one, many }) => ({
+    allotment: one(channelInventoryAllotments, {
+        fields: [channelInventoryReleaseRules.allotmentId],
+        references: [channelInventoryAllotments.id],
+    }),
+    schedules: many(channelReleaseSchedules),
+}));
+export const channelSettlementRunsRelations = relations(channelSettlementRuns, ({ one, many }) => ({
+    channel: one(channels, {
+        fields: [channelSettlementRuns.channelId],
+        references: [channels.id],
+    }),
+    contract: one(channelContracts, {
+        fields: [channelSettlementRuns.contractId],
+        references: [channelContracts.id],
+    }),
+    items: many(channelSettlementItems),
+    approvals: many(channelSettlementApprovals),
+}));
+export const channelSettlementItemsRelations = relations(channelSettlementItems, ({ one }) => ({
+    settlementRun: one(channelSettlementRuns, {
+        fields: [channelSettlementItems.settlementRunId],
+        references: [channelSettlementRuns.id],
+    }),
+    bookingLink: one(channelBookingLinks, {
+        fields: [channelSettlementItems.bookingLinkId],
+        references: [channelBookingLinks.id],
+    }),
+    commissionRule: one(channelCommissionRules, {
+        fields: [channelSettlementItems.commissionRuleId],
+        references: [channelCommissionRules.id],
+    }),
+}));
+export const channelReconciliationRunsRelations = relations(channelReconciliationRuns, ({ one, many }) => ({
+    channel: one(channels, {
+        fields: [channelReconciliationRuns.channelId],
+        references: [channels.id],
+    }),
+    contract: one(channelContracts, {
+        fields: [channelReconciliationRuns.contractId],
+        references: [channelContracts.id],
+    }),
+    items: many(channelReconciliationItems),
+}));
+export const channelReconciliationItemsRelations = relations(channelReconciliationItems, ({ one }) => ({
+    reconciliationRun: one(channelReconciliationRuns, {
+        fields: [channelReconciliationItems.reconciliationRunId],
+        references: [channelReconciliationRuns.id],
+    }),
+    bookingLink: one(channelBookingLinks, {
+        fields: [channelReconciliationItems.bookingLinkId],
+        references: [channelBookingLinks.id],
+    }),
+}));
+export const channelInventoryReleaseExecutionsRelations = relations(channelInventoryReleaseExecutions, ({ one }) => ({
+    allotment: one(channelInventoryAllotments, {
+        fields: [channelInventoryReleaseExecutions.allotmentId],
+        references: [channelInventoryAllotments.id],
+    }),
+    releaseRule: one(channelInventoryReleaseRules, {
+        fields: [channelInventoryReleaseExecutions.releaseRuleId],
+        references: [channelInventoryReleaseRules.id],
+    }),
+    target: one(channelInventoryAllotmentTargets, {
+        fields: [channelInventoryReleaseExecutions.targetId],
+        references: [channelInventoryAllotmentTargets.id],
+    }),
+    slot: one(availabilitySlots, {
+        fields: [channelInventoryReleaseExecutions.slotId],
+        references: [availabilitySlots.id],
+    }),
+}));
+export const channelSettlementPoliciesRelations = relations(channelSettlementPolicies, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelSettlementPolicies.channelId],
+        references: [channels.id],
+    }),
+    contract: one(channelContracts, {
+        fields: [channelSettlementPolicies.contractId],
+        references: [channelContracts.id],
+    }),
+}));
+export const channelReconciliationPoliciesRelations = relations(channelReconciliationPolicies, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelReconciliationPolicies.channelId],
+        references: [channels.id],
+    }),
+    contract: one(channelContracts, {
+        fields: [channelReconciliationPolicies.contractId],
+        references: [channelContracts.id],
+    }),
+}));
+export const channelReleaseSchedulesRelations = relations(channelReleaseSchedules, ({ one }) => ({
+    releaseRule: one(channelInventoryReleaseRules, {
+        fields: [channelReleaseSchedules.releaseRuleId],
+        references: [channelInventoryReleaseRules.id],
+    }),
+}));
+export const channelRemittanceExceptionsRelations = relations(channelRemittanceExceptions, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelRemittanceExceptions.channelId],
+        references: [channels.id],
+    }),
+    settlementItem: one(channelSettlementItems, {
+        fields: [channelRemittanceExceptions.settlementItemId],
+        references: [channelSettlementItems.id],
+    }),
+    reconciliationItem: one(channelReconciliationItems, {
+        fields: [channelRemittanceExceptions.reconciliationItemId],
+        references: [channelReconciliationItems.id],
+    }),
+}));
+export const channelSettlementApprovalsRelations = relations(channelSettlementApprovals, ({ one }) => ({
+    settlementRun: one(channelSettlementRuns, {
+        fields: [channelSettlementApprovals.settlementRunId],
+        references: [channelSettlementRuns.id],
+    }),
+}));
+export const channelWebhookEventsRelations = relations(channelWebhookEvents, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelWebhookEvents.channelId],
+        references: [channels.id],
+    }),
+}));

package/dist/schema-shared.d.ts

@@ -0,0 +1,24 @@
+export declare const channelKindEnum: import("drizzle-orm/pg-core").PgEnum<["direct", "affiliate", "ota", "reseller", "marketplace", "api_partner"]>;
+export declare const channelStatusEnum: import("drizzle-orm/pg-core").PgEnum<["active", "inactive", "pending", "archived"]>;
+export declare const channelContractStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "active", "expired", "terminated"]>;
+export declare const distributionPaymentOwnerEnum: import("drizzle-orm/pg-core").PgEnum<["operator", "channel", "split"]>;
+export declare const distributionCancellationOwnerEnum: import("drizzle-orm/pg-core").PgEnum<["operator", "channel", "mixed"]>;
+export declare const channelCommissionScopeEnum: import("drizzle-orm/pg-core").PgEnum<["booking", "product", "rate", "category"]>;
+export declare const channelCommissionTypeEnum: import("drizzle-orm/pg-core").PgEnum<["fixed", "percentage"]>;
+export declare const channelWebhookStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "processed", "failed", "ignored"]>;
+export declare const channelAllotmentReleaseModeEnum: import("drizzle-orm/pg-core").PgEnum<["automatic", "manual"]>;
+export declare const channelAllotmentUnsoldActionEnum: import("drizzle-orm/pg-core").PgEnum<["release_to_general_pool", "expire", "retain"]>;
+export declare const channelSettlementRunStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "open", "posted", "paid", "void"]>;
+export declare const channelSettlementItemStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "disputed", "paid", "void"]>;
+export declare const channelReconciliationRunStatusEnum: import("drizzle-orm/pg-core").PgEnum<["draft", "running", "completed", "archived"]>;
+export declare const channelReconciliationIssueTypeEnum: import("drizzle-orm/pg-core").PgEnum<["missing_booking", "status_mismatch", "amount_mismatch", "cancel_mismatch", "missing_payout", "other"]>;
+export declare const channelReconciliationSeverityEnum: import("drizzle-orm/pg-core").PgEnum<["info", "warning", "error"]>;
+export declare const channelReconciliationResolutionStatusEnum: import("drizzle-orm/pg-core").PgEnum<["open", "ignored", "resolved"]>;
+export declare const channelReleaseExecutionStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "completed", "skipped", "failed"]>;
+export declare const channelReleaseExecutionActionEnum: import("drizzle-orm/pg-core").PgEnum<["released", "expired", "retained", "manual_override"]>;
+export declare const channelSettlementPolicyFrequencyEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "daily", "weekly", "monthly"]>;
+export declare const channelReconciliationPolicyFrequencyEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "daily", "weekly", "monthly"]>;
+export declare const channelReleaseScheduleKindEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "hourly", "daily"]>;
+export declare const channelRemittanceExceptionStatusEnum: import("drizzle-orm/pg-core").PgEnum<["open", "investigating", "resolved", "ignored"]>;
+export declare const channelSettlementApprovalStatusEnum: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "rejected"]>;
+//# sourceMappingURL=schema-shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema-shared.d.ts","sourceRoot":"","sources":["../src/schema-shared.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe,gHAO1B,CAAA;AAEF,eAAO,MAAM,iBAAiB,qFAK5B,CAAA;AAEF,eAAO,MAAM,yBAAyB,oFAKpC,CAAA;AAEF,eAAO,MAAM,4BAA4B,wEAIvC,CAAA;AAEF,eAAO,MAAM,iCAAiC,wEAI5C,CAAA;AAEF,eAAO,MAAM,0BAA0B,kFAKrC,CAAA;AAEF,eAAO,MAAM,yBAAyB,+DAA6D,CAAA;AAEnG,eAAO,MAAM,wBAAwB,qFAKnC,CAAA;AAEF,eAAO,MAAM,+BAA+B,+DAG1C,CAAA;AAEF,eAAO,MAAM,gCAAgC,uFAI3C,CAAA;AAEF,eAAO,MAAM,8BAA8B,mFAMzC,CAAA;AAEF,eAAO,MAAM,+BAA+B,2FAM1C,CAAA;AAEF,eAAO,MAAM,kCAAkC,qFAK7C,CAAA;AAEF,eAAO,MAAM,kCAAkC,+IAO7C,CAAA;AAEF,eAAO,MAAM,iCAAiC,oEAI5C,CAAA;AAEF,eAAO,MAAM,yCAAyC,uEAGrD,CAAA;AAED,eAAO,MAAM,iCAAiC,qFAK5C,CAAA;AAEF,eAAO,MAAM,iCAAiC,8FAK5C,CAAA;AAEF,eAAO,MAAM,oCAAoC,gFAK/C,CAAA;AAEF,eAAO,MAAM,wCAAwC,gFAGpD,CAAA;AAED,eAAO,MAAM,8BAA8B,qEAIzC,CAAA;AAEF,eAAO,MAAM,oCAAoC,wFAK/C,CAAA;AAEF,eAAO,MAAM,mCAAmC,2EAI9C,CAAA"}

package/dist/schema-shared.js

@@ -0,0 +1,122 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+export const channelKindEnum = pgEnum("channel_kind", [
+    "direct",
+    "affiliate",
+    "ota",
+    "reseller",
+    "marketplace",
+    "api_partner",
+]);
+export const channelStatusEnum = pgEnum("channel_status", [
+    "active",
+    "inactive",
+    "pending",
+    "archived",
+]);
+export const channelContractStatusEnum = pgEnum("channel_contract_status", [
+    "draft",
+    "active",
+    "expired",
+    "terminated",
+]);
+export const distributionPaymentOwnerEnum = pgEnum("distribution_payment_owner", [
+    "operator",
+    "channel",
+    "split",
+]);
+export const distributionCancellationOwnerEnum = pgEnum("distribution_cancellation_owner", [
+    "operator",
+    "channel",
+    "mixed",
+]);
+export const channelCommissionScopeEnum = pgEnum("channel_commission_scope", [
+    "booking",
+    "product",
+    "rate",
+    "category",
+]);
+export const channelCommissionTypeEnum = pgEnum("channel_commission_type", ["fixed", "percentage"]);
+export const channelWebhookStatusEnum = pgEnum("channel_webhook_status", [
+    "pending",
+    "processed",
+    "failed",
+    "ignored",
+]);
+export const channelAllotmentReleaseModeEnum = pgEnum("channel_allotment_release_mode", [
+    "automatic",
+    "manual",
+]);
+export const channelAllotmentUnsoldActionEnum = pgEnum("channel_allotment_unsold_action", [
+    "release_to_general_pool",
+    "expire",
+    "retain",
+]);
+export const channelSettlementRunStatusEnum = pgEnum("channel_settlement_run_status", [
+    "draft",
+    "open",
+    "posted",
+    "paid",
+    "void",
+]);
+export const channelSettlementItemStatusEnum = pgEnum("channel_settlement_item_status", [
+    "pending",
+    "approved",
+    "disputed",
+    "paid",
+    "void",
+]);
+export const channelReconciliationRunStatusEnum = pgEnum("channel_reconciliation_run_status", [
+    "draft",
+    "running",
+    "completed",
+    "archived",
+]);
+export const channelReconciliationIssueTypeEnum = pgEnum("channel_reconciliation_issue_type", [
+    "missing_booking",
+    "status_mismatch",
+    "amount_mismatch",
+    "cancel_mismatch",
+    "missing_payout",
+    "other",
+]);
+export const channelReconciliationSeverityEnum = pgEnum("channel_reconciliation_severity", [
+    "info",
+    "warning",
+    "error",
+]);
+export const channelReconciliationResolutionStatusEnum = pgEnum("channel_reconciliation_resolution_status", ["open", "ignored", "resolved"]);
+export const channelReleaseExecutionStatusEnum = pgEnum("channel_release_execution_status", [
+    "pending",
+    "completed",
+    "skipped",
+    "failed",
+]);
+export const channelReleaseExecutionActionEnum = pgEnum("channel_release_execution_action", [
+    "released",
+    "expired",
+    "retained",
+    "manual_override",
+]);
+export const channelSettlementPolicyFrequencyEnum = pgEnum("channel_settlement_policy_frequency", [
+    "manual",
+    "daily",
+    "weekly",
+    "monthly",
+]);
+export const channelReconciliationPolicyFrequencyEnum = pgEnum("channel_reconciliation_policy_frequency", ["manual", "daily", "weekly", "monthly"]);
+export const channelReleaseScheduleKindEnum = pgEnum("channel_release_schedule_kind", [
+    "manual",
+    "hourly",
+    "daily",
+]);
+export const channelRemittanceExceptionStatusEnum = pgEnum("channel_remittance_exception_status", [
+    "open",
+    "investigating",
+    "resolved",
+    "ignored",
+]);
+export const channelSettlementApprovalStatusEnum = pgEnum("channel_settlement_approval_status", [
+    "pending",
+    "approved",
+    "rejected",
+]);