@carlonicora/nextjs-jsonapi 5.5.0 → 5.7.0

package/src/features/billing/stripe-coupon/components/lists/CouponCodesList.tsx

@@ -0,0 +1,61 @@
+"use client";
+
+import { TicketIcon } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { ReactNode, useEffect } from "react";
+import { ContentListTable } from "../../../../../components";
+import { Modules } from "../../../../../core";
+import { DataListRetriever, useDataListRetriever } from "../../../../../hooks";
+import { EmptyState } from "../../../../../shadcnui";
+import { useCouponContext } from "../../../contexts/CouponContext";
+import { StripeCouponCodeFields } from "../../data/stripe-coupon-code.fields";
+import { StripeCouponCodeInterface } from "../../data/stripe-coupon-code.interface";
+import { StripeCouponCodeService } from "../../data/stripe-coupon-code.service";
+import CouponCodeEditor from "../forms/CouponCodeEditor";
+
+type CouponCodesListProps = {
+  couponId: string;
+};
+
+export function CouponCodesList({ couponId }: CouponCodesListProps) {
+  const t = useTranslations();
+  const { catalogueVersion } = useCouponContext();
+
+  const data: DataListRetriever<StripeCouponCodeInterface> = useDataListRetriever({
+    retriever: (params) => StripeCouponCodeService.listByCoupon({ ...params, couponId }),
+    retrieverParams: {},
+    module: Modules.StripeCouponCode,
+  });
+
+  // Switching "Apply automatically" on one code clears it on the others in the
+  // same server write, so every flag change re-reads the whole list.
+  useEffect(() => {
+    if (catalogueVersion > 0) void data.refresh();
+  }, [catalogueVersion]);
+
+  const functions: ReactNode[] = [<CouponCodeEditor key="create-code" couponId={couponId} />];
+
+  return (
+    <ContentListTable
+      data={data}
+      fields={[
+        StripeCouponCodeFields.code,
+        StripeCouponCodeFields.places,
+        StripeCouponCodeFields.expiresAt,
+        StripeCouponCodeFields.automatic,
+        StripeCouponCodeFields.status,
+        StripeCouponCodeFields.actions,
+      ]}
+      tableGeneratorType={Modules.StripeCouponCode}
+      functions={functions}
+      title={t("billing.admin.coupons.codes.title")}
+      emptyState={
+        <EmptyState
+          icon={TicketIcon}
+          title={t("billing.admin.coupons.codes.empty.title")}
+          description={t("billing.admin.coupons.codes.empty.description")}
+        />
+      }
+    />
+  );
+}

package/src/features/billing/stripe-coupon/components/lists/CouponsList.tsx

@@ -0,0 +1,67 @@
+"use client";
+
+import { TicketPercentIcon } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { ReactNode, useEffect } from "react";
+import { ContentListTable } from "../../../../../components";
+import { Modules } from "../../../../../core";
+import { DataListRetriever, useDataListRetriever } from "../../../../../hooks";
+import { EmptyState } from "../../../../../shadcnui";
+import { useCouponContext } from "../../../contexts/CouponContext";
+import { StripeCouponFields } from "../../data/stripe-coupon.fields";
+import { StripeCouponInterface } from "../../data/stripe-coupon.interface";
+import { StripeCouponService } from "../../data/stripe-coupon.service";
+import CouponEditor from "../forms/CouponEditor";
+
+type CouponsListProps = {
+  /**
+   * Pass this whenever the list is the page's own content inside a
+   * `RoundPageContainer fullWidth`. Without it ContentListTable wraps itself in
+   * `rounded-md border`, drawing a second bordered card inside the page's
+   * rounded shell.
+   */
+  fullWidth?: boolean;
+};
+
+export function CouponsList({ fullWidth }: CouponsListProps = {}) {
+  const t = useTranslations();
+  const { catalogueVersion } = useCouponContext();
+
+  const data: DataListRetriever<StripeCouponInterface> = useDataListRetriever({
+    retriever: (params) => StripeCouponService.listCoupons(params),
+    retrieverParams: {},
+    module: Modules.StripeCoupon,
+  });
+
+  // Renames and code changes happen on the detail page, so the list has to
+  // learn about them through the provider's counter rather than a direct callback.
+  useEffect(() => {
+    if (catalogueVersion > 0) void data.refresh();
+  }, [catalogueVersion]);
+
+  const functions: ReactNode[] = [<CouponEditor key="create-coupon" />];
+
+  return (
+    <ContentListTable
+      data={data}
+      fields={[
+        StripeCouponFields.name,
+        StripeCouponFields.discount,
+        StripeCouponFields.places,
+        StripeCouponFields.codes,
+        StripeCouponFields.status,
+      ]}
+      tableGeneratorType={Modules.StripeCoupon}
+      functions={functions}
+      fullWidth={fullWidth}
+      title={t("billing.admin.coupons.title")}
+      emptyState={
+        <EmptyState
+          icon={TicketPercentIcon}
+          title={t("billing.admin.coupons.empty.title")}
+          description={t("billing.admin.coupons.empty.description")}
+        />
+      }
+    />
+  );
+}

