@riverbankcms/sdk 0.130.2 → 0.132.0

package/dist/_dts/commerce/src/purchase/orderConfirmationPlanning.d.ts

@@ -0,0 +1,120 @@
+import type { OrderInstalmentSummary } from '../../../core/src/index';
+import type { CreditProductUseCase } from './orderItemMetadata';
+import type { OrderPaymentMethod, OrderStatus } from './orderTypes';
+export type OrderConfirmationLineItem = Readonly<{
+    title: string;
+    subtitle?: string | null;
+    quantity: number;
+    amountCents: number;
+}>;
+export type OrderConfirmationPassDetail = Readonly<{
+    name: string;
+    productUseCase?: CreditProductUseCase;
+    creditsTotal: number;
+    expiresAt: string | null;
+    readyToUseNote: string;
+}>;
+export type PassOnlyOrderConfirmationVariant = Readonly<{
+    kind: 'pass_only';
+    passes: readonly [
+        OrderConfirmationPassDetail,
+        ...OrderConfirmationPassDetail[]
+    ];
+}>;
+export type StandardOrderConfirmationVariant = Readonly<{
+    kind: 'order';
+}>;
+export type OrderConfirmationVariant = PassOnlyOrderConfirmationVariant | StandardOrderConfirmationVariant;
+export type OrderConfirmationShippingDetails = Readonly<{
+    recipient: string | null;
+    addressLines: readonly string[];
+    costCents: number;
+    currency: string;
+    methodLabel?: string;
+}>;
+export type OrderConfirmationReceiptDetails = Readonly<{
+    orderNumber: string;
+    purchaseDate: string;
+    lineItems: readonly OrderConfirmationLineItem[];
+    subtotalCents: number;
+    discountCents: number;
+    creditCents: number;
+    taxCents: number;
+    shippingCents: number;
+    totalCents: number;
+    currency: string;
+    paymentMethodLabel: string;
+    paymentSummary: string | null;
+    paymentSchedule: Readonly<{
+        rows: readonly Readonly<{
+            label: string;
+            dueAt: string;
+            amountCents: number;
+        }>[];
+    }> | null;
+}>;
+export type OrderConfirmationTemplateVariables = Record<string, string | undefined>;
+export type OrderConfirmationEmailContent = Readonly<{
+    customerName: string;
+    siteTitle: string;
+    orderSubject: string;
+    heading: string;
+    introText: string;
+    orderReceiptDetails: OrderConfirmationReceiptDetails;
+    orderPassDetails?: Readonly<{
+        passes: readonly OrderConfirmationPassDetail[];
+    }>;
+    orderShippingDetails?: OrderConfirmationShippingDetails;
+    portalLink?: string;
+}>;
+export type OrderConfirmationContent = Readonly<{
+    customerDisplayName: string;
+    templateVars: OrderConfirmationTemplateVariables;
+    orderReceiptDetails: OrderConfirmationReceiptDetails;
+    emailData: OrderConfirmationEmailContent;
+}>;
+type OrderConfirmationOrderSource = Readonly<{
+    orderNumber: string;
+    subtotalCents: number;
+    discountCents: number;
+    creditCents: number;
+    taxCents: number;
+    shippingCents: number;
+    currency: string;
+    createdAt: string;
+    updatedAt: string | null;
+    status: OrderStatus;
+    paymentMethod: OrderPaymentMethod;
+    shippingAddressJson: unknown;
+    stripeShippingSnapshot: unknown;
+}>;
+export type OrderConfirmationSettlement = Readonly<{
+    collectedCents: number;
+}>;
+export type OrderConfirmationFormatters = Readonly<{
+    formatCurrencyAmount: (amountCents: number, currency: string) => string;
+    formatDateTime: (isoString: string) => string;
+    formatInstalmentStatusLabel: (row: OrderInstalmentSummary['rows'][number]) => string;
+    resolveCustomerDisplayName: (name: string | null, email: string) => string;
+}>;
+export declare function resolveOrderConfirmationShippingDetails(order: OrderConfirmationOrderSource): OrderConfirmationShippingDetails | undefined;
+export declare function resolveOrderConfirmationVariant<TItem extends Readonly<{
+    kind: string;
+}>>(items: readonly TItem[], passDetails: readonly OrderConfirmationPassDetail[]): OrderConfirmationVariant;
+export declare function resolveOrderConfirmationPaymentMethodLabel(paymentMethod: OrderPaymentMethod): string;
+export declare function resolveOrderConfirmationPaymentSummary(order: Pick<OrderConfirmationOrderSource, 'paymentMethod' | 'creditCents' | 'currency' | 'subtotalCents' | 'discountCents' | 'taxCents' | 'shippingCents'>, settlement: OrderConfirmationSettlement, formatCurrencyAmount: OrderConfirmationFormatters['formatCurrencyAmount']): string | null;
+export declare function buildOrderConfirmationContent(input: Readonly<{
+    order: OrderConfirmationOrderSource;
+    customerEmail: string;
+    customerName: string | null;
+    siteTitle: string | null;
+    confirmationVariant: OrderConfirmationVariant;
+    lineItems: readonly OrderConfirmationLineItem[];
+    passDetails: readonly OrderConfirmationPassDetail[];
+    instalmentPlan?: OrderInstalmentSummary | null;
+    settlement: OrderConfirmationSettlement;
+    shippingDetails?: OrderConfirmationShippingDetails;
+    portalLink?: string | null;
+    formatters: OrderConfirmationFormatters;
+}>): OrderConfirmationContent;
+export {};

