@voyant-travel/distribution 0.109.8

package/dist/service/settlement-policies.d.ts

@@ -0,0 +1,325 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { ChannelReconciliationPolicyListQuery, ChannelReleaseScheduleListQuery, ChannelRemittanceExceptionListQuery, ChannelSettlementApprovalListQuery, ChannelSettlementPolicyListQuery, CreateChannelReconciliationPolicyInput, CreateChannelReleaseScheduleInput, CreateChannelRemittanceExceptionInput, CreateChannelSettlementApprovalInput, CreateChannelSettlementPolicyInput, UpdateChannelReconciliationPolicyInput, UpdateChannelReleaseScheduleInput, UpdateChannelRemittanceExceptionInput, UpdateChannelSettlementApprovalInput, UpdateChannelSettlementPolicyInput } from "./types.js";
+export declare const settlementPolicyServiceOperations: {
+    listSettlementPolicies(db: PostgresJsDatabase, query: ChannelSettlementPolicyListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            contractId: string | null;
+            frequency: "manual" | "daily" | "weekly" | "monthly";
+            autoGenerate: boolean;
+            approvalRequired: boolean;
+            remittanceDaysAfterPeriodEnd: number | null;
+            minimumPayoutAmountCents: number | null;
+            currencyCode: string | null;
+            active: boolean;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getSettlementPolicyById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        frequency: "manual" | "daily" | "weekly" | "monthly";
+        autoGenerate: boolean;
+        approvalRequired: boolean;
+        remittanceDaysAfterPeriodEnd: number | null;
+        minimumPayoutAmountCents: number | null;
+        currencyCode: string | null;
+        active: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createSettlementPolicy(db: PostgresJsDatabase, data: CreateChannelSettlementPolicyInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        active: boolean;
+        channelId: string;
+        notes: string | null;
+        contractId: string | null;
+        currencyCode: string | null;
+        frequency: "manual" | "daily" | "weekly" | "monthly";
+        autoGenerate: boolean;
+        approvalRequired: boolean;
+        remittanceDaysAfterPeriodEnd: number | null;
+        minimumPayoutAmountCents: number | null;
+    } | undefined>;
+    updateSettlementPolicy(db: PostgresJsDatabase, id: string, data: UpdateChannelSettlementPolicyInput): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        frequency: "manual" | "daily" | "weekly" | "monthly";
+        autoGenerate: boolean;
+        approvalRequired: boolean;
+        remittanceDaysAfterPeriodEnd: number | null;
+        minimumPayoutAmountCents: number | null;
+        currencyCode: string | null;
+        active: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteSettlementPolicy(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listReconciliationPolicies(db: PostgresJsDatabase, query: ChannelReconciliationPolicyListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            contractId: string | null;
+            frequency: "manual" | "daily" | "weekly" | "monthly";
+            autoRun: boolean;
+            compareGrossAmounts: boolean;
+            compareStatuses: boolean;
+            compareCancellations: boolean;
+            amountToleranceCents: number | null;
+            active: boolean;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getReconciliationPolicyById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        frequency: "manual" | "daily" | "weekly" | "monthly";
+        autoRun: boolean;
+        compareGrossAmounts: boolean;
+        compareStatuses: boolean;
+        compareCancellations: boolean;
+        amountToleranceCents: number | null;
+        active: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createReconciliationPolicy(db: PostgresJsDatabase, data: CreateChannelReconciliationPolicyInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        active: boolean;
+        channelId: string;
+        notes: string | null;
+        contractId: string | null;
+        frequency: "manual" | "daily" | "weekly" | "monthly";
+        autoRun: boolean;
+        compareGrossAmounts: boolean;
+        compareStatuses: boolean;
+        compareCancellations: boolean;
+        amountToleranceCents: number | null;
+    } | undefined>;
+    updateReconciliationPolicy(db: PostgresJsDatabase, id: string, data: UpdateChannelReconciliationPolicyInput): Promise<{
+        id: string;
+        channelId: string;
+        contractId: string | null;
+        frequency: "manual" | "daily" | "weekly" | "monthly";
+        autoRun: boolean;
+        compareGrossAmounts: boolean;
+        compareStatuses: boolean;
+        compareCancellations: boolean;
+        amountToleranceCents: number | null;
+        active: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteReconciliationPolicy(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listReleaseSchedules(db: PostgresJsDatabase, query: ChannelReleaseScheduleListQuery): Promise<{
+        data: {
+            id: string;
+            releaseRuleId: string;
+            scheduleKind: "manual" | "daily" | "hourly";
+            nextRunAt: Date | null;
+            lastRunAt: Date | null;
+            active: boolean;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getReleaseScheduleById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        releaseRuleId: string;
+        scheduleKind: "manual" | "daily" | "hourly";
+        nextRunAt: Date | null;
+        lastRunAt: Date | null;
+        active: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createReleaseSchedule(db: PostgresJsDatabase, data: CreateChannelReleaseScheduleInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        active: boolean;
+        notes: string | null;
+        releaseRuleId: string;
+        scheduleKind: "manual" | "daily" | "hourly";
+        nextRunAt: Date | null;
+        lastRunAt: Date | null;
+    } | undefined>;
+    updateReleaseSchedule(db: PostgresJsDatabase, id: string, data: UpdateChannelReleaseScheduleInput): Promise<{
+        id: string;
+        releaseRuleId: string;
+        scheduleKind: "manual" | "daily" | "hourly";
+        nextRunAt: Date | null;
+        lastRunAt: Date | null;
+        active: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteReleaseSchedule(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listRemittanceExceptions(db: PostgresJsDatabase, query: ChannelRemittanceExceptionListQuery): Promise<{
+        data: {
+            id: string;
+            channelId: string;
+            settlementItemId: string | null;
+            reconciliationItemId: string | null;
+            exceptionType: string;
+            severity: "error" | "info" | "warning";
+            status: "ignored" | "open" | "resolved" | "investigating";
+            openedAt: Date;
+            resolvedAt: Date | null;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getRemittanceExceptionById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        channelId: string;
+        settlementItemId: string | null;
+        reconciliationItemId: string | null;
+        exceptionType: string;
+        severity: "error" | "info" | "warning";
+        status: "ignored" | "open" | "resolved" | "investigating";
+        openedAt: Date;
+        resolvedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createRemittanceException(db: PostgresJsDatabase, data: CreateChannelRemittanceExceptionInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        status: "ignored" | "open" | "resolved" | "investigating";
+        channelId: string;
+        notes: string | null;
+        severity: "error" | "info" | "warning";
+        resolvedAt: Date | null;
+        settlementItemId: string | null;
+        reconciliationItemId: string | null;
+        exceptionType: string;
+        openedAt: Date;
+    } | undefined>;
+    updateRemittanceException(db: PostgresJsDatabase, id: string, data: UpdateChannelRemittanceExceptionInput): Promise<{
+        id: string;
+        channelId: string;
+        settlementItemId: string | null;
+        reconciliationItemId: string | null;
+        exceptionType: string;
+        severity: "error" | "info" | "warning";
+        status: "ignored" | "open" | "resolved" | "investigating";
+        openedAt: Date;
+        resolvedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteRemittanceException(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listSettlementApprovals(db: PostgresJsDatabase, query: ChannelSettlementApprovalListQuery): Promise<{
+        data: {
+            id: string;
+            settlementRunId: string;
+            approverUserId: string | null;
+            status: "pending" | "approved" | "rejected";
+            decidedAt: Date | null;
+            notes: string | null;
+            metadata: Record<string, unknown> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getSettlementApprovalById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        settlementRunId: string;
+        approverUserId: string | null;
+        status: "pending" | "approved" | "rejected";
+        decidedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createSettlementApproval(db: PostgresJsDatabase, data: CreateChannelSettlementApprovalInput): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        status: "pending" | "approved" | "rejected";
+        notes: string | null;
+        settlementRunId: string;
+        approverUserId: string | null;
+        decidedAt: Date | null;
+    } | undefined>;
+    updateSettlementApproval(db: PostgresJsDatabase, id: string, data: UpdateChannelSettlementApprovalInput): Promise<{
+        id: string;
+        settlementRunId: string;
+        approverUserId: string | null;
+        status: "pending" | "approved" | "rejected";
+        decidedAt: Date | null;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteSettlementApproval(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=settlement-policies.d.ts.map

package/dist/service/settlement-policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlement-policies.d.ts","sourceRoot":"","sources":["../../src/service/settlement-policies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAUjE,OAAO,KAAK,EACV,oCAAoC,EACpC,+BAA+B,EAC/B,mCAAmC,EACnC,kCAAkC,EAClC,gCAAgC,EAChC,sCAAsC,EACtC,iCAAiC,EACjC,qCAAqC,EACrC,oCAAoC,EACpC,kCAAkC,EAClC,sCAAsC,EACtC,iCAAiC,EACjC,qCAAqC,EACrC,oCAAoC,EACpC,kCAAkC,EACnC,MAAM,YAAY,CAAA;AAEnB,eAAO,MAAM,iCAAiC;+BACX,kBAAkB,SAAS,gCAAgC;;;;;;;;;;;;;;;;;;;;;gCAuB1D,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;+BAS/B,kBAAkB,QAAQ,kCAAkC;;;;;;;;;;;;;;;;+BAMvF,kBAAkB,MAClB,MAAM,QACJ,kCAAkC;;;;;;;;;;;;;;;;+BAUT,kBAAkB,MAAM,MAAM;;;mCASzD,kBAAkB,SACf,oCAAoC;;;;;;;;;;;;;;;;;;;;;oCA6BP,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;mCAU9D,kBAAkB,QAChB,sCAAsC;;;;;;;;;;;;;;;;mCAOxC,kBAAkB,MAClB,MAAM,QACJ,sCAAsC;;;;;;;;;;;;;;;;mCAUT,kBAAkB,MAAM,MAAM;;;6BAQpC,kBAAkB,SAAS,+BAA+B;;;;;;;;;;;;;;;;;+BAuBxD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;8BAS/B,kBAAkB,QAAQ,iCAAiC;;;;;;;;;;;;8BAarF,kBAAkB,MAClB,MAAM,QACJ,iCAAiC;;;;;;;;;;;;8BAeT,kBAAkB,MAAM,MAAM;;;iCASxD,kBAAkB,SACf,mCAAmC;;;;;;;;;;;;;;;;;;;;mCA6BP,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;kCAU7D,kBAAkB,QAChB,qCAAqC;;;;;;;;;;;;;;;kCAcvC,kBAAkB,MAClB,MAAM,QACJ,qCAAqC;;;;;;;;;;;;;;;kCAeT,kBAAkB,MAAM,MAAM;;;gCAQhC,kBAAkB,SAAS,kCAAkC;;;;;;;;;;;;;;;;kCAuB3D,kBAAkB,MAAM,MAAM;;;;;;;;;;;iCAU5D,kBAAkB,QAChB,oCAAoC;;;;;;;;;;;iCAatC,kBAAkB,MAClB,MAAM,QACJ,oCAAoC;;;;;;;;;;;iCAcT,kBAAkB,MAAM,MAAM;;;CAOlE,CAAA"}

package/dist/service/settlement-policies.js

@@ -0,0 +1,272 @@
+import { and, desc, eq, sql } from "drizzle-orm";
+import { channelReconciliationPolicies, channelReleaseSchedules, channelRemittanceExceptions, channelSettlementApprovals, channelSettlementPolicies, } from "../schema.js";
+import { paginate, toDateOrNull } from "./helpers.js";
+export const settlementPolicyServiceOperations = {
+    async listSettlementPolicies(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelSettlementPolicies.channelId, query.channelId));
+        if (query.contractId)
+            conditions.push(eq(channelSettlementPolicies.contractId, query.contractId));
+        if (query.frequency)
+            conditions.push(eq(channelSettlementPolicies.frequency, query.frequency));
+        if (query.active !== undefined)
+            conditions.push(eq(channelSettlementPolicies.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelSettlementPolicies)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelSettlementPolicies.updatedAt)), db.select({ count: sql `count(*)::int` }).from(channelSettlementPolicies).where(where), query.limit, query.offset);
+    },
+    async getSettlementPolicyById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelSettlementPolicies)
+            .where(eq(channelSettlementPolicies.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createSettlementPolicy(db, data) {
+        const [row] = await db.insert(channelSettlementPolicies).values(data).returning();
+        return row;
+    },
+    async updateSettlementPolicy(db, id, data) {
+        const [row] = await db
+            .update(channelSettlementPolicies)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelSettlementPolicies.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteSettlementPolicy(db, id) {
+        const [row] = await db
+            .delete(channelSettlementPolicies)
+            .where(eq(channelSettlementPolicies.id, id))
+            .returning({ id: channelSettlementPolicies.id });
+        return row ?? null;
+    },
+    async listReconciliationPolicies(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelReconciliationPolicies.channelId, query.channelId));
+        if (query.contractId)
+            conditions.push(eq(channelReconciliationPolicies.contractId, query.contractId));
+        if (query.frequency)
+            conditions.push(eq(channelReconciliationPolicies.frequency, query.frequency));
+        if (query.active !== undefined)
+            conditions.push(eq(channelReconciliationPolicies.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelReconciliationPolicies)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelReconciliationPolicies.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelReconciliationPolicies)
+            .where(where), query.limit, query.offset);
+    },
+    async getReconciliationPolicyById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelReconciliationPolicies)
+            .where(eq(channelReconciliationPolicies.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createReconciliationPolicy(db, data) {
+        const [row] = await db.insert(channelReconciliationPolicies).values(data).returning();
+        return row;
+    },
+    async updateReconciliationPolicy(db, id, data) {
+        const [row] = await db
+            .update(channelReconciliationPolicies)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(channelReconciliationPolicies.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteReconciliationPolicy(db, id) {
+        const [row] = await db
+            .delete(channelReconciliationPolicies)
+            .where(eq(channelReconciliationPolicies.id, id))
+            .returning({ id: channelReconciliationPolicies.id });
+        return row ?? null;
+    },
+    async listReleaseSchedules(db, query) {
+        const conditions = [];
+        if (query.releaseRuleId)
+            conditions.push(eq(channelReleaseSchedules.releaseRuleId, query.releaseRuleId));
+        if (query.scheduleKind)
+            conditions.push(eq(channelReleaseSchedules.scheduleKind, query.scheduleKind));
+        if (query.active !== undefined)
+            conditions.push(eq(channelReleaseSchedules.active, query.active));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelReleaseSchedules)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelReleaseSchedules.updatedAt)), db.select({ count: sql `count(*)::int` }).from(channelReleaseSchedules).where(where), query.limit, query.offset);
+    },
+    async getReleaseScheduleById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelReleaseSchedules)
+            .where(eq(channelReleaseSchedules.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createReleaseSchedule(db, data) {
+        const [row] = await db
+            .insert(channelReleaseSchedules)
+            .values({
+            ...data,
+            nextRunAt: toDateOrNull(data.nextRunAt),
+            lastRunAt: toDateOrNull(data.lastRunAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateReleaseSchedule(db, id, data) {
+        const [row] = await db
+            .update(channelReleaseSchedules)
+            .set({
+            ...data,
+            nextRunAt: toDateOrNull(data.nextRunAt),
+            lastRunAt: toDateOrNull(data.lastRunAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelReleaseSchedules.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteReleaseSchedule(db, id) {
+        const [row] = await db
+            .delete(channelReleaseSchedules)
+            .where(eq(channelReleaseSchedules.id, id))
+            .returning({ id: channelReleaseSchedules.id });
+        return row ?? null;
+    },
+    async listRemittanceExceptions(db, query) {
+        const conditions = [];
+        if (query.channelId)
+            conditions.push(eq(channelRemittanceExceptions.channelId, query.channelId));
+        if (query.settlementItemId)
+            conditions.push(eq(channelRemittanceExceptions.settlementItemId, query.settlementItemId));
+        if (query.reconciliationItemId)
+            conditions.push(eq(channelRemittanceExceptions.reconciliationItemId, query.reconciliationItemId));
+        if (query.status)
+            conditions.push(eq(channelRemittanceExceptions.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelRemittanceExceptions)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelRemittanceExceptions.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelRemittanceExceptions)
+            .where(where), query.limit, query.offset);
+    },
+    async getRemittanceExceptionById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelRemittanceExceptions)
+            .where(eq(channelRemittanceExceptions.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createRemittanceException(db, data) {
+        const [row] = await db
+            .insert(channelRemittanceExceptions)
+            .values({
+            ...data,
+            openedAt: toDateOrNull(data.openedAt) ?? new Date(),
+            resolvedAt: toDateOrNull(data.resolvedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateRemittanceException(db, id, data) {
+        const [row] = await db
+            .update(channelRemittanceExceptions)
+            .set({
+            ...data,
+            openedAt: data.openedAt ? new Date(data.openedAt) : undefined,
+            resolvedAt: toDateOrNull(data.resolvedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelRemittanceExceptions.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteRemittanceException(db, id) {
+        const [row] = await db
+            .delete(channelRemittanceExceptions)
+            .where(eq(channelRemittanceExceptions.id, id))
+            .returning({ id: channelRemittanceExceptions.id });
+        return row ?? null;
+    },
+    async listSettlementApprovals(db, query) {
+        const conditions = [];
+        if (query.settlementRunId)
+            conditions.push(eq(channelSettlementApprovals.settlementRunId, query.settlementRunId));
+        if (query.status)
+            conditions.push(eq(channelSettlementApprovals.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(channelSettlementApprovals)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(channelSettlementApprovals.updatedAt)), db
+            .select({ count: sql `count(*)::int` })
+            .from(channelSettlementApprovals)
+            .where(where), query.limit, query.offset);
+    },
+    async getSettlementApprovalById(db, id) {
+        const [row] = await db
+            .select()
+            .from(channelSettlementApprovals)
+            .where(eq(channelSettlementApprovals.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createSettlementApproval(db, data) {
+        const [row] = await db
+            .insert(channelSettlementApprovals)
+            .values({
+            ...data,
+            decidedAt: toDateOrNull(data.decidedAt),
+        })
+            .returning();
+        return row;
+    },
+    async updateSettlementApproval(db, id, data) {
+        const [row] = await db
+            .update(channelSettlementApprovals)
+            .set({
+            ...data,
+            decidedAt: toDateOrNull(data.decidedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(channelSettlementApprovals.id, id))
+            .returning();
+        return row ?? null;
+    },
+    async deleteSettlementApproval(db, id) {
+        const [row] = await db
+            .delete(channelSettlementApprovals)
+            .where(eq(channelSettlementApprovals.id, id))
+            .returning({ id: channelSettlementApprovals.id });
+        return row ?? null;
+    },
+};