package/src/features/billing/stripe-coupon/components/lists/index.ts

@@ -0,0 +1,2 @@
+export * from "./CouponsList";
+export * from "./CouponCodesList";

package/src/features/billing/stripe-coupon/components/widgets/CouponCodeActions.tsx

@@ -0,0 +1,81 @@
+"use client";
+
+import { PowerIcon, RotateCcwIcon } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { useState } from "react";
+import { errorToast } from "../../../../../components/errors";
+import { Button, ConfirmDialog, FieldLabel, Switch } from "../../../../../shadcnui";
+import { useCouponContext } from "../../../contexts/CouponContext";
+import { StripeCouponCodeInterface } from "../../data/stripe-coupon-code.interface";
+import type { CouponCodeStatus } from "../../hooks/useStripeCouponCodeTableStructure";
+
+type CouponCodeActionsProps = {
+  code: StripeCouponCodeInterface;
+  status: CouponCodeStatus;
+};
+
+/**
+ * Row controls of a code: the "Apply automatically" switch and the deactivate /
+ * reactivate button. The button sits behind ConfirmDialog, which is controlled
+ * and trigger-less by design — the caller owns the trigger button, so none of
+ * Base UI's trigger-composition pitfalls apply (no asChild, no nested <button>).
+ */
+export function CouponCodeActions({ code, status }: CouponCodeActionsProps) {
+  const t = useTranslations();
+  const { updateCodeFlags } = useCouponContext();
+  const [open, setOpen] = useState<boolean>(false);
+  const [pending, setPending] = useState<boolean>(false);
+
+  // An expired or used-up code stays dead: Stripe never revives it.
+  const isDead = status === "expired" || status === "used_up";
+  const isInactive = !code.active;
+  const scope = isInactive ? "reactivate" : "deactivate";
+
+  return (
+    <div className="flex items-center justify-end gap-x-4">
+      {/* Typography role 9 (field label): FieldLabel wraps the switch, so a click on the text toggles it. */}
+      <FieldLabel>
+        <Switch
+          checked={code.automatic}
+          // Switching off is always allowed; switching on only for a live code.
+          disabled={pending || (!code.automatic && status !== "active")}
+          onCheckedChange={async (checked) => {
+            setPending(true);
+            try {
+              // The server clears the flag on every other code in the same
+              // write; the context's refreshCatalogue re-reads the list so the
+              // other row turns off too.
+              await updateCodeFlags({ id: code.id, automatic: checked });
+            } catch (error) {
+              errorToast({ title: t("billing.admin.coupons.fields.automatic"), error });
+            } finally {
+              setPending(false);
+            }
+          }}
+        />
+        {t("billing.admin.coupons.fields.automatic")}
+      </FieldLabel>
+      <Button variant="outline" size="sm" disabled={isDead} onClick={() => setOpen(true)}>
+        {isInactive ? <RotateCcwIcon /> : <PowerIcon />}
+        {t(`billing.admin.coupons.codes.${scope}.confirm`)}
+      </Button>
+      <ConfirmDialog
+        open={open}
+        onOpenChange={setOpen}
+        title={t(`billing.admin.coupons.codes.${scope}.title`)}
+        description={t(`billing.admin.coupons.codes.${scope}.description`, { code: code.code })}
+        confirmLabel={t(`billing.admin.coupons.codes.${scope}.confirm`)}
+        cancelLabel={t("ui.buttons.cancel")}
+        destructive={!isInactive}
+        onConfirm={async () => {
+          try {
+            await updateCodeFlags({ id: code.id, active: isInactive });
+          } catch (error) {
+            errorToast({ title: t(`billing.admin.coupons.codes.${scope}.title`), error });
+            throw error; // keeps the dialog open — ConfirmDialog swallows rejections
+          }
+        }}
+      />
+    </div>
+  );
+}