package/dist/_dts/commerce/src/purchase/orderFulfillmentPlan.d.ts

@@ -0,0 +1,81 @@
+import { type AttendeeId, type Result } from '../../../core/src/index';
+import type { OrderItemPlanningRecord } from './orderPlanningTypes';
+import type { OrderPaymentMethod } from './orderTypes';
+export type OrderItemFulfillmentPlan = {
+    kind: 'event_ticket';
+    attendeeId: AttendeeId;
+    paymentStatus: 'completed' | 'not_required';
+} | {
+    kind: 'product';
+} | {
+    kind: 'pass';
+    existingCustomerPassId: string | null;
+    passId: string;
+    bundleFulfillment: {
+        attendeeId: AttendeeId;
+        eventInstanceId: string | null;
+        ticketsCount: number;
+    } | null;
+} | {
+    kind: 'course_enrollment';
+    enrollmentId: string;
+    eventSeriesId: string;
+    paymentMethod: 'stripe' | 'free' | 'membership';
+    paymentStatus: 'completed' | 'not_required';
+} | {
+    kind: 'appointment';
+    appointmentId: string;
+    nextStatus: 'confirmed';
+    customerName: string;
+    customerEmail: string;
+    displayName: string | null;
+} | {
+    kind: 'membership';
+};
+export declare function planOrderItemFulfillment(item: OrderItemPlanningRecord, orderPaymentMethod: OrderPaymentMethod): Result<OrderItemFulfillmentPlan, string>;
+export type OrderItemCancellationPlan = {
+    kind: 'event_ticket';
+    attendeeId: AttendeeId;
+} | {
+    kind: 'course_enrollment';
+    enrollmentId: string;
+} | {
+    kind: 'appointment';
+    appointmentId: string;
+} | {
+    kind: 'product';
+} | {
+    kind: 'pass';
+    customerPassId: string | null;
+    bundleAttendeeId: AttendeeId | null;
+} | {
+    kind: 'membership';
+    customerMembershipId: string | null;
+    bundleAttendeeId: AttendeeId | null;
+};
+export declare function planOrderItemCancellation(item: OrderItemPlanningRecord): Result<OrderItemCancellationPlan, string>;
+export type OrderItemRefundRevocationPlan = {
+    kind: 'event_ticket';
+    attendeeId: AttendeeId;
+} | {
+    kind: 'product';
+} | {
+    kind: 'course_enrollment';
+    enrollmentId: string;
+} | {
+    kind: 'appointment';
+    appointmentId: string;
+} | {
+    kind: 'pass';
+    customerPassId: string | null;
+    bundleAttendeeId: AttendeeId | null;
+} | {
+    kind: 'membership';
+    customerMembershipId: string | null;
+    bundleAttendeeId: AttendeeId | null;
+};
+export declare function planOrderItemRefundRevocation(item: OrderItemPlanningRecord): Result<OrderItemRefundRevocationPlan, string>;
+export declare function resolveCourseEnrollmentPaymentForFulfillment(orderPaymentMethod: OrderPaymentMethod): {
+    paymentMethod: 'stripe' | 'free' | 'membership';
+    paymentStatus: 'completed' | 'not_required';
+};

