@voyant-travel/distribution 0.109.8

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":"AA+BA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;EAe3B,CAAA;AAEH,eAAO,MAAM,kCAAkC;;EAQ9C,CAAA;AAED,eAAO,MAAM,yBAAyB;;;;;;;EAUnC,CAAA;AAEH,eAAO,MAAM,+BAA+B;;EAKzC,CAAA;AAEH,eAAO,MAAM,+BAA+B;;EAKzC,CAAA;AAEH,eAAO,MAAM,4BAA4B;;EAKtC,CAAA;AAEH,eAAO,MAAM,mCAAmC;;;;;;EAe/C,CAAA;AAED,eAAO,MAAM,yCAAyC;;EAQrD,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;;;;EAgBtD,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,196 @@
+import { relations } from "drizzle-orm";
+import { channelReconciliationPolicies, channelReleaseSchedules, channelSettlementPolicies, } from "./schema-automation.js";
+import { channelBookingLinks, channelCommissionRules, channelContactProjections, channelContracts, channelProductMappings, channels, channelWebhookEvents, } from "./schema-core.js";
+import { channelReconciliationItems, channelReconciliationRuns, channelRemittanceExceptions, channelSettlementApprovals, channelSettlementItems, channelSettlementRuns, } from "./schema-finance.js";
+import { channelInventoryAllotments, channelInventoryAllotmentTargets, channelInventoryReleaseExecutions, channelInventoryReleaseRules, } from "./schema-inventory.js";
+import { suppliers } from "./suppliers/schema.js";
+export const channelsRelations = relations(channels, ({ many, one }) => ({
+    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),
+    contactProjection: one(channelContactProjections, {
+        fields: [channels.id],
+        references: [channelContactProjections.channelId],
+    }),
+}));
+export const channelContactProjectionsRelations = relations(channelContactProjections, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelContactProjections.channelId],
+        references: [channels.id],
+    }),
+}));
+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],
+    }),
+}));
+export const channelProductMappingsRelations = relations(channelProductMappings, ({ one }) => ({
+    channel: one(channels, {
+        fields: [channelProductMappings.channelId],
+        references: [channels.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],
+    }),
+    targets: many(channelInventoryAllotmentTargets),
+    releaseRules: many(channelInventoryReleaseRules),
+    releaseExecutions: many(channelInventoryReleaseExecutions),
+}));
+export const channelInventoryAllotmentTargetsRelations = relations(channelInventoryAllotmentTargets, ({ one }) => ({
+    allotment: one(channelInventoryAllotments, {
+        fields: [channelInventoryAllotmentTargets.allotmentId],
+        references: [channelInventoryAllotments.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],
+    }),
+}));
+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", "connect"]>;
+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,2HAQ1B,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,123 @@
+import { pgEnum } from "drizzle-orm/pg-core";
+export const channelKindEnum = pgEnum("channel_kind", [
+    "direct",
+    "affiliate",
+    "ota",
+    "reseller",
+    "marketplace",
+    "api_partner",
+    "connect",
+]);
+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",
+]);

package/dist/schema.d.ts

@@ -0,0 +1,9 @@
+export { bookingDistributionDetails, bookingPaymentOwnerEnum } from "./booking-extension.js";
+export * from "./schema-automation.js";
+export * from "./schema-core.js";
+export * from "./schema-finance.js";
+export * from "./schema-inventory.js";
+export * from "./schema-push-intents.js";
+export * from "./schema-relations.js";
+export * from "./schema-shared.js";
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAA;AAC5F,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA;AACnC,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA"}

package/dist/schema.js

@@ -0,0 +1,8 @@
+export { bookingDistributionDetails, bookingPaymentOwnerEnum } from "./booking-extension.js";
+export * from "./schema-automation.js";
+export * from "./schema-core.js";
+export * from "./schema-finance.js";
+export * from "./schema-inventory.js";
+export * from "./schema-push-intents.js";
+export * from "./schema-relations.js";
+export * from "./schema-shared.js";

package/dist/service/channels.d.ts

