@cartbase/storefront 0.1.0

package/src/api/content.ts

@@ -0,0 +1,125 @@
+/**
+ * @cartbase/storefront/api/content — pages + blogs (content-pages-blog card).
+ *
+ * Ground truth: src/app/api/store/pages/[handle]/route.ts,
+ * src/app/api/store/blogs/[handle]/posts{,/[postHandle]}/route.ts,
+ * src/lib/content/article-shape.ts.
+ *
+ * Shapes are Shopify Storefront `Page` / `Article` verbatim so storefront
+ * code ports 1:1. PUBLISHED only — drafts and deleted rows 404 (lib filter
+ * AND anon RLS). Stored HTML is server-sanitized on write — safe to render
+ * raw (`dangerouslySetInnerHTML`).
+ *
+ * Path convention (src/lib/content/paths.ts, shared with menus/redirects):
+ * `/pages/<handle>`, `/blogs/<handle>`, `/blogs/<blog>/<post>`.
+ */
+
+import type { StorefrontClient } from "./http"
+import type { IsoDateString, PaginationQuery } from "./types"
+
+/** Shopify Storefront `Page`, verbatim. */
+export interface Page {
+  /** `cpage_<hex>` */
+  id: string
+  handle: string
+  title: string
+  /** Sanitized HTML — safe to render raw. */
+  body: string
+  /** Stripped text, ~160-char word-boundary truncation. */
+  bodySummary: string
+  /** Fallbacks applied server-side: title / bodySummary. */
+  seo: { title: string; description: string }
+  publishedAt: IsoDateString
+  createdAt: IsoDateString
+  updatedAt: IsoDateString
+}
+
+export interface PageResponse {
+  page: Page
+}
+
+/**
+ * GET /api/store/pages/:handle — one published page.
+ *
+ * Auth: anon (x-client-id).
+ * Errors: 404 not_found (unknown handle, draft, or deleted).
+ * Settings: policy pages (privacy-policy, terms-of-service, refund-policy,
+ * shipping-policy) are seeded as DRAFTS — they 404 until published.
+ */
+export async function getPage(
+  client: StorefrontClient,
+  handle: string
+): Promise<PageResponse> {
+  return client.get(`/api/store/pages/${encodeURIComponent(handle)}`)
+}
+
+/** Shopify Storefront `Article`, verbatim. */
+export interface Article {
+  /** `bpost_<hex>` */
+  id: string
+  handle: string
+  title: string
+  /** Sanitized HTML — safe to render raw. */
+  contentHtml: string
+  /** Plain-text version of contentHtml. */
+  content: string
+  /** Author-provided; falls back to truncated content. */
+  excerpt: string
+  /** null when the post has no hero image. altText is always null today. */
+  image: { url: string; altText: null } | null
+  tags: string[]
+  /** null when the post has no author name set. */
+  author: { name: string } | null
+  publishedAt: IsoDateString
+  /** Fallbacks applied server-side: title / excerpt. */
+  seo: { title: string; description: string }
+  blog: { handle: string; title: string }
+}
+
+export interface ArticleResponse {
+  article: Article
+}
+
+export type ListBlogPostsQuery = PaginationQuery
+
+export interface BlogPostListResponse {
+  blog: { handle: string; title: string }
+  articles: Article[]
+  count: number
+  offset: number
+  limit: number
+}
+
+/**
+ * GET /api/store/blogs/:handle/posts — published posts of one blog,
+ * `published_at` desc. `limit` ≤ 100 (default 20), `offset` ≥ 0.
+ *
+ * Auth: anon (x-client-id).
+ * Errors: 404 not_found (unknown blog handle) · 400 validation_failed
+ * (limit/offset out of range).
+ */
+export async function listBlogPosts(
+  client: StorefrontClient,
+  blogHandle: string,
+  query?: ListBlogPostsQuery
+): Promise<BlogPostListResponse> {
+  return client.get(`/api/store/blogs/${encodeURIComponent(blogHandle)}/posts`, {
+    query: { ...query },
+  })
+}
+
+/**
+ * GET /api/store/blogs/:handle/posts/:postHandle — one published article.
+ *
+ * Auth: anon (x-client-id).
+ * Errors: 404 not_found (unknown blog OR unknown/draft post).
+ */
+export async function getBlogPost(
+  client: StorefrontClient,
+  blogHandle: string,
+  postHandle: string
+): Promise<ArticleResponse> {
+  return client.get(
+    `/api/store/blogs/${encodeURIComponent(blogHandle)}/posts/${encodeURIComponent(postHandle)}`
+  )
+}