package/dist/_dts/commerce/src/purchase/orderFulfillmentResult.d.ts

@@ -0,0 +1,8 @@
+export type OrderFulfillmentResult = {
+    totalCount: number;
+    fulfilledCount: number;
+    inProgressCount: number;
+    failedCount: number;
+    inProgressItemIds: string[];
+    failedItemIds: string[];
+};

package/dist/_dts/commerce/src/purchase/orderHistoryLedgerFilters.d.ts

@@ -0,0 +1 @@
+export type OrderHistoryLedgerFilter = 'all' | 'products' | 'bookings' | 'passes' | 'memberships';

package/dist/_dts/commerce/src/purchase/orderHistorySource.d.ts

@@ -0,0 +1,11 @@
+export type OrderHistorySource = 'live' | 'ledger';
+export declare function hasLiveOrderHistorySource<TRecord extends {
+    historySource: OrderHistorySource;
+}>(record: TRecord): record is TRecord & Readonly<{
+    historySource: 'live';
+}>;
+export declare function hasArchivedOrderHistorySource<TRecord extends {
+    historySource: OrderHistorySource;
+}>(record: TRecord): record is TRecord & Readonly<{
+    historySource: 'ledger';
+}>;

package/dist/_dts/commerce/src/purchase/orderInstalmentAdminSettlement.d.ts

@@ -0,0 +1,43 @@
+import { type NonNegativeCents, type PositiveCents } from "../../../core/src/index";
+import type { OrderInstalmentPhaseKind, OrderInstalmentPlanStatus, OrderInstalmentStatus } from "./orderInstalmentPlan";
+type InstalmentPlanSnapshot = Readonly<{
+    status: OrderInstalmentPlanStatus;
+    remainingBalanceCents: NonNegativeCents;
+}>;
+type InstalmentRowSnapshot = Readonly<{
+    id: string;
+    sequence: number;
+    phaseKind: OrderInstalmentPhaseKind;
+    amountCents: NonNegativeCents;
+    status: OrderInstalmentStatus;
+}>;
+type InstalmentStatusUpdate = Readonly<{
+    instalmentId: string;
+    nextStatus: "paid" | "waived";
+}>;
+export type OrderInstalmentManualPaymentPlan = Readonly<{
+    kind: "already_applied";
+}> | Readonly<{
+    kind: "apply";
+    nextPlanStatus: Extract<OrderInstalmentPlanStatus, "active" | "completed">;
+    nextRemainingBalanceCents: NonNegativeCents;
+    instalmentUpdates: readonly InstalmentStatusUpdate[];
+}>;
+export type OrderInstalmentWaiverPlan = Readonly<{
+    kind: "already_applied";
+}> | Readonly<{
+    kind: "apply";
+    nextPlanStatus: "completed";
+    nextRemainingBalanceCents: NonNegativeCents;
+    instalmentUpdates: readonly InstalmentStatusUpdate[];
+}>;
+export declare function planOrderInstalmentManualPayment(input: Readonly<{
+    paymentPlan: InstalmentPlanSnapshot;
+    instalments: readonly InstalmentRowSnapshot[];
+    amountPaidCents: PositiveCents;
+}>): OrderInstalmentManualPaymentPlan;
+export declare function planOrderInstalmentWaiver(input: Readonly<{
+    paymentPlan: InstalmentPlanSnapshot;
+    instalments: readonly InstalmentRowSnapshot[];
+}>): OrderInstalmentWaiverPlan;
+export {};

package/dist/_dts/commerce/src/purchase/orderInstalmentClosure.d.ts