package/src/features/billing/stripe-coupon/components/widgets/index.ts

@@ -0,0 +1 @@
+export * from "./CouponCodeActions";

package/src/features/billing/stripe-coupon/data/__tests__/stripe-coupon-models.spec.ts

@@ -0,0 +1,114 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { DataClassRegistry } from "../../../../../core/registry/DataClassRegistry";
+import { ModuleRegistry } from "../../../../../core/registry/ModuleRegistry";
+import { ModuleFactory, ModuleWithPermissions } from "../../../../../permissions/types";
+import { StripeCouponCodeModule } from "../../stripe-coupon-code.module";
+import { StripeCouponModule } from "../../stripe-coupon.module";
+import { StripeCouponOfferModule } from "../../stripe-coupon-offer.module";
+import { StripeCoupon } from "../stripe-coupon";
+import { StripeCouponCode } from "../stripe-coupon-code";
+
+// createJsonApi reads Modules.X.name (resolved lazily via ModuleRegistry), and
+// _readIncluded rehydrates through the registered model, so the modules must be
+// registered first — mirrors email-automation-models.spec.
+const moduleFactory: ModuleFactory = (params) =>
+  ({
+    pageUrl: params.pageUrl,
+    name: params.name,
+    model: params.model,
+  }) as ModuleWithPermissions;
+
+beforeAll(() => {
+  const coupon = StripeCouponModule(moduleFactory);
+  const code = StripeCouponCodeModule(moduleFactory);
+  ModuleRegistry.register("StripeCoupon", coupon);
+  ModuleRegistry.register("StripeCouponCode", code);
+  ModuleRegistry.register("StripeCouponOffer", StripeCouponOfferModule(moduleFactory));
+  // The included code is rehydrated through the class registry (normally filled by bootstrap()).
+  DataClassRegistry.registerObjectClass(coupon, StripeCoupon);
+  DataClassRegistry.registerObjectClass(code, StripeCouponCode);
+});
+
+describe("stripe coupon models", () => {
+  it("rehydrates redeemBy into a Date and reads the included codes", () => {
+    const coupon = new StripeCoupon().rehydrate({
+      jsonApi: {
+        id: "co-1",
+        type: "stripe-coupons",
+        attributes: {
+          stripeCouponId: "co_1",
+          name: "Founding GM",
+          discountType: "percent_off",
+          percentOff: 20,
+          duration: "forever",
+          redeemBy: "2027-01-01T00:00:00.000Z",
+          maxRedemptions: 50,
+          timesRedeemed: 13,
+          valid: true,
+        },
+        relationships: { codes: { data: [{ type: "stripe-coupon-codes", id: "cc-1" }] } },
+      },
+      included: [
+        {
+          id: "cc-1",
+          type: "stripe-coupon-codes",
+          attributes: {
+            stripePromotionCodeId: "promo_1",
+            code: "FOUNDER",
+            active: true,
+            automatic: true,
+            expiresAt: "2027-02-01T00:00:00.000Z",
+            timesRedeemed: 13,
+          },
+        },
+      ],
+    } as any);
+
+    expect(coupon.redeemBy).toBeInstanceOf(Date);
+    expect(coupon.redeemBy?.toISOString()).toBe("2027-01-01T00:00:00.000Z");
+    expect(coupon.codes.length).toBe(1);
+    expect(coupon.codes[0].code).toBe("FOUNDER");
+    expect(coupon.codes[0].expiresAt).toBeInstanceOf(Date);
+    expect(coupon.timesRedeemed).toBe(13);
+  });
+
+  it("serialises the datetimes of the coupon and its first code as ISO strings", () => {
+    const body = new StripeCoupon().createJsonApi({
+      id: "co-1",
+      name: "Founding GM",
+      discountType: "percent_off",
+      percentOff: 20,
+      duration: "forever",
+      productIds: ["p1"],
+      redeemBy: new Date("2027-01-01T00:00:00.000Z"),
+      maxRedemptions: 50,
+      firstCode: { code: "FOUNDER", automatic: true, expiresAt: new Date("2027-02-01T00:00:00.000Z") },
+    });
+
+    expect(body.data.type).toBe("stripe-coupons");
+    expect(body.data.attributes.redeemBy).toBe("2027-01-01T00:00:00.000Z");
+    expect(body.data.attributes.firstCode.expiresAt).toBe("2027-02-01T00:00:00.000Z");
+    expect(body.data.attributes.firstCode.automatic).toBe(true);
+    expect(body.data.attributes.productIds).toEqual(["p1"]);
+    expect("amountOff" in body.data.attributes).toBe(false);
+  });
+
+  it("builds the rename body with the name only", () => {
+    expect(new StripeCoupon().createRenameJsonApi({ id: "co-1", name: "Renamed" })).toEqual({
+      data: { type: "stripe-coupons", id: "co-1", attributes: { name: "Renamed" } },
+    });
+  });
+
+  it("writes the code's coupon relationship", () => {
+    const body = new StripeCouponCode().createJsonApi({ id: "c1", couponId: "co-1", code: "SPRING" });
+    expect(body.data.type).toBe("stripe-coupon-codes");
+    expect(body.data.attributes).toEqual({ code: "SPRING" });
+    expect(body.data.relationships.coupon).toEqual({ data: { type: "stripe-coupons", id: "co-1" } });
+  });
+
+  it("builds the flags body with only the flags that are set", () => {
+    const body = new StripeCouponCode().createFlagsJsonApi({ id: "c1", automatic: true });
+    expect(body).toEqual({ data: { type: "stripe-coupon-codes", id: "c1", attributes: { automatic: true } } });
+    expect("active" in body.data.attributes).toBe(false);
+  });
+});