package/src/api/customers.ts

@@ -0,0 +1,307 @@
+/**
+ * @cartbase/storefront/api/customers — customer profile, addresses, documents.
+ *
+ * Ground truth: src/app/api/store/customers/** + src/app/api/_lib/customer.ts.
+ *
+ * Auth model: every endpoint here except none is CUSTOMER-authenticated —
+ * `authorization: Bearer <supabase jwt>` (minted by the passwordless code
+ * flow in ./auth or a client-side supabase password sign-in) PLUS the anon
+ * `x-client-id` tenant header the client always sends. Missing/invalid JWT →
+ * `401 unauthenticated`.
+ *
+ * Lazy registration: `/customers/me` resolves the customer row by
+ * (client_id, JWT email) and CREATES it on first authenticated call
+ * (has_account=true, account_status per the store's approval policy) — a
+ * fresh login never 404s on "me".
+ */
+
+import type { StorefrontClient } from "./http"
+import type { IsoDateString, PaginationQuery } from "./types"
+
+/** One row of `customer.addresses` (barter_commerce.customer_addresses). */
+export interface CustomerAddress {
+  id: string
+  client_id: string
+  customer_id: string
+  address_name: string | null
+  first_name: string | null
+  last_name: string | null
+  company: string | null
+  address_1: string | null
+  address_2: string | null
+  city: string | null
+  country_code: string | null
+  province: string | null
+  postal_code: string | null
+  phone: string | null
+  is_default_billing: boolean
+  is_default_shipping: boolean
+  metadata: Record<string, unknown> | null
+  created_at: IsoDateString
+  updated_at: IsoDateString
+  deleted_at: IsoDateString | null
+}
+
+/**
+ * The customer payload (full barter_commerce.customers row + addresses).
+ * `account_status` (`pending` | `approved`) gates B2B storefront content
+ * when the store's approval policy is on (b2b-v1). `tags` are admin-only
+ * labels — readable here, never writable from the store surface.
+ */
+export interface StoreCustomer {
+  id: string
+  client_id: string
+  email: string | null
+  first_name: string | null
+  last_name: string | null
+  phone: string | null
+  company_name: string | null
+  /** Bulgarian company id (ЕИК) — feeds invoice-required checkout. */
+  company_eik: string | null
+  vat_number: string | null
+  has_account: boolean
+  /** `pending` | `approved` — store approval policy (customer-accounts card). */
+  account_status: string
+  tags: string[]
+  metadata: Record<string, unknown> | null
+  created_by: string | null
+  created_at: IsoDateString
+  updated_at: IsoDateString
+  deleted_at: IsoDateString | null
+  addresses: CustomerAddress[]
+}
+
+export interface CustomerResponse {
+  customer: StoreCustomer
+}
+
+export interface CreateCustomerInput {
+  /** Must equal the session JWT's email — mismatch → 403 email_mismatch. */
+  email: string
+  first_name?: string
+  last_name?: string
+  phone?: string
+  company_name?: string
+}
+
+/**
+ * POST /api/store/customers — guest-to-registered conversion (password
+ * sign-up flow): call `supabase.auth.signUp({email, password})` client-side
+ * first, then this with the same email. Upserts the (client_id, email)
+ * customer row with has_account=true. NOT needed for the passwordless code
+ * flow — verify already lazy-creates the customer.
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 403 email_mismatch (body email ≠ JWT email)
+ * · 400 validation_failed.
+ * Settings: store approval policy decides account_status of a NEW row.
+ */
+export async function createCustomer(
+  client: StorefrontClient,
+  input: CreateCustomerInput
+): Promise<CustomerResponse> {
+  return client.post("/api/store/customers", input)
+}
+
+/**
+ * GET /api/store/customers/me — the signed-in customer, addresses embedded.
+ * Lazy-creates the customer row on first call for this (tenant, email).
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 400 missing_client_id.
+ */
+export async function getMe(client: StorefrontClient): Promise<CustomerResponse> {
+  return client.get("/api/store/customers/me")
+}
+
+export interface UpdateCustomerInput {
+  first_name?: string | null
+  last_name?: string | null
+  phone?: string | null
+  company_name?: string | null
+  /** ЕИК / VAT (customer-master-data) — loose format, never shape-blocked. */
+  company_eik?: string | null
+  vat_number?: string | null
+  metadata?: Record<string, unknown>
+  // NOTE: `tags` deliberately absent — admin-only; the server strips them.
+}
+
+/**
+ * POST /api/store/customers/me — update own profile. Unknown keys (incl.
+ * `tags`) are stripped server-side; returns the refreshed customer.
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 400 validation_failed.
+ */
+export async function updateMe(
+  client: StorefrontClient,
+  input: UpdateCustomerInput
+): Promise<CustomerResponse> {
+  return client.post("/api/store/customers/me", input)
+}
+
+export interface AddressListResponse {
+  addresses: CustomerAddress[]
+  /** Not truly paginated: offset is always 0 and limit === count. */
+  count: number
+  offset: number
+  limit: number
+}
+
+/**
+ * GET /api/store/customers/me/addresses — all of the customer's addresses
+ * (created_at asc). The list envelope is nominal — the route returns EVERY
+ * address (offset 0, limit = count); no query params are read.
+ *
+ * Auth: Bearer JWT (+ x-client-id). Errors: 401 unauthenticated.
+ */
+export async function listAddresses(
+  client: StorefrontClient
+): Promise<AddressListResponse> {
+  return client.get("/api/store/customers/me/addresses")
+}
+
+export interface CreateAddressInput {
+  address_name?: string
+  first_name?: string
+  last_name?: string
+  company?: string
+  address_1?: string
+  address_2?: string
+  city?: string
+  /** Lower-cased server-side. */
+  country_code?: string
+  province?: string
+  postal_code?: string
+  phone?: string
+  /** true clears the flag on every sibling first (one default per kind). */
+  is_default_billing?: boolean
+  is_default_shipping?: boolean
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * POST /api/store/customers/me/addresses — create an address. Returns the
+ * FULL refreshed customer (`{customer}`, addresses embedded) — not the
+ * created address alone; find it in `customer.addresses`.
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 400 validation_failed.
+ */
+export async function createAddress(
+  client: StorefrontClient,
+  input: CreateAddressInput
+): Promise<CustomerResponse> {
+  return client.post("/api/store/customers/me/addresses", input)
+}
+
+export interface AddressResponse {
+  address: CustomerAddress
+}
+
+/**
+ * GET /api/store/customers/me/addresses/:id — one owned address.
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 404 not_found (unknown OR another
+ * customer's address — ownership 404s, it never 403s).
+ */
+export async function getAddress(
+  client: StorefrontClient,
+  addressId: string
+): Promise<AddressResponse> {
+  return client.get(`/api/store/customers/me/addresses/${encodeURIComponent(addressId)}`)
+}
+
+export interface UpdateAddressInput {
+  address_name?: string | null
+  first_name?: string | null
+  last_name?: string | null
+  company?: string | null
+  address_1?: string | null
+  address_2?: string | null
+  city?: string | null
+  country_code?: string | null
+  province?: string | null
+  postal_code?: string | null
+  phone?: string | null
+  is_default_billing?: boolean
+  is_default_shipping?: boolean
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * POST /api/store/customers/me/addresses/:id — partial update; default
+ * flags clear siblings. Returns the FULL refreshed customer.
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 404 not_found · 400 validation_failed.
+ */
+export async function updateAddress(
+  client: StorefrontClient,
+  addressId: string,
+  input: UpdateAddressInput
+): Promise<CustomerResponse> {
+  return client.post(
+    `/api/store/customers/me/addresses/${encodeURIComponent(addressId)}`,
+    input
+  )
+}
+
+/**
+ * DELETE /api/store/customers/me/addresses/:id — soft-delete an owned
+ * address. Returns the FULL refreshed customer (the address gone from
+ * `customer.addresses`).
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 404 not_found.
+ */
+export async function deleteAddress(
+  client: StorefrontClient,
+  addressId: string
+): Promise<CustomerResponse> {
+  return client.delete(
+    `/api/store/customers/me/addresses/${encodeURIComponent(addressId)}`
+  )
+}
+
+/** One issued (non-void) order document — the account "Invoices" row. */
+export interface CustomerDocument {
+  id: string
+  order_id: string
+  order_display_id: number | null
+  doc_type: string
+  number: string
+  issued_at: IsoDateString
+  pdf_url: string | null
+  due_date: IsoDateString | null
+  paid_at: IsoDateString | null
+}
+
+export interface ListDocumentsQuery extends PaginationQuery {
+  /** Filter by document type (e.g. `invoice`). */
+  doc_type?: string
+}
+
+export interface DocumentListResponse {
+  documents: CustomerDocument[]
+  count: number
+  offset: number
+  limit: number
+}
+
+/**
+ * GET /api/store/customers/me/documents — the customer's issued order
+ * documents, newest first (issued_at desc). Voided documents excluded.
+ * Ownership is INNER-join enforced (session customer id AND client_id) —
+ * cross-customer reads are impossible. `limit` ≤ 200, default 20.
+ *
+ * Auth: Bearer JWT (+ x-client-id).
+ * Errors: 401 unauthenticated · 400 validation_failed.
+ */
+export async function listMyDocuments(
+  client: StorefrontClient,
+  query?: ListDocumentsQuery
+): Promise<DocumentListResponse> {
+  return client.get("/api/store/customers/me/documents", { query: { ...query } })
+}

package/src/api/gift-cards.ts

@@ -0,0 +1,112 @@
+/**
+ * @cartbase/storefront/api/gift-cards — gift-card TENDER on carts.
+ *
+ * Redemption is a payment tender (`pp_giftcard`), never a discount: cart
+ * totals/VAT compute first and NEVER move; applied cards cover part (or all)
+ * of `cart.total` and the remainder provider (Stripe/COD/manual) charges
+ * only what is left. The cart decoration fields (`gift_cards[]`,
+ * `gift_card_total`, `gift_card_remainder` — declared on the `Cart` DTO in
+ * `./carts`) are derived from the LIVE transactions ledger at every read.
+ *
+ * Route ground truth: src/app/api/store/carts/[id]/gift-cards/route.ts +
+ * src/lib/gift-cards/{redeem,tender}.ts. Doc: docs/storefront/gift-cards.md.
+ *
+ * Security model baked into the contract:
+ *  - failure is ONE generic answer — unknown, disabled, expired, depleted
+ *    and foreign-tenant codes are all `400 invalid_gift_card` (no
+ *    code-existence oracle);
+ *  - attempts are recorded BEFORE lookup and rate-limited per cart
+ *    (10 / 15 min) AND per IP (30 / 15 min) → `429 rate_limited`;
+ *  - the confirmation is MASKED (`last4` only) — the code is never echoed.
+ */
+import type { StorefrontClient } from "./http"
+import type { MajorUnitAmount } from "./types"
+import type { Cart } from "./carts"
+
+// ---------------------------------------------------------------------------
+// DTOs
+// ---------------------------------------------------------------------------
+
+/** Body of POST /api/store/carts/:id/gift-cards (`.strict()`). */
+export interface ApplyGiftCardInput {
+  /** The plaintext code (4–64 chars). Hashed at rest server-side. */
+  code: string
+}
+
+/** Body of DELETE /api/store/carts/:id/gift-cards (`.strict()`). */
+export interface RemoveGiftCardInput {
+  /** The applied card's id (from `cart.gift_cards[].id` or the apply response). */
+  gift_card_id: string
+}
+
+/** Masked apply confirmation. */
+export interface AppliedGiftCardConfirmation {
+  id: string
+  /** Last 4 characters of the code — the full code is never echoed. */
+  last4: string
+  /**
+   * How much of the cart total THIS card covers right now
+   * (`min(live balance, remaining total)` in apply order).
+   */
+  amount_applied: MajorUnitAmount
+}
+
+export interface ApplyGiftCardResponse {
+  /** Decorated cart — `gift_cards[]` / `gift_card_total` / `gift_card_remainder` updated; `total` untouched. */
+  cart: Cart
+  gift_card: AppliedGiftCardConfirmation
+}
+
+export interface RemoveGiftCardResponse {
+  cart: Cart
+}
+
+// ---------------------------------------------------------------------------
+// Functions
+// ---------------------------------------------------------------------------
+
+/**
+ * Apply a gift-card code to an open cart (idempotent re-apply). → 200
+ * `{cart, gift_card}` with a MASKED confirmation.
+ *
+ * Auth: anon `x-client-id`.
+ * Errors: 400 `invalid_gift_card` (the deliberate generic answer for
+ * unknown/disabled/expired/depleted/foreign-tenant codes), 429
+ * `rate_limited` (per-cart and per-IP attempt windows — a valid code inside
+ * a burned window is refused the same way), 404 `cart_not_found`, 409
+ * `cart_completed`, 400 `validation_failed`.
+ *
+ * Behavior: also syncs the internal `pp_giftcard` payment session to the
+ * covered amount when a payment collection exists (no-op before one does —
+ * creating the collection composes it). Actual balance redemption happens
+ * ONLY at cart complete, atomically; a card drained elsewhere in the
+ * meantime shrinks this cart's tender at the next read instead of
+ * over-redeeming.
+ * Settings: gift cards are issued/disabled from the admin; expiry and
+ * balance live on the card's ledger.
+ */
+export async function applyGiftCard(
+  client: StorefrontClient,
+  cartId: string,
+  input: ApplyGiftCardInput
+): Promise<ApplyGiftCardResponse> {
+  return client.post(`/api/store/carts/${cartId}/gift-cards`, input)
+}
+
+/**
+ * Remove an applied gift card from an open cart (idempotent). → 200 `{cart}`.
+ *
+ * Auth: anon `x-client-id`.
+ * Errors: 404 `cart_not_found`, 409 `cart_completed`, 400
+ * `validation_failed`.
+ * Behavior: re-syncs the `pp_giftcard` session to the remaining tender
+ * (removing the last card zeroes it), so the remainder provider's session
+ * re-inflates to the full total on the next amount sync.
+ */
+export async function removeGiftCard(
+  client: StorefrontClient,
+  cartId: string,
+  input: RemoveGiftCardInput
+): Promise<RemoveGiftCardResponse> {
+  return client.delete(`/api/store/carts/${cartId}/gift-cards`, input)
+}

package/src/api/http.ts

@@ -0,0 +1,122 @@
+/**
+ * @cartbase/storefront — the ONE http seam.
+ *
+ * Every SDK function in this package is a thin typed wrapper over
+ * `storeFetch()` from a `StorefrontClient`. Auth model (store-api.md):
+ *
+ *  - `x-client-id`      — required for anon reads (RLS scope)
+ *  - `x-publishable-api-key` — optional; scopes catalog/carts to the key's
+ *                              sales channels when set
+ *  - `authorization: Bearer <jwt>` — customer session (passwordless code
+ *                              flow or supabase password login)
+ *  - `x-locale`         — optional storefront locale hint
+ *
+ * The client is isomorphic (browser + RSC/server actions) — it holds no
+ * global state; construct once per request scope on the server, once per
+ * app on the client.
+ */
+
+import { StoreApiError } from "./types"
+
+export interface StorefrontClientConfig {
+  /** Deployment origin, e.g. `https://admin.mindpages.bg` */
+  baseUrl: string
+  /** Tenant id — required for anon reads. */
+  clientId: string
+  /** Publishable API key (channel scope). Optional for single-channel stores. */
+  publishableKey?: string
+  /** Called per request; return the customer JWT or null for guests. */
+  getAuthToken?: () => string | null | Promise<string | null>
+  /** Called per request; return the active locale code or null. */
+  getLocale?: () => string | null | Promise<string | null>
+  /** Override fetch (tests, custom caching). Defaults to global fetch. */
+  fetch?: typeof fetch
+}
+
+export type QueryValue = string | number | boolean | null | undefined
+export type Query = Record<string, QueryValue | QueryValue[]>
+
+export interface RequestOptions {
+  method?: "GET" | "POST" | "DELETE"
+  query?: Query
+  body?: unknown
+  headers?: Record<string, string>
+  /** Passed through to fetch — lets Next.js RSC callers tag cache behavior. */
+  cache?: RequestCache
+  next?: { revalidate?: number | false; tags?: string[] }
+  signal?: AbortSignal
+}
+
+export class StorefrontClient {
+  constructor(private readonly config: StorefrontClientConfig) {
+    if (!config.baseUrl) throw new Error("StorefrontClient: baseUrl is required")
+    if (!config.clientId) throw new Error("StorefrontClient: clientId is required")
+  }
+
+  /** The low-level typed request. Domain modules call this — apps rarely should. */
+  async request<T>(path: string, opts: RequestOptions = {}): Promise<T> {
+    const url = new URL(
+      path.replace(/^\//, ""),
+      this.config.baseUrl.replace(/\/?$/, "/")
+    )
+    if (opts.query) {
+      for (const [key, value] of Object.entries(opts.query)) {
+        if (value === undefined || value === null) continue
+        if (Array.isArray(value)) {
+          const joined = value.filter((v) => v !== undefined && v !== null).join(",")
+          if (joined) url.searchParams.set(key, joined)
+        } else {
+          url.searchParams.set(key, String(value))
+        }
+      }
+    }
+
+    const headers: Record<string, string> = {
+      "x-client-id": this.config.clientId,
+      ...(this.config.publishableKey
+        ? { "x-publishable-api-key": this.config.publishableKey }
+        : {}),
+      ...(opts.body !== undefined ? { "content-type": "application/json" } : {}),
+      ...(opts.headers ?? {}),
+    }
+    const token = this.config.getAuthToken ? await this.config.getAuthToken() : null
+    if (token && !headers.authorization) headers.authorization = `Bearer ${token}`
+    const locale = this.config.getLocale ? await this.config.getLocale() : null
+    if (locale && !headers["x-locale"]) headers["x-locale"] = locale
+
+    const doFetch = this.config.fetch ?? fetch
+    const res = await doFetch(url.toString(), {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+      cache: opts.cache,
+      ...(opts.next ? { next: opts.next } : {}),
+      signal: opts.signal,
+    } as RequestInit)
+
+    if (!res.ok) {
+      let detail: unknown
+      const text = await res.text()
+      try {
+        detail = JSON.parse(text)
+      } catch {
+        detail = text
+      }
+      throw new StoreApiError(res.status, detail)
+    }
+    if (res.status === 204) return undefined as T
+    return (await res.json()) as T
+  }
+
+  get<T>(path: string, opts: Omit<RequestOptions, "method" | "body"> = {}): Promise<T> {
+    return this.request<T>(path, { ...opts, method: "GET" })
+  }
+
+  post<T>(path: string, body?: unknown, opts: Omit<RequestOptions, "method" | "body"> = {}): Promise<T> {
+    return this.request<T>(path, { ...opts, method: "POST", body })
+  }
+
+  delete<T>(path: string, body?: unknown, opts: Omit<RequestOptions, "method" | "body"> = {}): Promise<T> {
+    return this.request<T>(path, { ...opts, method: "DELETE", body })
+  }
+}

package/src/api/index.ts

@@ -0,0 +1,29 @@
+/**
+ * @cartbase/storefront/api — barrel.
+ *
+ * PRE-DECLARED SEAM: every domain module line below is written up front so
+ * fleet agents create their module file WITHOUT editing this barrel (no
+ * union-merge seams). Do not reorder; append new domains at the end.
+ */
+
+export * from "./types"
+export * from "./http"
+
+export * as products from "./products"
+export * as collections from "./collections"
+export * as categories from "./categories"
+export * as regions from "./regions"
+export * as carts from "./carts"
+export * as giftCards from "./gift-cards"
+export * as checkout from "./checkout"
+export * as orders from "./orders"
+export * as customers from "./customers"
+export * as auth from "./auth"
+export * as content from "./content"
+export * as menus from "./menus"
+export * as metaobjects from "./metaobjects"
+export * as reviews from "./reviews"
+export * as search from "./search"
+export * as integrations from "./integrations"
+export * as consent from "./consent"
+export * as redirects from "./redirects"