@@ -0,0 +1,29 @@
+import { type NonNegativeCents } from '../../../core/src/index';
+import type { OrderInstalmentPlanStatus, OrderInstalmentStatus } from './orderInstalmentPlan';
+type InstalmentClosureReason = 'cancelled' | 'refunded';
+type InstalmentClosurePlanSnapshot = Readonly<{
+    status: OrderInstalmentPlanStatus;
+    remainingBalanceCents: NonNegativeCents;
+}>;
+type InstalmentClosureRowSnapshot = Readonly<{
+    id: string;
+    status: OrderInstalmentStatus;
+}>;
+type InstalmentStatusUpdate = Readonly<{
+    instalmentId: string;
+    nextStatus: OrderInstalmentStatus;
+}>;
+export type OrderInstalmentClosurePlan = Readonly<{
+    kind: 'already_applied';
+}> | Readonly<{
+    kind: 'apply';
+    nextPlanStatus: Extract<OrderInstalmentPlanStatus, 'cancelled' | 'refunded'>;
+    nextRemainingBalanceCents: NonNegativeCents;
+    instalmentUpdates: readonly InstalmentStatusUpdate[];
+}>;
+export declare function planOrderInstalmentClosure(input: Readonly<{
+    paymentPlan: InstalmentClosurePlanSnapshot;
+    instalments: readonly InstalmentClosureRowSnapshot[];
+    reason: InstalmentClosureReason;
+}>): OrderInstalmentClosurePlan;
+export {};

package/dist/_dts/commerce/src/purchase/orderInstalmentLifecycle.d.ts

@@ -0,0 +1,44 @@
+import { type NonNegativeCents } from '../../../core/src/index';
+import type { OrderInstalmentPhaseKind, OrderInstalmentPlanStatus, OrderInstalmentStatus } from './orderInstalmentPlan';
+type InstalmentLifecyclePlanSnapshot = Readonly<{
+    status: OrderInstalmentPlanStatus;
+    remainingBalanceCents: NonNegativeCents;
+}>;
+type InstalmentLifecycleRowSnapshot = Readonly<{
+    id: string;
+    sequence: number;
+    phaseKind: OrderInstalmentPhaseKind;
+    amountCents: NonNegativeCents;
+    status: OrderInstalmentStatus;
+    stripeInvoiceId: string | null;
+}>;
+export type ApplyRecurringInstalmentPaymentPlan = Readonly<{
+    kind: 'already_applied';
+    instalmentId: string;
+}> | Readonly<{
+    kind: 'apply_payment';
+    instalmentId: string;
+    nextInstalmentStatus: 'paid';
+    nextPlanStatus: Extract<OrderInstalmentPlanStatus, 'active' | 'completed'>;
+    nextRemainingBalanceCents: NonNegativeCents;
+}>;
+export type ApplyRecurringInstalmentFailurePlan = Readonly<{
+    kind: 'already_applied';
+    instalmentId: string;
+}> | Readonly<{
+    kind: 'apply_failure';
+    instalmentId: string;
+    nextInstalmentStatus: 'failed';
+    nextPlanStatus: 'payment_failed';
+}>;
+export declare function planRecurringInstalmentInvoicePaid(input: Readonly<{
+    paymentPlan: InstalmentLifecyclePlanSnapshot;
+    instalments: readonly InstalmentLifecycleRowSnapshot[];
+    stripeInvoiceId: string;
+    amountPaidCents: NonNegativeCents;
+}>): ApplyRecurringInstalmentPaymentPlan;
+export declare function planRecurringInstalmentInvoiceFailed(input: Readonly<{
+    instalments: readonly InstalmentLifecycleRowSnapshot[];
+    stripeInvoiceId: string;
+}>): ApplyRecurringInstalmentFailurePlan;
+export {};

package/dist/_dts/commerce/src/purchase/orderInstalmentPayoff.d.ts

@@ -0,0 +1,24 @@
+import { type NonNegativeCents } from '../../../core/src/index';
+import type { OrderInstalmentPhaseKind, OrderInstalmentPlanStatus, OrderInstalmentStatus } from './orderInstalmentPlan';
+type InstalmentPayoffPlanSnapshot = Readonly<{
+    status: OrderInstalmentPlanStatus;
+    remainingBalanceCents: NonNegativeCents;
+}>;
+type InstalmentPayoffRowSnapshot = Readonly<{
+    id: string;
+    phaseKind: OrderInstalmentPhaseKind;
+    status: OrderInstalmentStatus;
+}>;
+export type OrderInstalmentPayoffPlan = Readonly<{
+    kind: 'already_applied';
+}> | Readonly<{
+    kind: 'apply';
+    nextPlanStatus: 'cancelled_as_paid_early';
+    nextRemainingBalanceCents: NonNegativeCents;
+    instalmentIdsToCancel: readonly string[];
+}>;
+export declare function planOrderInstalmentPayoff(input: Readonly<{
+    paymentPlan: InstalmentPayoffPlanSnapshot;
+    instalments: readonly InstalmentPayoffRowSnapshot[];
+}>): OrderInstalmentPayoffPlan;
+export {};