package/src/features/billing/stripe-coupon/data/index.ts

@@ -0,0 +1,10 @@
+export * from "./stripe-coupon";
+export * from "./stripe-coupon.fields";
+export * from "./stripe-coupon.interface";
+export * from "./stripe-coupon.service";
+export * from "./stripe-coupon-code";
+export * from "./stripe-coupon-code.fields";
+export * from "./stripe-coupon-code.interface";
+export * from "./stripe-coupon-code.service";
+export * from "./stripe-coupon-offer";
+export * from "./stripe-coupon-offer.interface";

package/src/features/billing/stripe-coupon/data/stripe-coupon-code.fields.ts

@@ -0,0 +1,8 @@
+export enum StripeCouponCodeFields {
+  code = "code",
+  places = "places",
+  expiresAt = "expiresAt",
+  automatic = "automatic",
+  status = "status",
+  actions = "actions",
+}

package/src/features/billing/stripe-coupon/data/stripe-coupon-code.interface.ts

@@ -0,0 +1,44 @@
+import { ApiDataInterface } from "../../../../core";
+import { StripeCouponInterface } from "./stripe-coupon.interface";
+
+// ============================================================================
+// Stripe Coupon Code Interfaces (a customer-facing promotion code of a coupon)
+// ============================================================================
+
+export interface StripeCouponCodeInterface extends ApiDataInterface {
+  get stripePromotionCodeId(): string;
+  get code(): string;
+  get active(): boolean;
+  get automatic(): boolean;
+  get firstTimeTransaction(): boolean;
+  get minimumAmount(): number | undefined; // minor units
+  get minimumAmountCurrency(): string | undefined;
+  get stripeCustomerId(): string | undefined;
+  get expiresAt(): Date | undefined;
+  get maxRedemptions(): number | undefined;
+  get timesRedeemed(): number;
+  get coupon(): StripeCouponInterface | undefined;
+}
+
+// ============================================================================
+// Stripe Coupon Code Input DTOs
+// ============================================================================
+
+export type StripeCouponCodeInput = {
+  id: string;
+  couponId: string;
+  code?: string;
+  firstTimeTransaction?: boolean;
+  minimumAmount?: number;
+  minimumAmountCurrency?: string;
+  stripeCustomerId?: string;
+  expiresAt?: Date;
+  maxRedemptions?: number;
+  automatic?: boolean;
+};
+
+export type StripeCouponCodeFlagsInput = {
+  id: string;
+  active?: boolean;
+  automatic?: boolean;
+};

