@voyant-travel/distribution 0.109.8

package/dist/service/settlements.d.ts

@@ -0,0 +1,357 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ChannelInventoryReleaseExecutionListQuery, ChannelReconciliationItemListQuery, ChannelReconciliationRunListQuery, ChannelSettlementItemListQuery, ChannelSettlementRunListQuery, CreateChannelInventoryReleaseExecutionInput, CreateChannelReconciliationItemInput, CreateChannelReconciliationRunInput, CreateChannelSettlementItemInput, CreateChannelSettlementRunInput, UpdateChannelInventoryReleaseExecutionInput, UpdateChannelReconciliationItemInput, UpdateChannelReconciliationRunInput, UpdateChannelSettlementItemInput, UpdateChannelSettlementRunInput } from "./types.js";
+export declare const settlementServiceOperations: {
+    listSettlementRuns(db: PostgresJsDatabase, query: ChannelSettlementRunListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            contractId: string | null;
+            status: "void" | "draft" | "open" | "posted" | "paid";
+            currencyCode: string | null;
+            periodStart: string | null;
+            periodEnd: string | null;
+            statementReference: string | null;
+            generatedAt: Date | null;
+            postedAt: Date | null;
+            paidAt: Date | null;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getSettlementRunById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        status: "void" | "draft" | "open" | "posted" | "paid";
+        currencyCode: string | null;
+        periodStart: string | null;
+        periodEnd: string | null;
+        statementReference: string | null;
+        generatedAt: Date | null;
+        postedAt: Date | null;
+        paidAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createSettlementRun(db: PostgresJsDatabase, data: CreateChannelSettlementRunInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        status: "void" | "draft" | "open" | "posted" | "paid";
+        channelId: string;
+        notes: string | null;
+        contractId: string | null;
+        paidAt: Date | null;
+        currencyCode: string | null;
+        periodStart: string | null;
+        periodEnd: string | null;
+        statementReference: string | null;
+        generatedAt: Date | null;
+        postedAt: Date | null;
+    } | undefined>;
+    updateSettlementRun(db: PostgresJsDatabase, id: string, data: UpdateChannelSettlementRunInput): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        status: "void" | "draft" | "open" | "posted" | "paid";
+        currencyCode: string | null;
+        periodStart: string | null;
+        periodEnd: string | null;
+        statementReference: string | null;
+        generatedAt: Date | null;
+        postedAt: Date | null;
+        paidAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteSettlementRun(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listSettlementItems(db: PostgresJsDatabase, query: ChannelSettlementItemListQuery): Promise<{
+        data: {
+            id: string;
+            settlementRunId: string;
+            bookingLinkId: string | null;
+            bookingId: string | null;
+            commissionRuleId: string | null;
+            status: "void" | "pending" | "paid" | "approved" | "disputed";
+            grossAmountCents: number;
+            commissionAmountCents: number;
+            netRemittanceAmountCents: number;
+            currencyCode: string | null;
+            remittanceDueAt: Date | null;
+            paidAt: Date | null;
+            notes: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getSettlementItemById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        settlementRunId: string;
+        bookingLinkId: string | null;
+        bookingId: string | null;
+        commissionRuleId: string | null;
+        status: "void" | "pending" | "paid" | "approved" | "disputed";
+        grossAmountCents: number;
+        commissionAmountCents: number;
+        netRemittanceAmountCents: number;
+        currencyCode: string | null;
+        remittanceDueAt: Date | null;
+        paidAt: Date | null;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createSettlementItem(db: PostgresJsDatabase, data: CreateChannelSettlementItemInput): Promise<{
+        bookingId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        status: "void" | "pending" | "paid" | "approved" | "disputed";
+        notes: string | null;
+        paidAt: Date | null;
+        currencyCode: string | null;
+        settlementRunId: string;
+        bookingLinkId: string | null;
+        commissionRuleId: string | null;
+        grossAmountCents: number;
+        commissionAmountCents: number;
+        netRemittanceAmountCents: number;
+        remittanceDueAt: Date | null;
+    } | undefined>;
+    updateSettlementItem(db: PostgresJsDatabase, id: string, data: UpdateChannelSettlementItemInput): Promise<{
+        id: string;
+        settlementRunId: string;
+        bookingLinkId: string | null;
+        bookingId: string | null;
+        commissionRuleId: string | null;
+        status: "void" | "pending" | "paid" | "approved" | "disputed";
+        grossAmountCents: number;
+        commissionAmountCents: number;
+        netRemittanceAmountCents: number;
+        currencyCode: string | null;
+        remittanceDueAt: Date | null;
+        paidAt: Date | null;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteSettlementItem(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listReconciliationRuns(db: PostgresJsDatabase, query: ChannelReconciliationRunListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            contractId: string | null;
+            status: "archived" | "draft" | "completed" | "running";
+            periodStart: string | null;
+            periodEnd: string | null;
+            externalReportReference: string | null;
+            startedAt: Date | null;
+            completedAt: Date | null;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getReconciliationRunById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        status: "archived" | "draft" | "completed" | "running";
+        periodStart: string | null;
+        periodEnd: string | null;
+        externalReportReference: string | null;
+        startedAt: Date | null;
+        completedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createReconciliationRun(db: PostgresJsDatabase, data: CreateChannelReconciliationRunInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        status: "archived" | "draft" | "completed" | "running";
+        channelId: string;
+        startedAt: Date | null;
+        notes: string | null;
+        contractId: string | null;
+        completedAt: Date | null;
+        periodStart: string | null;
+        periodEnd: string | null;
+        externalReportReference: string | null;
+    } | undefined>;
+    updateReconciliationRun(db: PostgresJsDatabase, id: string, data: UpdateChannelReconciliationRunInput): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        status: "archived" | "draft" | "completed" | "running";
+        periodStart: string | null;
+        periodEnd: string | null;
+        externalReportReference: string | null;
+        startedAt: Date | null;
+        completedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteReconciliationRun(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listReconciliationItems(db: PostgresJsDatabase, query: ChannelReconciliationItemListQuery): Promise<{
+        data: {
+            id: string;
+            reconciliationRunId: string;
+            bookingLinkId: string | null;
+            bookingId: string | null;
+            externalBookingId: string | null;
+            issueType: "other" | "missing_booking" | "status_mismatch" | "amount_mismatch" | "cancel_mismatch" | "missing_payout";
+            severity: "error" | "info" | "warning";
+            resolutionStatus: "ignored" | "open" | "resolved";
+            notes: string | null;
+            resolvedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getReconciliationItemById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        reconciliationRunId: string;
+        bookingLinkId: string | null;
+        bookingId: string | null;
+        externalBookingId: string | null;
+        issueType: "other" | "missing_booking" | "status_mismatch" | "amount_mismatch" | "cancel_mismatch" | "missing_payout";
+        severity: "error" | "info" | "warning";
+        resolutionStatus: "ignored" | "open" | "resolved";
+        notes: string | null;
+        resolvedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createReconciliationItem(db: PostgresJsDatabase, data: CreateChannelReconciliationItemInput): Promise<{
+        bookingId: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        externalBookingId: string | null;
+        notes: string | null;
+        bookingLinkId: string | null;
+        reconciliationRunId: string;
+        issueType: "other" | "missing_booking" | "status_mismatch" | "amount_mismatch" | "cancel_mismatch" | "missing_payout";
+        resolutionStatus: "ignored" | "open" | "resolved";
+        severity: "error" | "info" | "warning";
+        resolvedAt: Date | null;
+    } | undefined>;
+    updateReconciliationItem(db: PostgresJsDatabase, id: string, data: UpdateChannelReconciliationItemInput): Promise<{
+        id: string;
+        reconciliationRunId: string;
+        bookingLinkId: string | null;
+        bookingId: string | null;
+        externalBookingId: string | null;
+        issueType: "other" | "missing_booking" | "status_mismatch" | "amount_mismatch" | "cancel_mismatch" | "missing_payout";
+        severity: "error" | "info" | "warning";
+        resolutionStatus: "ignored" | "open" | "resolved";
+        notes: string | null;
+        resolvedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteReconciliationItem(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listReleaseExecutions(db: PostgresJsDatabase, query: ChannelInventoryReleaseExecutionListQuery): Promise<{
+        data: {
+            id: string;
+            allotmentId: string;
+            releaseRuleId: string | null;
+            targetId: string | null;
+            slotId: string | null;
+            actionTaken: "expired" | "released" | "retained" | "manual_override";
+            status: "pending" | "failed" | "skipped" | "completed";
+            releasedCapacity: number | null;
+            executedAt: Date | null;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getReleaseExecutionById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        allotmentId: string;
+        releaseRuleId: string | null;
+        targetId: string | null;
+        slotId: string | null;
+        actionTaken: "expired" | "released" | "retained" | "manual_override";
+        status: "pending" | "failed" | "skipped" | "completed";
+        releasedCapacity: number | null;
+        executedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createReleaseExecution(db: PostgresJsDatabase, data: CreateChannelInventoryReleaseExecutionInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        status: "pending" | "failed" | "skipped" | "completed";
+        notes: string | null;
+        slotId: string | null;
+        allotmentId: string;
+        releaseRuleId: string | null;
+        targetId: string | null;
+        actionTaken: "expired" | "released" | "retained" | "manual_override";
+        releasedCapacity: number | null;
+        executedAt: Date | null;
+    } | undefined>;
+    updateReleaseExecution(db: PostgresJsDatabase, id: string, data: UpdateChannelInventoryReleaseExecutionInput): Promise<{
+        id: string;
+        allotmentId: string;
+        releaseRuleId: string | null;
+        targetId: string | null;
+        slotId: string | null;
+        actionTaken: "expired" | "released" | "retained" | "manual_override";
+        status: "pending" | "failed" | "skipped" | "completed";
+        releasedCapacity: number | null;
+        executedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteReleaseExecution(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=settlements.d.ts.map

package/dist/service/settlements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlements.d.ts","sourceRoot":"","sources":["../../src/service/settlements.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAUjE,OAAO,KAAK,EACV,yCAAyC,EACzC,kCAAkC,EAClC,iCAAiC,EACjC,8BAA8B,EAC9B,6BAA6B,EAC7B,2CAA2C,EAC3C,oCAAoC,EACpC,mCAAmC,EACnC,gCAAgC,EAChC,+BAA+B,EAC/B,2CAA2C,EAC3C,oCAAoC,EACpC,mCAAmC,EACnC,gCAAgC,EAChC,+BAA+B,EAChC,MAAM,YAAY,CAAA;AAEnB,eAAO,MAAM,2BAA2B;2BACT,kBAAkB,SAAS,6BAA6B;;;;;;;;;;;;;;;;;;;;;;6BAoBtD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;4BAS/B,kBAAkB,QAAQ,+BAA+B;;;;;;;;;;;;;;;;;4BAejF,kBAAkB,MAClB,MAAM,QACJ,+BAA+B;;;;;;;;;;;;;;;;;4BAiBT,kBAAkB,MAAM,MAAM;;;4BAQ9B,kBAAkB,SAAS,8BAA8B;;;;;;;;;;;;;;;;;;;;;;8BAyBvD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;6BAS/B,kBAAkB,QAAQ,gCAAgC;;;;;;;;;;;;;;;;;6BAcnF,kBAAkB,MAClB,MAAM,QACJ,gCAAgC;;;;;;;;;;;;;;;;;6BAgBT,kBAAkB,MAAM,MAAM;;;+BAQ5B,kBAAkB,SAAS,iCAAiC;;;;;;;;;;;;;;;;;;;;iCAsB1D,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;gCAS/B,kBAAkB,QAAQ,mCAAmC;;;;;;;;;;;;;;;gCAczF,kBAAkB,MAClB,MAAM,QACJ,mCAAmC;;;;;;;;;;;;;;;gCAgBT,kBAAkB,MAAM,MAAM;;;gCAQ9B,kBAAkB,SAAS,kCAAkC;;;;;;;;;;;;;;;;;;;kCAiC3D,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;iCAU5D,kBAAkB,QAChB,oCAAoC;;;;;;;;;;;;;;iCActC,kBAAkB,MAClB,MAAM,QACJ,oCAAoC;;;;;;;;;;;;;;iCAeT,kBAAkB,MAAM,MAAM;;;8BAS3D,kBAAkB,SACf,yCAAyC;;;;;;;;;;;;;;;;;;;;gCAgChB,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;+BAU1D,kBAAkB,QAChB,2CAA2C;;;;;;;;;;;;;;;+BAc7C,kBAAkB,MAClB,MAAM,QACJ,2CAA2C;;;;;;;;;;;;;;;+BAelB,kBAAkB,MAAM,MAAM;;;CAOhE,CAAA"}

package/dist/service/settlements.js

@@ -0,0 +1,319 @@
+import { and, desc, eq, sql } from "drizzle-orm";
+import { channelInventoryReleaseExecutions, channelReconciliationItems, channelReconciliationRuns, channelSettlementItems, channelSettlementRuns, } from "../schema.js";
+import { paginate, toDateOrNull } from "./helpers.js";
+export const settlementServiceOperations = {
+    async listSettlementRuns(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelSettlementRuns.channelId, query.channelId));
+        if (query.contractId)
+            conditions.push(eq(channelSettlementRuns.contractId, query.contractId));
+        if (query.status)
+            conditions.push(eq(channelSettlementRuns.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelSettlementRuns)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelSettlementRuns.updatedAt)), db.select({ count: sql `count(*)::int` }).from(channelSettlementRuns).where(where), query.limit, query.offset);
+    },
+    async getSettlementRunById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelSettlementRuns)
+            .where(eq(channelSettlementRuns.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createSettlementRun(db, data) {
+        const { generatedAt, postedAt, paidAt, ...rest } = data;
+        const [row] = await db
+            .insert(channelSettlementRuns)
+            .values({
+            ...rest,
+            generatedAt: toDateOrNull(generatedAt),
+            postedAt: toDateOrNull(postedAt),
+            paidAt: toDateOrNull(paidAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateSettlementRun(db, id, data) {
+        const { generatedAt, postedAt, paidAt, ...rest } = data;
+        const [row] = await db
+            .update(channelSettlementRuns)
+            .set({
+            ...rest,
+            generatedAt: toDateOrNull(generatedAt),
+            postedAt: toDateOrNull(postedAt),
+            paidAt: toDateOrNull(paidAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelSettlementRuns.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteSettlementRun(db, id) {
+        const [row] = await db
+            .delete(channelSettlementRuns)
+            .where(eq(channelSettlementRuns.id, id))
+            .returning({ id: channelSettlementRuns.id });
+        return row ?? null;
+    },
+    async listSettlementItems(db, query) {
+        const conditions = [];
+        if (query.settlementRunId) {
+            conditions.push(eq(channelSettlementItems.settlementRunId, query.settlementRunId));
+        }
+        if (query.bookingLinkId) {
+            conditions.push(eq(channelSettlementItems.bookingLinkId, query.bookingLinkId));
+        }
+        if (query.bookingId)
+            conditions.push(eq(channelSettlementItems.bookingId, query.bookingId));
+        if (query.status)
+            conditions.push(eq(channelSettlementItems.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelSettlementItems)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelSettlementItems.updatedAt)), db.select({ count: sql `count(*)::int` }).from(channelSettlementItems).where(where), query.limit, query.offset);
+    },
+    async getSettlementItemById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelSettlementItems)
+            .where(eq(channelSettlementItems.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createSettlementItem(db, data) {
+        const { remittanceDueAt, paidAt, ...rest } = data;
+        const [row] = await db
+            .insert(channelSettlementItems)
+            .values({
+            ...rest,
+            remittanceDueAt: toDateOrNull(remittanceDueAt),
+            paidAt: toDateOrNull(paidAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateSettlementItem(db, id, data) {
+        const { remittanceDueAt, paidAt, ...rest } = data;
+        const [row] = await db
+            .update(channelSettlementItems)
+            .set({
+            ...rest,
+            remittanceDueAt: toDateOrNull(remittanceDueAt),
+            paidAt: toDateOrNull(paidAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelSettlementItems.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteSettlementItem(db, id) {
+        const [row] = await db
+            .delete(channelSettlementItems)
+            .where(eq(channelSettlementItems.id, id))
+            .returning({ id: channelSettlementItems.id });
+        return row ?? null;
+    },
+    async listReconciliationRuns(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelReconciliationRuns.channelId, query.channelId));
+        if (query.contractId) {
+            conditions.push(eq(channelReconciliationRuns.contractId, query.contractId));
+        }
+        if (query.status)
+            conditions.push(eq(channelReconciliationRuns.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelReconciliationRuns)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelReconciliationRuns.updatedAt)), db.select({ count: sql `count(*)::int` }).from(channelReconciliationRuns).where(where), query.limit, query.offset);
+    },
+    async getReconciliationRunById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelReconciliationRuns)
+            .where(eq(channelReconciliationRuns.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createReconciliationRun(db, data) {
+        const { startedAt, completedAt, ...rest } = data;
+        const [row] = await db
+            .insert(channelReconciliationRuns)
+            .values({
+            ...rest,
+            startedAt: toDateOrNull(startedAt),
+            completedAt: toDateOrNull(completedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateReconciliationRun(db, id, data) {
+        const { startedAt, completedAt, ...rest } = data;
+        const [row] = await db
+            .update(channelReconciliationRuns)
+            .set({
+            ...rest,
+            startedAt: toDateOrNull(startedAt),
+            completedAt: toDateOrNull(completedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelReconciliationRuns.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteReconciliationRun(db, id) {
+        const [row] = await db
+            .delete(channelReconciliationRuns)
+            .where(eq(channelReconciliationRuns.id, id))
+            .returning({ id: channelReconciliationRuns.id });
+        return row ?? null;
+    },
+    async listReconciliationItems(db, query) {
+        const conditions = [];
+        if (query.reconciliationRunId) {
+            conditions.push(eq(channelReconciliationItems.reconciliationRunId, query.reconciliationRunId));
+        }
+        if (query.bookingLinkId) {
+            conditions.push(eq(channelReconciliationItems.bookingLinkId, query.bookingLinkId));
+        }
+        if (query.bookingId) {
+            conditions.push(eq(channelReconciliationItems.bookingId, query.bookingId));
+        }
+        if (query.issueType)
+            conditions.push(eq(channelReconciliationItems.issueType, query.issueType));
+        if (query.resolutionStatus) {
+            conditions.push(eq(channelReconciliationItems.resolutionStatus, query.resolutionStatus));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelReconciliationItems)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelReconciliationItems.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelReconciliationItems)
+            .where(where), query.limit, query.offset);
+    },
+    async getReconciliationItemById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelReconciliationItems)
+            .where(eq(channelReconciliationItems.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createReconciliationItem(db, data) {
+        const { resolvedAt, ...rest } = data;
+        const [row] = await db
+            .insert(channelReconciliationItems)
+            .values({
+            ...rest,
+            resolvedAt: toDateOrNull(resolvedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateReconciliationItem(db, id, data) {
+        const { resolvedAt, ...rest } = data;
+        const [row] = await db
+            .update(channelReconciliationItems)
+            .set({
+            ...rest,
+            resolvedAt: toDateOrNull(resolvedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelReconciliationItems.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteReconciliationItem(db, id) {
+        const [row] = await db
+            .delete(channelReconciliationItems)
+            .where(eq(channelReconciliationItems.id, id))
+            .returning({ id: channelReconciliationItems.id });
+        return row ?? null;
+    },
+    async listReleaseExecutions(db, query) {
+        const conditions = [];
+        if (query.allotmentId) {
+            conditions.push(eq(channelInventoryReleaseExecutions.allotmentId, query.allotmentId));
+        }
+        if (query.releaseRuleId) {
+            conditions.push(eq(channelInventoryReleaseExecutions.releaseRuleId, query.releaseRuleId));
+        }
+        if (query.targetId) {
+            conditions.push(eq(channelInventoryReleaseExecutions.targetId, query.targetId));
+        }
+        if (query.slotId)
+            conditions.push(eq(channelInventoryReleaseExecutions.slotId, query.slotId));
+        if (query.status)
+            conditions.push(eq(channelInventoryReleaseExecutions.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelInventoryReleaseExecutions)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelInventoryReleaseExecutions.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelInventoryReleaseExecutions)
+            .where(where), query.limit, query.offset);
+    },
+    async getReleaseExecutionById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelInventoryReleaseExecutions)
+            .where(eq(channelInventoryReleaseExecutions.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createReleaseExecution(db, data) {
+        const { executedAt, ...rest } = data;
+        const [row] = await db
+            .insert(channelInventoryReleaseExecutions)
+            .values({
+            ...rest,
+            executedAt: toDateOrNull(executedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateReleaseExecution(db, id, data) {
+        const { executedAt, ...rest } = data;
+        const [row] = await db
+            .update(channelInventoryReleaseExecutions)
+            .set({
+            ...rest,
+            executedAt: toDateOrNull(executedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelInventoryReleaseExecutions.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteReleaseExecution(db, id) {
+        const [row] = await db
+            .delete(channelInventoryReleaseExecutions)
+            .where(eq(channelInventoryReleaseExecutions.id, id))
+            .returning({ id: channelInventoryReleaseExecutions.id });
+        return row ?? null;
+    },
+};