package/dist/_dts/commerce/src/purchase/orderInstalmentPlan.d.ts

@@ -0,0 +1,40 @@
+import type { BookingInstalmentPlanConfig, NonNegativeCents, OrderInstalmentPhaseKind, OrderInstalmentPlanStatus, OrderInstalmentStatus } from '../../../core/src/index';
+export type { OrderInstalmentPhaseKind, OrderInstalmentPlanStatus, OrderInstalmentStatus, } from '../../../core/src/index';
+export type OrderInstalmentScheduleRowDraft = Readonly<{
+    sequence: number;
+    phaseKind: OrderInstalmentPhaseKind;
+    dueAt: string;
+    amountCents: NonNegativeCents;
+    status: OrderInstalmentStatus;
+}>;
+export type OrderInstalmentPlanDraft = Readonly<{
+    kind: 'instalment_plan';
+    status: OrderInstalmentPlanStatus;
+    planDefinition: BookingInstalmentPlanConfig;
+    totalCents: NonNegativeCents;
+    initialPaymentCents: NonNegativeCents;
+    remainingBalanceCents: NonNegativeCents;
+    instalments: readonly [
+        OrderInstalmentScheduleRowDraft,
+        ...OrderInstalmentScheduleRowDraft[]
+    ];
+}>;
+export type OrderInstalmentStripeSchedulePhaseDraft = Readonly<{
+    startDateEpoch: number;
+    amountCents: NonNegativeCents;
+    durationInterval: 'day' | 'week' | 'month';
+    durationIntervalCount: number;
+    recurringInterval: 'day' | 'week' | 'month';
+    recurringIntervalCount: number;
+    sequenceStart: number;
+    sequenceEnd: number;
+}>;
+export declare function buildOrderInstalmentPlanDraft(input: Readonly<{
+    anchorAt: string;
+    totalCents: NonNegativeCents;
+    planDefinition: BookingInstalmentPlanConfig;
+}>): OrderInstalmentPlanDraft;
+export declare function buildOrderInstalmentStripeSchedulePhases(input: Readonly<{
+    planDefinition: BookingInstalmentPlanConfig;
+    instalments: readonly OrderInstalmentScheduleRowDraft[];
+}>): readonly [OrderInstalmentStripeSchedulePhaseDraft, ...OrderInstalmentStripeSchedulePhaseDraft[]];

package/dist/_dts/commerce/src/purchase/orderItemMetadata.d.ts

