@nextblock-cms/ecom 0.0.10 → 0.8.1

package/lib/CurrencyProvider.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+import { CurrencyRecord } from './currency';
+interface CurrencyContextValue {
+    currencies: CurrencyRecord[];
+    defaultCurrency: CurrencyRecord;
+    activeCurrency: CurrencyRecord;
+    activeCurrencyCode: string;
+    isHydrated: boolean;
+    setActiveCurrencyCode: (currencyCode: string) => void;
+}
+export declare function CurrencyProvider({ children, initialCurrencies, initialCurrencyCode, locale, }: {
+    children: ReactNode;
+    initialCurrencies: CurrencyRecord[];
+    initialCurrencyCode?: string | null;
+    locale?: string | null;
+}): import("react").JSX.Element;
+export declare function useCurrency(): CurrencyContextValue;
+export {};

package/lib/cart-store.d.ts

@@ -0,0 +1,47 @@
+import { CartItem } from './types';
+import { useCurrency } from './CurrencyProvider';
+import { AppliedCouponState } from './coupons';
+export interface AddItemResult {
+    success: boolean;
+    error?: string;
+}
+interface CartState {
+    items: CartItem[];
+    appliedCoupon: AppliedCouponState | null;
+    isOpen: boolean;
+    addItem: (item: Omit<CartItem, 'quantity'> & {
+        quantity?: number;
+    }) => AddItemResult;
+    removeItem: (itemId: string) => void;
+    updateQuantity: (itemId: string, quantity: number) => void;
+    setAppliedCoupon: (coupon: AppliedCouponState | null) => void;
+    removeCoupon: () => void;
+    clearCart: () => void;
+    toggleCart: () => void;
+    setIsOpen: (isOpen: boolean) => void;
+    setItems: (items: CartItem[]) => void;
+}
+export declare const useCartStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CartState>, "setState" | "persist"> & {
+    setState(partial: CartState | Partial<CartState> | ((state: CartState) => CartState | Partial<CartState>), replace?: false | undefined): unknown;
+    setState(state: CartState | ((state: CartState) => CartState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CartState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CartState) => void) => () => void;
+        onFinishHydration: (fn: (state: CartState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<CartState, unknown, unknown>>;
+    };
+}>;
+export declare const useCartTotalItems: () => number;
+export declare function getCartItemActivePrice(item: CartItem, params: {
+    currencyCode: string;
+    currencies: ReturnType<typeof useCurrency>['currencies'];
+}): {
+    currencyCode: any;
+    price: any;
+    sale_price: any;
+};
+export declare const useCartSubtotal: () => number;
+export {};

package/lib/components/AccountNavigationMenu.d.ts

@@ -0,0 +1,14 @@
+export type AccountNavigationIcon = 'orders' | 'password';
+export interface AccountNavigationLink {
+    href: string;
+    labelKey: string;
+    fallbackLabel: string;
+    icon?: AccountNavigationIcon;
+}
+interface AccountNavigationMenuProps {
+    links: AccountNavigationLink[];
+    title?: string;
+    className?: string;
+}
+export declare function AccountNavigationMenu({ links, title, className, }: AccountNavigationMenuProps): import("react").JSX.Element | null;
+export {};

package/lib/components/AddToCartButton.d.ts

@@ -0,0 +1,8 @@
+import { Product } from '../types';
+interface AddToCartButtonProps {
+    product: Product;
+    className?: string;
+    quantity?: number;
+}
+export declare const AddToCartButton: ({ product, className, quantity }: AddToCartButtonProps) => import("react").JSX.Element;
+export {};

package/lib/components/Cart.d.ts

@@ -0,0 +1 @@
+export declare const Cart: () => import("react").JSX.Element | null;

package/lib/components/CartDrawer.d.ts

@@ -0,0 +1 @@
+export declare const CartDrawer: () => import("react").JSX.Element | null;

package/lib/components/CartIcon.d.ts

@@ -0,0 +1 @@
+export declare const CartIcon: () => import("react").JSX.Element;

package/lib/components/Checkout.d.ts

@@ -0,0 +1,6 @@
+import { CheckoutCustomerDefaults } from '../customer';
+interface CheckoutProps {
+    initialCustomer?: CheckoutCustomerDefaults;
+}
+export declare const Checkout: ({ initialCustomer }: CheckoutProps) => import("react").JSX.Element | null;
+export {};

package/lib/components/CouponForm.d.ts

@@ -0,0 +1,8 @@
+import { CouponQuote } from '../coupons';
+import { CartItem } from '../types';
+export declare function CouponForm({ items, currencyCode, onQuoteChange, compact, }: {
+    items: CartItem[];
+    currencyCode: string;
+    onQuoteChange?: (quote: CouponQuote | null) => void;
+    compact?: boolean;
+}): import("react").JSX.Element | null;

package/lib/components/CurrencySwitcher.d.ts

@@ -0,0 +1 @@
+export declare function CurrencySwitcher(): import("react").JSX.Element | null;

package/lib/components/CustomerProfileForm.d.ts

@@ -0,0 +1,21 @@
+import { default as React } from 'react';
+import { AccountNavigationLink } from './AccountNavigationMenu';
+import { ProfileUpdateData } from '../server-actions/customer-actions';
+import { Database } from '../../../../db/src/index.ts';
+type UserRole = Database['public']['Enums']['user_role'];
+export interface ExtendedProfileUpdateData extends ProfileUpdateData {
+    role?: UserRole;
+}
+interface CustomerProfileFormProps {
+    initialData?: ExtendedProfileUpdateData;
+    MediaPickerComponent?: React.ComponentType<any>;
+    isAdmin?: boolean;
+    email?: string;
+    accountLinks?: AccountNavigationLink[];
+    onAction?: (data: ExtendedProfileUpdateData) => Promise<{
+        error?: string;
+    } | void>;
+    initialSuccessMessage?: string | null;
+}
+export declare function CustomerProfileForm({ initialData, MediaPickerComponent, isAdmin, email, accountLinks, onAction, initialSuccessMessage, }: CustomerProfileFormProps): React.JSX.Element;
+export {};

package/lib/components/FeaturedProduct.d.ts

@@ -0,0 +1,8 @@
+import { Product } from '../types';
+interface FeaturedProductProps {
+    product: Product;
+    className?: string;
+    imagePosition?: 'left' | 'right';
+}
+export declare const FeaturedProduct: ({ product, className, imagePosition }: FeaturedProductProps) => import("react").JSX.Element;
+export {};

package/lib/components/InvoiceDocument.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { InvoicePresentationData } from '../invoice';
+export interface InvoiceDocumentLabels {
+    invoice: string;
+    invoiceNumber: string;
+    orderNumber: string;
+    paidOn: string;
+    status: string;
+    from: string;
+    billTo: string;
+    shipTo: string;
+    item: string;
+    details: string;
+    quantity: string;
+    price: string;
+    amount: string;
+    subtotal: string;
+    discount: string;
+    shipping: string;
+    tax: string;
+    total: string;
+    taxBreakdown: string;
+    taxRegistrations: string;
+}
+interface InvoiceDocumentProps {
+    data: InvoicePresentationData;
+    labels: InvoiceDocumentLabels;
+    locale?: string;
+    className?: string;
+}
+export declare function InvoiceDocument({ data, labels, locale, className, }: InvoiceDocumentProps): React.JSX.Element;
+export {};

package/lib/components/InvoiceViewerShell.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { InvoiceDocumentLabels } from './InvoiceDocument';
+import { InvoicePresentationData } from '../invoice';
+interface InvoiceViewerAction {
+    href: string;
+    label: string;
+    variant?: 'default' | 'outline';
+}
+interface InvoiceViewerShellProps {
+    invoice?: InvoicePresentationData | null;
+    labels: InvoiceDocumentLabels;
+    locale: string;
+    title: string;
+    description?: string;
+    printLabel: string;
+    headerVisual?: ReactNode;
+    action?: InvoiceViewerAction;
+    loading?: boolean;
+    loadingMessage?: string;
+    error?: string | null;
+    emptyMessage?: string;
+    className?: string;
+    showHeader?: boolean;
+}
+export declare function InvoiceViewerShell({ invoice, labels, locale, title, description, printLabel, headerVisual, action, loading, loadingMessage, error, emptyMessage, className, showHeader, }: InvoiceViewerShellProps): import("react").JSX.Element;
+export {};

package/lib/components/ProductCard.d.ts

@@ -0,0 +1,7 @@
+import { Product } from '../types';
+interface ProductCardProps {
+    product: Product;
+    className?: string;
+}
+export declare const ProductCard: ({ product, className }: ProductCardProps) => import("react").JSX.Element;
+export {};

package/lib/components/ProductDetailsLayout.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface ProductDetailsLayoutProps {
+    visualEditingEnabled?: boolean;
+    descriptionNode?: React.ReactNode;
+}
+export declare const ProductDetailsLayout: React.FC<ProductDetailsLayoutProps>;
+export {};

package/lib/components/ProductGallery.d.ts

@@ -0,0 +1,9 @@
+interface ProductGalleryProps {
+    images?: {
+        url: string;
+        alt?: string;
+    }[];
+    className?: string;
+}
+export declare const ProductGallery: ({ images, className }: ProductGalleryProps) => import("react").JSX.Element;
+export {};

package/lib/components/ProductGrid.d.ts

@@ -0,0 +1,8 @@
+import { Product } from '../types';
+interface ProductGridProps {
+    products: Product[];
+    columns?: 2 | 3 | 4;
+    className?: string;
+}
+export declare const ProductGrid: ({ products, columns, className }: ProductGridProps) => import("react").JSX.Element;
+export {};

package/lib/components/ShippingEstimator.d.ts

@@ -0,0 +1,5 @@
+interface ShippingEstimatorProps {
+    physicalSubtotal: number;
+}
+export declare const ShippingEstimator: ({ physicalSubtotal }: ShippingEstimatorProps) => import("react").JSX.Element;
+export {};

package/lib/components/SimpleTiptapRenderer.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface SimpleTiptapRendererProps {
+    content: unknown;
+    className?: string;
+}
+export declare const SimpleTiptapRenderer: React.FC<SimpleTiptapRendererProps>;
+export {};

package/lib/components/SubscriptionSelector.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { Product } from '../types';
+interface SubscriptionSelectorProps {
+    product: Product;
+}
+export declare const SubscriptionSelector: ({ product }: SubscriptionSelectorProps) => React.JSX.Element;
+export {};

package/lib/components/media/MediaImage.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface MediaImageProps {
+    src: string;
+    alt: string;
+    width?: number | null;
+    height?: number | null;
+    blurDataURL?: string | null;
+    className?: string;
+    priority?: boolean;
+}
+declare const MediaImage: React.FC<MediaImageProps>;
+export default MediaImage;

package/lib/components/media/MediaPickerDialog.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+import { Database } from '../../../../../db/src/index.ts';
+type Media = Database["public"]["Tables"]["media"]["Row"];
+interface MediaPickerDialogProps {
+    triggerLabel?: string;
+    triggerVariant?: "default" | "outline" | "secondary" | "destructive" | "ghost";
+    onSelect?: (media: Media) => void;
+    accept?: (m: Media) => boolean;
+    title?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    hideTrigger?: boolean;
+    defaultFolder?: string;
+}
+export default function MediaPickerDialog({ triggerLabel, triggerVariant, onSelect, accept, title, open, onOpenChange, hideTrigger, defaultFolder, }: MediaPickerDialogProps): React.JSX.Element;
+export {};

package/lib/components/media/MediaUploadForm.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { Database } from '../../../../../db/src/index.ts';
+type Media = Database['public']['Tables']['media']['Row'];
+interface MediaUploadFormProps {
+    onUploadSuccess?: (newMedia: Media) => void;
+    returnJustData?: boolean;
+    defaultFolder?: string;
+}
+export default function MediaUploadForm({ onUploadSuccess, returnJustData, defaultFolder }: MediaUploadFormProps): React.JSX.Element;
+export {};

package/lib/components/media/UploadFolderContext.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+type UploadFolderContextValue = {
+    defaultFolder?: string | null;
+};
+export declare function UploadFolderProvider({ defaultFolder, children }: {
+    defaultFolder?: string;
+    children: React.ReactNode;
+}): React.JSX.Element;
+export declare function useUploadFolder(): UploadFolderContextValue;
+export {};

package/lib/countries.d.ts

@@ -0,0 +1,5 @@
+export declare const countries: {
+    code: string;
+    name: string;
+}[];
+export declare function normalizeCountryCode(value?: string | null): string | null;

package/lib/coupon-server.d.ts

@@ -0,0 +1,22 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { CouponQuote, CouponQuoteResult } from './coupons';
+import { CartItem, EcommercePaymentProvider } from './types';
+type SupabaseLikeClient = SupabaseClient<any>;
+export declare function getCouponQuote(input: {
+    client: SupabaseLikeClient;
+    code?: string | null;
+    items: CartItem[];
+    currencyCode?: string | null;
+}): Promise<CouponQuoteResult>;
+export declare function getQuoteLineDiscountMap(quote?: CouponQuote | null): Map<string, number>;
+export declare function recordCouponRedemption(input: {
+    client: SupabaseLikeClient;
+    quote: CouponQuote;
+    orderId: string;
+    provider: EcommercePaymentProvider;
+    discountTotal: number;
+    userId?: string | null;
+    customerEmail?: string | null;
+    metadata?: Record<string, unknown>;
+}): Promise<void>;
+export {};

package/lib/coupon-server.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/coupons.d.ts

@@ -0,0 +1,41 @@
+import { CartItem, EcommercePaymentProvider } from './types';
+export type CouponProviderScope = 'all' | EcommercePaymentProvider;
+export type CouponDiscountType = 'percent' | 'fixed';
+export type CouponSyncStatus = 'not_synced' | 'pending' | 'synced' | 'failed' | 'deleted' | 'not_required';
+export interface AppliedCouponState {
+    code: string;
+    couponId?: string | null;
+}
+export interface CouponLineQuote {
+    key: string;
+    product_id: string;
+    variant_id?: string | null;
+    provider: EcommercePaymentProvider;
+    title: string;
+    quantity: number;
+    subtotal: number;
+    discount: number;
+}
+export interface CouponQuote {
+    couponId: string;
+    code: string;
+    name: string;
+    discountType: CouponDiscountType;
+    discountAmount: number;
+    providerScope: CouponProviderScope;
+    eligibleSubtotal: number;
+    discountTotal: number;
+    providerDiscounts: Record<EcommercePaymentProvider, number>;
+    lineDiscounts: CouponLineQuote[];
+}
+export type CouponQuoteResult = {
+    success: true;
+    quote: CouponQuote;
+} | {
+    success: false;
+    error: string;
+    errorKey?: string;
+};
+export declare function normalizeCouponCode(code?: string | null): string;
+export declare function getCartLineCouponKey(item: Pick<CartItem, 'product_id' | 'variant_id'>): string;
+export declare function emptyProviderDiscounts(): Record<EcommercePaymentProvider, number>;

package/lib/currency-constants.d.ts

@@ -0,0 +1 @@
+export declare const CURRENCY_COOKIE_NAME = "NEXTBLOCK_CURRENCY";

package/lib/currency-rest-client.d.ts

@@ -0,0 +1 @@
+export declare function fetchActiveCurrenciesFromRest(): Promise<Array<Record<string, unknown>>>;

package/lib/currency-sale-schedule.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/currency-store.d.ts

@@ -0,0 +1,20 @@
+interface CurrencyPreferenceState {
+    activeCurrencyCode: string | null;
+    hasHydrated: boolean;
+    setActiveCurrencyCode: (currencyCode: string) => void;
+    setHasHydrated: (hasHydrated: boolean) => void;
+}
+export declare const useCurrencyPreferenceStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<CurrencyPreferenceState>, "setState" | "persist"> & {
+    setState(partial: CurrencyPreferenceState | Partial<CurrencyPreferenceState> | ((state: CurrencyPreferenceState) => CurrencyPreferenceState | Partial<CurrencyPreferenceState>), replace?: false | undefined): unknown;
+    setState(state: CurrencyPreferenceState | ((state: CurrencyPreferenceState) => CurrencyPreferenceState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<CurrencyPreferenceState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CurrencyPreferenceState) => void) => () => void;
+        onFinishHydration: (fn: (state: CurrencyPreferenceState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<CurrencyPreferenceState, unknown, unknown>>;
+    };
+}>;
+export {};

package/lib/currency-sync.d.ts

@@ -0,0 +1,19 @@
+export declare function rebaseStoreCurrencyExchangeRates(params: {
+    newDefaultCurrencyCode: string;
+    previousBaseRate: number;
+}): Promise<{
+    rebasedAt: string;
+    newDefaultCurrencyCode: any;
+    updatedCurrencies: string[];
+}>;
+export declare function syncStoreCurrencyRates(): Promise<{
+    baseCurrencyCode: any;
+    fetchedAt: string;
+    provider: string;
+    providerUrl: string;
+    skippedCurrencies: string[];
+    updatedCurrencies: string[];
+}>;
+export declare function clearAutoSyncedCurrencyPriceOverrides(currencyCode: string): Promise<{
+    currencyCode: any;
+}>;

package/lib/currency.d.ts

@@ -0,0 +1,116 @@
+export declare const CURRENCY_ROUNDING_MODES: readonly ["none", "nearest", "up", "down", "charm"];
+export type CurrencyRoundingMode = (typeof CURRENCY_ROUNDING_MODES)[number];
+export interface CurrencyRecord {
+    code: string;
+    symbol: string;
+    exchange_rate: number;
+    is_default: boolean;
+    is_active: boolean;
+    auto_sync_product_prices?: boolean | null;
+    rounding_mode?: CurrencyRoundingMode | null;
+    rounding_increment?: number | null;
+    rounding_charm_amount?: number | null;
+    auto_update_exchange_rate?: boolean | null;
+    exchange_rate_source?: string | null;
+    exchange_rate_updated_at?: string | null;
+}
+export type PriceMap = Record<string, number>;
+export type SalePriceMap = Record<string, number | null>;
+export declare function normalizeCurrencyRoundingMode(value: unknown): CurrencyRoundingMode;
+export declare function normalizeCurrencyRecord(value: Partial<CurrencyRecord> | Record<string, unknown> | null | undefined): CurrencyRecord;
+export declare function normalizePriceMap(value: unknown): PriceMap;
+export declare function normalizeSalePriceMap(value: unknown): SalePriceMap;
+export declare function getDefaultCurrency(currencies: CurrencyRecord[]): CurrencyRecord;
+export declare function getCurrencyLookup(currencies: CurrencyRecord[]): Record<string, CurrencyRecord>;
+export declare function getExchangeRateForCurrency(currencies: CurrencyRecord[], currencyCode?: string | null): number;
+export declare function convertMinorUnitAmount(params: {
+    amount: number;
+    fromCurrencyCode?: string | null;
+    toCurrencyCode?: string | null;
+    currencies: CurrencyRecord[];
+    applyRounding?: boolean;
+}): any;
+export declare function applyCurrencyRounding(params: {
+    amount: number;
+    currencyCode?: string | null;
+    currencies: CurrencyRecord[];
+}): number;
+export declare function describeCurrencyRoundingRule(currency: CurrencyRecord): string;
+export declare function resolvePriceForCurrency(params: {
+    prices?: PriceMap | null;
+    salePrices?: SalePriceMap | null;
+    fallbackPrice?: number | null;
+    fallbackSalePrice?: number | null;
+    currencyCode?: string | null;
+    currencies: CurrencyRecord[];
+}): {
+    currencyCode: any;
+    price: any;
+    sale_price: any;
+};
+/**
+ * Returns whether a scheduled sale window is active at `now` (defaults to the
+ * current instant). A null bound means "open ended"; both bounds null means the
+ * sale is always-on (preserves the behaviour of pre-schedule static sales).
+ * Window is [start, end): inclusive start, exclusive end. All comparisons are
+ * absolute instants, so this is timezone-safe.
+ */
+export declare function isSaleWindowActive(params: {
+    saleStartAt?: string | null;
+    saleEndAt?: string | null;
+    now?: Date;
+}): boolean;
+/**
+ * Returns whether a pending regular-price change has reached its effective time.
+ */
+export declare function isScheduledPriceDue(params: {
+    scheduledPriceAt?: string | null;
+    now?: Date;
+}): boolean;
+/**
+ * Window-aware wrapper around {@link resolvePriceForCurrency}. Resolves the
+ * effective regular/sale price for a product or variant at `now`:
+ *   - a due scheduled regular-price change replaces the regular price inputs;
+ *   - the sale price only applies while its window is active.
+ * The existing `sale_price <= regularPrice` guard is preserved by delegating to
+ * `resolvePriceForCurrency`, so an out-of-window or invalid sale returns null.
+ */
+export declare function resolveEffectivePriceForCurrency(params: {
+    prices?: PriceMap | null;
+    salePrices?: SalePriceMap | null;
+    fallbackPrice?: number | null;
+    fallbackSalePrice?: number | null;
+    saleStartAt?: string | null;
+    saleEndAt?: string | null;
+    scheduledPrice?: number | null;
+    scheduledPrices?: PriceMap | null;
+    scheduledPriceAt?: string | null;
+    currencyCode?: string | null;
+    currencies: CurrencyRecord[];
+    now?: Date;
+}): {
+    currencyCode: any;
+    price: any;
+    sale_price: any;
+};
+export declare function resolvePriceRangeForCurrency(params: {
+    entries: Array<{
+        price: number;
+        prices?: PriceMap | null;
+        sale_price?: number | null;
+        sale_prices?: SalePriceMap | null;
+        sale_start_at?: string | null;
+        sale_end_at?: string | null;
+        scheduled_price?: number | null;
+        scheduled_prices?: PriceMap | null;
+        scheduled_price_at?: string | null;
+    }>;
+    currencyCode?: string | null;
+    currencies: CurrencyRecord[];
+    now?: Date;
+}): {
+    min: number;
+    max: number;
+} | null;
+export declare function inferCurrencyCodeFromLocale(locale: string | null | undefined, currencies: CurrencyRecord[]): string;
+export declare function sortCurrencies(currencies: CurrencyRecord[]): CurrencyRecord[];

package/lib/customer-addresses.d.ts

@@ -0,0 +1,19 @@
+import { CustomerAddressInput } from './customer';
+type SupabaseLikeClient = any;
+export declare function getDefaultUserAddresses(userId: string, client?: SupabaseLikeClient): Promise<{
+    billingAddress: CustomerAddressInput | null;
+    shippingAddress: CustomerAddressInput | null;
+}>;
+export declare function upsertDefaultUserAddresses(input: {
+    userId: string;
+    billingAddress?: CustomerAddressInput | null;
+    shippingAddress?: CustomerAddressInput | null;
+    client?: SupabaseLikeClient;
+}): Promise<void>;
+export declare function fillMissingUserProfileCheckoutDetails(input: {
+    userId: string;
+    fullName?: string | null;
+    phone?: string | null;
+    client?: SupabaseLikeClient;
+}): Promise<void>;
+export {};

package/lib/customer-orders.d.ts

@@ -0,0 +1,23 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+import { InvoicePresentationData } from './invoice';
+type SupabaseLikeClient = SupabaseClient<any>;
+export interface CustomerOrderSummary {
+    id: string;
+    invoice_number: string | null;
+    paid_at: string | null;
+    created_at: string | null;
+    currency: string | null;
+    status: string;
+    provider: string | null;
+    subtotal: number | null;
+    shipping_total: number | null;
+    tax_total: number | null;
+    total: number;
+}
+export declare function getCurrentCustomerOrders(client?: SupabaseLikeClient): Promise<CustomerOrderSummary[]>;
+export declare function getCurrentCustomerOrder(orderId: string, client?: SupabaseLikeClient): Promise<CustomerOrderSummary | null>;
+export declare function getCurrentCustomerOrderInvoice(orderId: string, client?: SupabaseLikeClient): Promise<{
+    order: CustomerOrderSummary;
+    invoice: InvoicePresentationData | null;
+} | null>;
+export {};