package/src/features/billing/stripe-coupon/data/stripe-coupon-code.service.ts

@@ -0,0 +1,92 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../../core";
+import { STRIPE_COUPON_CODE_AUTOMATIC_SEGMENT } from "../stripe-coupon-code.module";
+import { StripeCouponCode } from "./stripe-coupon-code";
+import {
+  StripeCouponCodeFlagsInput,
+  StripeCouponCodeInput,
+  StripeCouponCodeInterface,
+} from "./stripe-coupon-code.interface";
+
+/**
+ * Billing service for the customer-facing codes of a coupon
+ */
+export class StripeCouponCodeService extends AbstractService {
+  /**
+   * List the codes of a coupon (admin)
+   */
+  static async listByCoupon(params: {
+    couponId: string;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<StripeCouponCodeInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeCoupon,
+      id: params.couponId,
+      childEndpoint: Modules.StripeCouponCode,
+    });
+
+    return this.callApi({
+      type: Modules.StripeCouponCode,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+      previous: params.prev,
+    });
+  }
+
+  /**
+   * Create a code on an existing coupon (admin)
+   */
+  static async createCode(params: StripeCouponCodeInput): Promise<StripeCouponCodeInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeCouponCode,
+    });
+
+    return this.callApi<StripeCouponCodeInterface>({
+      type: Modules.StripeCouponCode,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+      input: params,
+    });
+  }
+
+  /**
+   * Switch "Apply automatically" and / or deactivate / reactivate a code (admin)
+   */
+  static async updateFlags(params: StripeCouponCodeFlagsInput): Promise<StripeCouponCodeInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeCouponCode,
+      id: params.id,
+    });
+
+    return this.callApi<StripeCouponCodeInterface>({
+      type: Modules.StripeCouponCode,
+      method: HttpMethod.PATCH,
+      endpoint: endpoint.generate(),
+      input: new StripeCouponCode().createFlagsJsonApi(params),
+      overridesJsonApiCreation: true,
+    });
+  }
+
+  /**
+   * The code the server would apply automatically for this price at a first
+   * payment, or null when none applies (logged-in company administrator)
+   */
+  static async findAutomatic(params: { priceId: string }): Promise<StripeCouponCodeInterface | null> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeCouponCode,
+      id: STRIPE_COUPON_CODE_AUTOMATIC_SEGMENT,
+    });
+    endpoint.addAdditionalParam("priceId", params.priceId);
+
+    const codes = await this.callApi<StripeCouponCodeInterface[]>({
+      type: Modules.StripeCouponCode,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      // A failed lookup must reach the wizard, which then refuses to show full price as the truth
+      suppressGlobalError: true,
+    });
+
+    return codes?.[0] ?? null;
+  }
+}

package/src/features/billing/stripe-coupon/data/stripe-coupon-code.ts