@@ -0,0 +1,151 @@
+import { type BrandedIdParseError, type CheckoutLineId, type CourseId, type CustomerId, type DatedOfferingCapacityHoldAuditRef, type DatedOfferingCapacityHoldId, type EventSeriesId, type EventInstanceId, type OccurrenceId, type PassId, type PricingOptionId, type TicketTypeId, type Result } from '../../../core/src/index';
+import type { OrderItemKind } from './orderTypes';
+export type CheckoutLineMetadata = Readonly<{
+    checkoutLineId?: CheckoutLineId;
+    displayName?: string;
+}>;
+export type StripeBookingCommissionOrderItemMetadata = Readonly<{
+    stripeBookingCommission?: Readonly<{
+        kind: 'application_fee_amount';
+        amountCents: number;
+        percent: number;
+    }>;
+}>;
+export type SlidingScaleOrderItemPricingSnapshot = Readonly<{
+    kind: 'sliding_scale';
+    version: 1;
+    currency: string;
+    minAmount: number;
+    maxAmount: number;
+    suggestedAmount: number | null;
+    chosenAmount: number;
+}>;
+export type BookableOrderItemPricingMetadata = Readonly<{
+    pricing?: SlidingScaleOrderItemPricingSnapshot;
+}>;
+export declare const DATED_OFFERING_ORDER_ITEM_ENGINE_METADATA_KEYS: {
+    readonly contractVersion: "datedOfferingEngineContractVersion";
+    readonly routeKind: "datedOfferingEngineRouteKind";
+    readonly capacityHoldId: "datedOfferingCapacityHoldId";
+    readonly capacityHoldAuditRef: "datedOfferingCapacityHoldAuditRef";
+    readonly courseId: "courseId";
+    readonly customerId: "customerId";
+    readonly eventSeriesId: "eventSeriesId";
+    readonly nonCashProjectionIdempotencyKey: "datedOfferingNonCashProjectionIdempotencyKey";
+};
+export type DatedOfferingOrderItemEngineMetadata = Readonly<{
+    datedOfferingEngineContractVersion: 'shared_v1';
+    datedOfferingEngineRouteKind: 'shared_whole_series_registration';
+    datedOfferingCapacityHoldId: DatedOfferingCapacityHoldId;
+    datedOfferingCapacityHoldAuditRef: DatedOfferingCapacityHoldAuditRef;
+    customerId: CustomerId;
+    eventSeriesId: EventSeriesId;
+}>;
+export type DatedOfferingNonCashOrderItemEngineMetadata = Readonly<{
+    datedOfferingEngineContractVersion: 'shared_v1';
+    datedOfferingEngineRouteKind: 'shared_whole_series_registration';
+    datedOfferingNonCashProjectionIdempotencyKey: string;
+    customerId: CustomerId;
+    eventSeriesId: EventSeriesId;
+}>;
+export type DatedOfferingOrderItemEngineMetadataParseError = Readonly<{
+    kind: 'invalid_engine_contract';
+}> | Readonly<{
+    kind: 'invalid_capacity_hold_id';
+    error: DatedOfferingMetadataRefParseError;
+}> | Readonly<{
+    kind: 'invalid_capacity_hold_audit_ref';
+    error: DatedOfferingMetadataRefParseError;
+}> | Readonly<{
+    kind: 'invalid_customer_id';
+    error: BrandedIdParseError;
+}> | Readonly<{
+    kind: 'invalid_event_series_id';
+    error: BrandedIdParseError;
+}>;
+export type DatedOfferingMetadataRefParseError = Readonly<{
+    kind: 'not_string';
+}> | Readonly<{
+    kind: 'empty_string';
+}> | Readonly<{
+    kind: 'invalid_uuid';
+}>;
+type LegacyDatedOfferingOrderItemEngineMetadata = Readonly<{
+    [TKey in keyof DatedOfferingOrderItemEngineMetadata]?: never;
+}>;
+export type CourseEnrollmentEngineMetadata = (LegacyDatedOfferingOrderItemEngineMetadata & Readonly<{
+    courseId: CourseId;
+}>) | DatedOfferingOrderItemEngineMetadata | DatedOfferingNonCashOrderItemEngineMetadata;
+export type EventTicketOrderItemMetadata = CheckoutLineMetadata & StripeBookingCommissionOrderItemMetadata & BookableOrderItemPricingMetadata & Readonly<{
+    eventSeriesId: string;
+    occurrenceId: OccurrenceId;
+    ticketTypeId?: TicketTypeId;
+    ticketCount: number;
+    attendeeEmail: string;
+    attendeeName: string;
+}>;
+export type ProductOrderItemMetadata = CheckoutLineMetadata & Readonly<{
+    productType?: 'physical' | 'digital';
+    requiresShipping?: boolean;
+}>;
+export type PassBundleFulfillmentMetadata = Readonly<{
+    occurrenceId: OccurrenceId;
+    eventInstanceId: EventInstanceId | null;
+    ticketsCount: number;
+    attendeeEmail: string;
+    attendeeName: string;
+    passName: string;
+}>;
+export type CreditProductUseCase = 'event_pass' | 'appointment_package';
+export declare function normalizeOrderCreditProductUseCase(value: unknown): Result<CreditProductUseCase, string>;
+export type PassOrderItemMetadata = CheckoutLineMetadata & Readonly<{
+    passId: PassId;
+    productUseCase?: CreditProductUseCase;
+    creditsTotal: number;
+    validDays: number | null;
+    bundleFulfillment?: PassBundleFulfillmentMetadata;
+}>;
+export type CourseEnrollmentOrderItemMetadata = CheckoutLineMetadata & StripeBookingCommissionOrderItemMetadata & BookableOrderItemPricingMetadata & CourseEnrollmentEngineMetadata & Readonly<{
+    pricingOptionId?: PricingOptionId;
+    attendeeEmail: string;
+    attendeeName: string;
+}>;
+export declare function parseDatedOfferingOrderItemEngineMetadata(raw: Record<string, unknown>): Result<DatedOfferingOrderItemEngineMetadata, DatedOfferingOrderItemEngineMetadataParseError>;
+export declare function parseDatedOfferingNonCashOrderItemEngineMetadata(raw: Record<string, unknown>): Result<DatedOfferingNonCashOrderItemEngineMetadata, DatedOfferingOrderItemEngineMetadataParseError>;
+export type AppointmentOrderItemMetadata = CheckoutLineMetadata & StripeBookingCommissionOrderItemMetadata & BookableOrderItemPricingMetadata & Readonly<{
+    serviceId: string;
+    resourceId: string;
+    startAt: string;
+    endAt: string;
+    timezone: string;
+    customerEmail: string;
+    customerName: string;
+}>;
+export type MembershipBundleFulfillmentMetadata = Readonly<{
+    occurrenceId: OccurrenceId;
+    ticketsCount: number;
+    attendeeEmail: string;
+    attendeeName: string;
+    membershipName: string;
+}>;
+export type MembershipOrderItemMetadata = CheckoutLineMetadata & Readonly<{
+    bundleFulfillment?: MembershipBundleFulfillmentMetadata;
+}>;
+export type OrderItemMetadataByKind = {
+    event_ticket: EventTicketOrderItemMetadata;
+    product: ProductOrderItemMetadata;
+    pass: PassOrderItemMetadata;
+    course_enrollment: CourseEnrollmentOrderItemMetadata;
+    appointment: AppointmentOrderItemMetadata;
+    membership: MembershipOrderItemMetadata;
+};
+export type OrderItemMetadata = OrderItemMetadataByKind[OrderItemKind];
+export declare function parseStripeBookingCommissionMetadata(raw: Record<string, unknown>): Result<StripeBookingCommissionOrderItemMetadata, string>;
+export declare function parseBookableOrderItemPricingMetadata(raw: Record<string, unknown>): Result<BookableOrderItemPricingMetadata, string>;
+export declare function parseOrderItemMetadata(kind: 'event_ticket', raw: unknown): Result<EventTicketOrderItemMetadata, string>;
+export declare function parseOrderItemMetadata(kind: 'product', raw: unknown): Result<ProductOrderItemMetadata, string>;
+export declare function parseOrderItemMetadata(kind: 'pass', raw: unknown): Result<PassOrderItemMetadata, string>;
+export declare function parseOrderItemMetadata(kind: 'course_enrollment', raw: unknown): Result<CourseEnrollmentOrderItemMetadata, string>;
+export declare function parseOrderItemMetadata(kind: 'appointment', raw: unknown): Result<AppointmentOrderItemMetadata, string>;
+export declare function parseOrderItemMetadata(kind: 'membership', raw: unknown): Result<MembershipOrderItemMetadata, string>;
+export {};