@@ -0,0 +1,167 @@
+import type { InsertContactPointForEntity, InsertNamedContactForEntity, UpdateContactPoint as UpdateIdentityContactPoint, UpdateNamedContact as UpdateIdentityNamedContact } from "@voyant-travel/identity/validation";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { Channel } from "../schema.js";
+import type { ChannelListQuery, CreateChannelInput, UpdateChannelInput } from "./types.js";
+type ChannelHydratedFields = {
+    website: string | null;
+    contactName: string | null;
+    contactEmail: string | null;
+};
+export declare const channelServiceOperations: {
+    listChannels(db: PostgresJsDatabase, query: ChannelListQuery): Promise<{
+        data: ({
+            id: string;
+            name: string;
+            description: string | null;
+            kind: "direct" | "affiliate" | "ota" | "reseller" | "marketplace" | "api_partner" | "connect";
+            status: "active" | "inactive" | "pending" | "archived";
+            metadata: Record<string, unknown> | null;
+            rateLimitRps: number | null;
+            rateLimitBurst: number | null;
+            rateLimitPriorityGates: Record<string, number> | null;
+            createdAt: Date;
+            updatedAt: Date;
+        } & ChannelHydratedFields)[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getChannelById(db: PostgresJsDatabase, id: string): Promise<({
+        id: string;
+        name: string;
+        description: string | null;
+        kind: "direct" | "affiliate" | "ota" | "reseller" | "marketplace" | "api_partner" | "connect";
+        status: "active" | "inactive" | "pending" | "archived";
+        metadata: Record<string, unknown> | null;
+        rateLimitRps: number | null;
+        rateLimitBurst: number | null;
+        rateLimitPriorityGates: Record<string, number> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } & ChannelHydratedFields) | null>;
+    createChannel(db: PostgresJsDatabase, data: CreateChannelInput): Promise<({
+        id: string;
+        name: string;
+        description: string | null;
+        kind: "direct" | "affiliate" | "ota" | "reseller" | "marketplace" | "api_partner" | "connect";
+        status: "active" | "inactive" | "pending" | "archived";
+        metadata: Record<string, unknown> | null;
+        rateLimitRps: number | null;
+        rateLimitBurst: number | null;
+        rateLimitPriorityGates: Record<string, number> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } & ChannelHydratedFields) | null>;
+    updateChannel(db: PostgresJsDatabase, id: string, data: UpdateChannelInput): Promise<({
+        id: string;
+        name: string;
+        description: string | null;
+        kind: "direct" | "affiliate" | "ota" | "reseller" | "marketplace" | "api_partner" | "connect";
+        status: "active" | "inactive" | "pending" | "archived";
+        metadata: Record<string, unknown> | null;
+        rateLimitRps: number | null;
+        rateLimitBurst: number | null;
+        rateLimitPriorityGates: Record<string, number> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } & ChannelHydratedFields) | null>;
+    deleteChannel(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listChannelContactPoints(db: PostgresJsDatabase, channelId: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        kind: "other" | "website" | "email" | "phone" | "mobile" | "whatsapp" | "sms" | "fax" | "social";
+        label: string | null;
+        value: string;
+        normalizedValue: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[] | null>;
+    createChannelContactPoint(db: PostgresJsDatabase, channelId: string, data: InsertContactPointForEntity): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        value: string;
+        id: string;
+        kind: "other" | "website" | "email" | "phone" | "mobile" | "whatsapp" | "sms" | "fax" | "social";
+        notes: string | null;
+        entityType: string;
+        entityId: string;
+        isPrimary: boolean;
+        label: string | null;
+        normalizedValue: string | null;
+    } | null>;
+    updateChannelContactPoint(db: PostgresJsDatabase, id: string, data: UpdateIdentityContactPoint): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        kind: "other" | "website" | "email" | "phone" | "mobile" | "whatsapp" | "sms" | "fax" | "social";
+        label: string | null;
+        value: string;
+        normalizedValue: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteChannelContactPoint(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+    listChannelContacts(db: PostgresJsDatabase, channelId: string): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        role: "primary" | "other" | "general" | "reservations" | "operations" | "front_desk" | "sales" | "emergency" | "accounting" | "legal";
+        name: string;
+        title: string | null;
+        email: string | null;
+        phone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }[] | null>;
+    createChannelContact(db: PostgresJsDatabase, channelId: string, data: InsertNamedContactForEntity): Promise<{
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: Record<string, unknown> | null;
+        id: string;
+        title: string | null;
+        notes: string | null;
+        entityType: string;
+        entityId: string;
+        isPrimary: boolean;
+        email: string | null;
+        phone: string | null;
+        role: "primary" | "other" | "general" | "reservations" | "operations" | "front_desk" | "sales" | "emergency" | "accounting" | "legal";
+    } | null>;
+    updateChannelContact(db: PostgresJsDatabase, id: string, data: UpdateIdentityNamedContact): Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        role: "primary" | "other" | "general" | "reservations" | "operations" | "front_desk" | "sales" | "emergency" | "accounting" | "legal";
+        name: string;
+        title: string | null;
+        email: string | null;
+        phone: string | null;
+        isPrimary: boolean;
+        notes: string | null;
+        metadata: Record<string, unknown> | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deleteChannelContact(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+    } | null>;
+};
+export type HydratedChannel = Channel & ChannelHydratedFields;
+export {};
+//# sourceMappingURL=channels.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../src/service/channels.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,2BAA2B,EAC3B,2BAA2B,EAC3B,kBAAkB,IAAI,0BAA0B,EAChD,kBAAkB,IAAI,0BAA0B,EACjD,MAAM,oCAAoC,CAAA;AAE3C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAE3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAQ1F,KAAK,qBAAqB,GAAG;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5B,CAAA;AAkND,eAAO,MAAM,wBAAwB;qBACZ,kBAAkB,SAAS,gBAAgB;;;;;;;;;;;;;;;;;;uBAwBzC,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;sBAU/B,kBAAkB,QAAQ,kBAAkB;;;;;;;;;;;;;sBAS5C,kBAAkB,MAAM,MAAM,QAAQ,kBAAkB;;;;;;;;;;;;;sBAoBxD,kBAAkB,MAAM,MAAM;;;iCASnB,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;kCAOlE,kBAAkB,aACX,MAAM,QACX,2BAA2B;;;;;;;;;;;;;;kCAiB7B,kBAAkB,MAClB,MAAM,QACJ,0BAA0B;;;;;;;;;;;;;;kCAaE,kBAAkB,MAAM,MAAM;;;4BAWpC,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;6BAO7D,kBAAkB,aACX,MAAM,QACX,2BAA2B;;;;;;;;;;;;;;;6BAgBJ,kBAAkB,MAAM,MAAM,QAAQ,0BAA0B;;;;;;;;;;;;;;;6BAYhE,kBAAkB,MAAM,MAAM;;;CAU9D,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,qBAAqB,CAAA"}