@@ -0,0 +1,132 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../../core";
+import {
+  StripeCouponCodeFlagsInput,
+  StripeCouponCodeInput,
+  StripeCouponCodeInterface,
+} from "./stripe-coupon-code.interface";
+import { StripeCouponInterface } from "./stripe-coupon.interface";
+import { StripeCoupon } from "./stripe-coupon";
+
+export class StripeCouponCode extends AbstractApiData implements StripeCouponCodeInterface {
+  private _stripePromotionCodeId?: string;
+  private _code: string = "";
+  private _active: boolean = true;
+  private _automatic: boolean = false;
+  private _firstTimeTransaction: boolean = false;
+  private _minimumAmount?: number;
+  private _minimumAmountCurrency?: string;
+  private _stripeCustomerId?: string;
+  private _expiresAt?: Date;
+  private _maxRedemptions?: number;
+  private _timesRedeemed: number = 0;
+  private _coupon?: StripeCouponInterface;
+
+  get stripePromotionCodeId(): string {
+    if (!this._stripePromotionCodeId) throw new Error("stripePromotionCodeId is not defined");
+    return this._stripePromotionCodeId;
+  }
+
+  get code(): string {
+    return this._code;
+  }
+
+  get active(): boolean {
+    return this._active;
+  }
+
+  get automatic(): boolean {
+    return this._automatic;
+  }
+
+  get firstTimeTransaction(): boolean {
+    return this._firstTimeTransaction;
+  }
+
+  get minimumAmount(): number | undefined {
+    return this._minimumAmount;
+  }
+
+  get minimumAmountCurrency(): string | undefined {
+    return this._minimumAmountCurrency;
+  }
+
+  get stripeCustomerId(): string | undefined {
+    return this._stripeCustomerId;
+  }
+
+  get expiresAt(): Date | undefined {
+    return this._expiresAt;
+  }
+
+  get maxRedemptions(): number | undefined {
+    return this._maxRedemptions;
+  }
+
+  get timesRedeemed(): number {
+    return this._timesRedeemed;
+  }
+
+  get coupon(): StripeCouponInterface | undefined {
+    return this._coupon;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attributes = data.jsonApi.attributes;
+
+    this._stripePromotionCodeId = attributes.stripePromotionCodeId;
+    this._code = attributes.code ?? "";
+    this._active = attributes.active ?? true;
+    this._automatic = attributes.automatic ?? false;
+    this._firstTimeTransaction = attributes.firstTimeTransaction ?? false;
+    this._minimumAmount = attributes.minimumAmount ?? undefined;
+    this._minimumAmountCurrency = attributes.minimumAmountCurrency ?? undefined;
+    this._stripeCustomerId = attributes.stripeCustomerId ?? undefined;
+    this._expiresAt = attributes.expiresAt ? new Date(attributes.expiresAt) : undefined;
+    this._maxRedemptions = attributes.maxRedemptions ?? undefined;
+    this._timesRedeemed = attributes.timesRedeemed ?? 0;
+
+    this._coupon = this._readIncluded(data, "coupon", Modules.StripeCoupon) as StripeCouponInterface | undefined;
+
+    return this;
+  }
+
+  createJsonApi(data: StripeCouponCodeInput): any {
+    const { id, couponId, ...code } = data;
+
+    return {
+      data: {
+        type: Modules.StripeCouponCode.name,
+        id,
+        attributes: StripeCoupon.codeAttributes(code),
+        relationships: {
+          coupon: {
+            data: {
+              type: Modules.StripeCoupon.name,
+              id: couponId,
+            },
+          },
+        },
+      },
+    };
+  }
+
+  /**
+   * PATCH body for the flags a code can still change after creation.
+   * Only the flags that are set are sent, so switching one never touches the other.
+   */
+  createFlagsJsonApi(data: StripeCouponCodeFlagsInput): any {
+    const attributes: Record<string, boolean> = {};
+    if (data.active !== undefined) attributes.active = data.active;
+    if (data.automatic !== undefined) attributes.automatic = data.automatic;
+
+    return {
+      data: {
+        type: Modules.StripeCouponCode.name,
+        id: data.id,
+        attributes,
+      },
+    };
+  }
+}

package/src/features/billing/stripe-coupon/data/stripe-coupon-offer.interface.ts

@@ -0,0 +1,17 @@
+import { ApiDataInterface } from "../../../../core";
+import { StripeCouponDiscountType, StripeCouponDurationType } from "./stripe-coupon.interface";
+
+// ============================================================================
+// Stripe Coupon Offer Interface (public, synthetic: the automatic code's places left)
+// ============================================================================
+
+export interface StripeCouponOfferInterface extends ApiDataInterface {
+  get discountType(): StripeCouponDiscountType;
+  get percentOff(): number | undefined;
+  get amountOff(): number | undefined; // minor units
+  get currency(): string | undefined;
+  get duration(): StripeCouponDurationType;
+  get durationInMonths(): number | undefined;
+  get placesLeft(): number;
+  get placesTotal(): number;
+}