package/dist/_dts/commerce/src/purchase/orderItemSupport.d.ts

@@ -0,0 +1,14 @@
+import type { OrderItemPlanningRecord } from './orderPlanningTypes';
+import type { OrderPaymentMethod } from './orderTypes';
+export type ShopRefundableOrderItem<TItem extends OrderItemPlanningRecord = OrderItemPlanningRecord> = Extract<TItem, {
+    kind: 'product' | 'pass';
+}>;
+export declare function isShopRefundableOrderItem<TItem extends OrderItemPlanningRecord>(item: TItem): item is ShopRefundableOrderItem<TItem>;
+export declare function usesShopRefundFlow<TItem extends OrderItemPlanningRecord>(paymentMethod: OrderPaymentMethod, item: TItem): item is ShopRefundableOrderItem<TItem>;
+export declare function getOrderItemDisplayName(item: Pick<OrderItemPlanningRecord, 'kind' | 'metadata'>): string;
+export declare function effectiveOrderItemNetTotalCents(item: Pick<OrderItemPlanningRecord, 'netTotalCents' | 'totalCents'>): number;
+export declare function isOrderItemShippable(item: OrderItemPlanningRecord): boolean;
+export declare function partitionActiveUnshippedOrderItems<TItem extends OrderItemPlanningRecord>(items: readonly TItem[], shippedQuantityByItemId: ReadonlyMap<string, number>): Readonly<{
+    cancellableItems: readonly TItem[];
+    shippedItems: readonly TItem[];
+}>;

package/dist/_dts/commerce/src/purchase/orderListFilters.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeOrderListSearchTerm(value: string | null | undefined): string | null;
+export declare function buildOrderListDateFromBoundary(value: string | null | undefined): string | null;
+export declare function buildOrderListDateToBoundary(value: string | null | undefined): string | null;

package/dist/_dts/commerce/src/purchase/orderPaymentLinkPlanning.d.ts

@@ -0,0 +1,60 @@
+import type { BookingFlexibleBalanceContractStatus, NonNegativeCents, OrderFlexibleBalanceContractId, OrderInstalmentPlanStatus, OrderPaymentPlanId } from '../../../core/src/index';
+import type { Result } from '../../../core/src/index';
+import type { OrderHistorySource } from './orderHistorySource';
+import { type OrderPaymentPosition, type OrderPaymentPositionInconsistency } from './orderPaymentState';
+import type { CheckoutCommitState, OrderPaymentMethod, OrderStatus } from './orderTypes';
+export type OrderPaymentLinkUnavailableReason = 'archived_order' | 'order_not_pending' | 'order_not_committed' | 'no_balance_due' | 'payment_path_unavailable' | 'stripe_not_connected' | 'checkout_in_progress';
+export type OrderPaymentReminderUnavailableReason = OrderPaymentLinkUnavailableReason | 'missing_customer_email';
+export type OrderPaymentLinkAvailability = Readonly<{
+    kind: 'available';
+}> | Readonly<{
+    kind: 'unavailable';
+    reason: OrderPaymentLinkUnavailableReason;
+    publicMessage: string;
+    httpStatus: 409 | 422;
+}>;
+export type OrderPaymentReminderAvailability = Readonly<{
+    kind: 'available';
+    recipientEmail: string;
+}> | Readonly<{
+    kind: 'unavailable';
+    reason: OrderPaymentReminderUnavailableReason;
+    publicMessage: string;
+    httpStatus: 409 | 422;
+}>;
+export type OrderPaymentAdminFlexibleBalance = Readonly<{
+    contractId: OrderFlexibleBalanceContractId;
+    status: BookingFlexibleBalanceContractStatus;
+    remainingBalanceCents: NonNegativeCents;
+    dueAt?: string | null;
+    upfrontAmountCents?: NonNegativeCents | null;
+}>;
+export type OrderPaymentAdminInstalmentPlan = Readonly<{
+    paymentPlanId: OrderPaymentPlanId;
+    status: OrderInstalmentPlanStatus;
+    remainingBalanceCents: NonNegativeCents;
+    nextDueAt?: string | null;
+    nextDueAmountCents?: NonNegativeCents | null;
+}>;
+export type OrderPaymentAdminFacts = Readonly<{
+    historySource: OrderHistorySource;
+    status: OrderStatus;
+    commitState: CheckoutCommitState;
+    paymentMethod: OrderPaymentMethod;
+    grandTotalCents: NonNegativeCents;
+    paidCents: NonNegativeCents;
+    waivedCents: NonNegativeCents;
+    refundedCents: NonNegativeCents;
+    flexibleBalance: OrderPaymentAdminFlexibleBalance | null;
+    instalmentPlan: OrderPaymentAdminInstalmentPlan | null;
+    stripeCheckoutSessionId: string | null;
+    stripeConnected: boolean;
+    customerEmail: string | null;
+}>;
+export type OrderPaymentAdminProjection = Readonly<{
+    paymentState: OrderPaymentPosition;
+    balanceDueCents: NonNegativeCents;
+    paymentLinkAvailability: OrderPaymentLinkAvailability;
+    paymentReminderAvailability: OrderPaymentReminderAvailability;
+}>;
+export declare function buildOrderPaymentAdminProjection(facts: OrderPaymentAdminFacts): Result<OrderPaymentAdminProjection, OrderPaymentPositionInconsistency>;