@kasuvia/sdk 0.0.8 → 0.0.9

package/README.md

@@ -10,49 +10,76 @@ pnpm install @kasuvia/sdk
 
 ## Usage
 
-### Initialize SDK
+The SDK is stateless — there is no `initSdk()` call. Every service function takes a
+`SdkConfig` object as its first argument, and every hook accepts an optional `SdkConfig`
+argument (falling back to React Context if you wrap your tree in `<SdkProvider>`).
+
+### Configuration
 
 ```ts
-import { initSdk, configureHttpClients } from '@kasuvia/sdk'
+import type { SdkConfig } from '@kasuvia/sdk'
 
-initSdk({
+const config: SdkConfig = {
   businessId: 'B-123ABC',
   storefrontApiKey: 'your-api-key',
-  environment: 'production' // or 'development' for local development
-})
-
-// Configure HTTP clients after initialization
-configureHttpClients()
+  backendUrls: {
+    auth: 'https://api.kasuvia.com/auth',
+    store: 'https://api.kasuvia.com/store',
+    payment: 'https://api.kasuvia.com/payment',
+    notifications: 'https://api.kasuvia.com/notifications',
+    cms: 'https://api.kasuvia.com/cms',
+  },
+}
 ```
 
+`backendUrls` should only be resolved on the server (or in a Next.js API route) — never
+shipped to the browser directly.
+
 ### Use React Hooks
 
+Wrap your tree once so hooks don't need explicit config on every call:
+
+```tsx
+import { SdkProvider } from '@kasuvia/sdk/hooks'
+
+function RootLayout({ children }) {
+  return (
+    <SdkProvider config={config} accessToken={accessToken}>
+      {children}
+    </SdkProvider>
+  )
+}
+```
+
 ```ts
-import { useCart, useOrders, useAuth } from '@kasuvia/sdk'
+import { useCart, useOrders, useLogin } from '@kasuvia/sdk/hooks'
 
 function Cart() {
-  const { cart, addToCart, isLoading } = useCart()
+  const { cart, items, count, isLoading, addItem } = useCart() // custom return shape, not raw React Query `data`
   // ...
 }
 
 function Orders() {
-  const { orders } = useOrders()
+  const { data: orders } = useOrders()
   // ...
 }
 
 function Auth() {
-  const { login } = useLogin()
+  const { mutate: login } = useLogin() // standard React Query useMutation result
   // ...
 }
 ```
 
+Hooks also accept an explicit `config`/`accessToken` if you're not using `<SdkProvider>`
+— check each hook's signature in `src/hooks/`, as parameter order varies per hook.
+
 ### Use Services Directly
 
 ```ts
-import { getCart, addToCart } from '@kasuvia/sdk'
+import { getCart, addToCart } from '@kasuvia/sdk/services'
 
-const cart = await getCart()
-const updated = await addToCart({ product_id: '123', quantity: 1 })
+const cart = await getCart(config, accessToken)
+const updated = await addToCart(config, accessToken, { product_id: '123', quantity: 1, /* ...see full item shape in src/services/cart.service.ts */ })
 ```
 
 ## Features

package/dist/AddressAutocomplete-CjcqPElD.d.mts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { S as SdkConfig } from './index-NkI10J_E.mjs';
+
+interface AddressSuggestion {
+    place_id?: string | number;
+    display_name: string;
+    line1: string;
+    city?: string;
+    state?: string;
+    postal_code?: string;
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+}
+interface AddressAutocompleteProps {
+    /** The street-address line 1 text. */
+    value: string;
+    /** Fires on every keystroke - the field stays fully editable. */
+    onChange: (line1: string) => void;
+    /** Fires once when a suggestion is picked, with structured components. */
+    onResolve?: (suggestion: AddressSuggestion) => void;
+    /** ISO-2 country code to bias results toward (e.g. "NG"). */
+    country?: string;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+    config?: SdkConfig;
+}
+/**
+ * REAL BUG FIXED (2026-09-22): this called a hardcoded third-party endpoint
+ * (`nominatim.openstreetmap.org`) directly from the browser — a completely
+ * different data source than the rest of this platform's address/logistics
+ * system, which already has a real, working backend endpoint for exactly
+ * this (`GET /logistics/address/autocomplete`, `autocompleteAddress` in
+ * logistics.service.ts, live-verified this session). Calling Nominatim
+ * directly is also a real operational risk: OpenStreetMap's usage policy
+ * rate-limits and blocks unauthenticated browser traffic at production
+ * volume, and it has no idea this business is in Nigeria the way the real
+ * backend's geocoding provider is tuned to be. Rebuilt to call the real
+ * backend through the SDK's own service function instead.
+ */
+declare function AddressAutocomplete({ value, onChange, onResolve, country, disabled, placeholder, className, id, config, ...rest }: AddressAutocompleteProps): React.JSX.Element;
+
+export { AddressAutocomplete as A, type AddressAutocompleteProps as a, type AddressSuggestion as b };

package/dist/AddressAutocomplete-CvJHuRkf.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { S as SdkConfig } from './index-NkI10J_E.js';
+
+interface AddressSuggestion {
+    place_id?: string | number;
+    display_name: string;
+    line1: string;
+    city?: string;
+    state?: string;
+    postal_code?: string;
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+}
+interface AddressAutocompleteProps {
+    /** The street-address line 1 text. */
+    value: string;
+    /** Fires on every keystroke - the field stays fully editable. */
+    onChange: (line1: string) => void;
+    /** Fires once when a suggestion is picked, with structured components. */
+    onResolve?: (suggestion: AddressSuggestion) => void;
+    /** ISO-2 country code to bias results toward (e.g. "NG"). */
+    country?: string;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+    config?: SdkConfig;
+}
+/**
+ * REAL BUG FIXED (2026-09-22): this called a hardcoded third-party endpoint
+ * (`nominatim.openstreetmap.org`) directly from the browser — a completely
+ * different data source than the rest of this platform's address/logistics
+ * system, which already has a real, working backend endpoint for exactly
+ * this (`GET /logistics/address/autocomplete`, `autocompleteAddress` in
+ * logistics.service.ts, live-verified this session). Calling Nominatim
+ * directly is also a real operational risk: OpenStreetMap's usage policy
+ * rate-limits and blocks unauthenticated browser traffic at production
+ * volume, and it has no idea this business is in Nigeria the way the real
+ * backend's geocoding provider is tuned to be. Rebuilt to call the real
+ * backend through the SDK's own service function instead.
+ */
+declare function AddressAutocomplete({ value, onChange, onResolve, country, disabled, placeholder, className, id, config, ...rest }: AddressAutocompleteProps): React.JSX.Element;
+
+export { AddressAutocomplete as A, type AddressAutocompleteProps as a, type AddressSuggestion as b };

package/dist/components/index.d.mts

@@ -0,0 +1,497 @@
+import * as React from 'react';
+import React__default, { ReactNode, CSSProperties } from 'react';
+import { a as CartItem$1, P as Product, L as ListParams, O as Order } from '../index-CNW_LINy.mjs';
+export { A as AddressAutocomplete, a as AddressAutocompleteProps, b as AddressSuggestion } from '../AddressAutocomplete-CjcqPElD.mjs';
+import { LucideProps } from 'lucide-react';
+import { HTMLMotionProps } from 'framer-motion';
+import '../index-NkI10J_E.mjs';
+
+interface TableSkeletonProps {
+    rows?: number;
+    columns?: number;
+    className?: string;
+    rowClassName?: string;
+}
+declare function TableSkeleton({ rows, columns, className, rowClassName }: TableSkeletonProps): React__default.JSX.Element;
+
+interface CardSkeletonProps {
+    count?: number;
+    containerClassName?: string;
+    cardClassName?: string;
+}
+declare function CardSkeleton({ count, containerClassName, cardClassName }: CardSkeletonProps): React__default.JSX.Element;
+
+interface CartItemSkeletonProps {
+    count?: number;
+    className?: string;
+}
+declare function CartItemSkeleton({ count, className }: CartItemSkeletonProps): React__default.JSX.Element;
+
+interface OrderItemSkeletonProps {
+    count?: number;
+    className?: string;
+}
+declare function OrderItemSkeleton({ count, className }: OrderItemSkeletonProps): React__default.JSX.Element;
+
+interface ProductCardSkeletonProps {
+    className?: string;
+    imageClassName?: string;
+}
+declare function ProductCardSkeleton({ className, imageClassName, }: ProductCardSkeletonProps): React__default.JSX.Element;
+
+interface CartItemProps {
+    item: CartItem$1;
+    onUpdateQty: (itemId: string, qty: number) => void;
+    onRemove: (itemId: string) => void;
+    formatPriceFn?: (price: number) => string;
+    className?: string;
+    imageClassName?: string;
+    titleClassName?: string;
+    priceClassName?: string;
+    quantityGroupClassName?: string;
+    buttonClassName?: string;
+    removeButtonClassName?: string;
+}
+declare function CartItem({ item, onUpdateQty, onRemove, formatPriceFn, className, imageClassName, titleClassName, priceClassName, quantityGroupClassName, buttonClassName, removeButtonClassName, }: CartItemProps): React__default.JSX.Element;
+
+interface CartSidebarProps {
+    onCheckout?: () => void;
+    onClose?: () => void;
+    formatPriceFn?: (price: number) => string;
+    className?: string;
+    headerClassName?: string;
+    titleClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+    checkoutButtonClassName?: string;
+}
+declare function CartSidebar({ onCheckout, onClose, formatPriceFn, className, headerClassName, titleClassName, bodyClassName, footerClassName, checkoutButtonClassName, }: CartSidebarProps): React__default.JSX.Element;
+
+interface CartTypeMismatchBannerProps {
+    mismatch: {
+        message: string;
+        existing_type: string;
+        new_type: string;
+    };
+    onClearAndAdd: () => void;
+    onKeepCurrent: () => void;
+    className?: string;
+    titleClassName?: string;
+    messageClassName?: string;
+    buttonGroupClassName?: string;
+    confirmButtonClassName?: string;
+    cancelButtonClassName?: string;
+}
+declare function CartTypeMismatchBanner({ mismatch, onClearAndAdd, onKeepCurrent, className, titleClassName, messageClassName, buttonGroupClassName, confirmButtonClassName, cancelButtonClassName, }: CartTypeMismatchBannerProps): React__default.JSX.Element;
+
+interface ProductCardProps {
+    product: Product;
+    onSelectProduct?: (product: Product) => void;
+    onWishlistToggle?: (product: Product, e: React__default.MouseEvent) => void;
+    isWishlistSaved?: boolean;
+    showWishlistButton?: boolean;
+    priority?: boolean;
+    className?: string;
+    /** Sizing/aspect-ratio classes for the image's container (e.g. "aspect-square").
+     * Kept separate from `imageClassName` because SmartImage renders the image
+     * in `fill` mode — sizing has to live on the container, not the <img>. */
+    imageContainerClassName?: string;
+    imageClassName?: string;
+    titleClassName?: string;
+    priceClassName?: string;
+    buttonClassName?: string;
+    enableImageCarousel?: boolean;
+    showCarouselDots?: boolean;
+    showCarouselArrows?: boolean;
+    activeDotClassName?: string;
+    dotClassName?: string;
+    formatPriceFn?: (price: number) => string;
+    /** Rendered top-left over the image. Falls back to a plain product-type
+     * badge when omitted — pass your own (e.g. New/Popular/On Sale badges) to
+     * replace it entirely. */
+    badgeSlot?: React__default.ReactNode;
+    /**
+     * Built-in star-rating row (product.average_rating / rating_count — real
+     * platform fields, synced from kasuvia-crm's review pipeline). On by
+     * default when a product actually has a rating; a storefront with no use
+     * for it, or that wants to build its own, can pass `showRating={false}`.
+     */
+    showRating?: boolean;
+    ratingClassName?: string;
+    /**
+     * Generic composable slot rendered between the price row and the CTA
+     * button — for "and many more" (stock urgency, shipping badges, a custom
+     * promo line, anything else a specific storefront wants) without forking
+     * this component. Renders nothing by default.
+     */
+    footerSlot?: React__default.ReactNode;
+}
+declare function ProductCard({ product, onSelectProduct, onWishlistToggle, isWishlistSaved, showWishlistButton, priority, className, imageContainerClassName, imageClassName, titleClassName, priceClassName, buttonClassName, enableImageCarousel, showCarouselDots, showCarouselArrows, activeDotClassName, dotClassName, formatPriceFn, badgeSlot, showRating, ratingClassName, footerSlot, }: ProductCardProps): React__default.JSX.Element;
+
+interface ProductGridProps {
+    params?: ListParams;
+    onSelectProduct?: (product: Product) => void;
+    onWishlistToggle?: (product: Product, e: React__default.MouseEvent) => void;
+    isWishlistSavedFn?: (product: Product) => boolean;
+    showWishlistButton?: boolean;
+    formatPriceFn?: (price: number) => string;
+    className?: string;
+    cardClassName?: string;
+}
+declare function ProductGrid({ params, onSelectProduct, onWishlistToggle, isWishlistSavedFn, showWishlistButton, formatPriceFn, className, cardClassName, }: ProductGridProps): React__default.JSX.Element;
+
+interface SlotPickerProps {
+    productId: string;
+    /** A single date (YYYY-MM-DD) — the real backend checks one day at a time. */
+    date: string;
+    staffId?: string;
+    locationId?: string;
+    onSelectSlot: (time: string) => void;
+    className?: string;
+    slotButtonClassName?: string;
+}
+/**
+ * REAL BUG FIXED (2026-09-20): rebuilt against the real backend response
+ * (GET /catalog/products/{id}/available-slots — a single `date`, not a
+ * dateFrom/dateTo range; `available_slots` is a flat array of ISO time
+ * strings, not slot objects with start_time/end_time/slots_remaining, none
+ * of which the real endpoint returns).
+ */
+declare function SlotPicker({ productId, date, staffId, locationId, onSelectSlot, className, slotButtonClassName, }: SlotPickerProps): React__default.JSX.Element;
+
+interface BespokeAvailabilityBadgeProps {
+    productId: string;
+    className?: string;
+}
+declare function BespokeAvailabilityBadge({ productId, className }: BespokeAvailabilityBadgeProps): React__default.JSX.Element | null;
+
+type BespokeStageKey = 'received' | 'development' | 'finished' | 'dispatched';
+interface BespokeProgressTrackerProps {
+    stage: BespokeStageKey;
+    className?: string;
+    activeStepClassName?: string;
+    completedStepClassName?: string;
+    inactiveStepClassName?: string;
+}
+declare function BespokeProgressTracker({ stage, className, activeStepClassName, completedStepClassName, inactiveStepClassName, }: BespokeProgressTrackerProps): React__default.JSX.Element;
+
+interface DeliverableReviewerProps {
+    order: Order;
+    className?: string;
+}
+/**
+ * REAL BUG FIXED (2026-09-20): rebuilt entirely — this used to fetch a
+ * "/service/projects/{order_id}/deliverables/" list that doesn't exist
+ * anywhere in the backend. The real bespoke deliverable model is a SINGLE
+ * proofing record per order (BespokeFulfillmentResponse, embedded as
+ * `order.bespoke_fulfillment` and flattened onto the SDK's Order type as
+ * `bespoke_*` fields by normaliseStorefrontOrder), not a fetchable list —
+ * there is no separate GET endpoint for it at all. Approve/request-revision
+ * now call the real endpoints (POST /orders/{id}/bespoke/approve,
+ * .../request-revision) instead of a fictional deliverable-id-scoped route.
+ */
+declare function DeliverableReviewer({ order, className }: DeliverableReviewerProps): React__default.JSX.Element;
+
+interface TruncatedValueProps {
+    /** The (possibly visually truncated, or compact/abbreviated) displayed value. */
+    value: ReactNode;
+    /** The full, untruncated/unabbreviated value shown on hover/title. */
+    fullValue?: ReactNode;
+    className?: string;
+    triggerClassName?: string;
+}
+/**
+ * TruncatedValue
+ * Wraps a string or numeric value so the full value is accessible on hover or title.
+ */
+declare function TruncatedValue({ value, fullValue, className, triggerClassName }: TruncatedValueProps): React.JSX.Element;
+
+interface OfflineBannerProps {
+    message?: string;
+    className?: string;
+}
+declare function OfflineBanner({ message, className, }: OfflineBannerProps): React.JSX.Element | null;
+
+interface MapPinDropProps {
+    initialLatitude?: number;
+    initialLongitude?: number;
+    onPinDrop?: (coordinates: {
+        latitude: number;
+        longitude: number;
+    }) => void;
+    value?: {
+        latitude: number;
+        longitude: number;
+    } | null;
+    height?: string;
+    disabled?: boolean;
+    zoom?: number;
+}
+declare function MapPinDrop({ initialLatitude, initialLongitude, onPinDrop, value, height, disabled, }: MapPinDropProps): React.JSX.Element;
+
+interface SearchableInputItem {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+}
+interface SearchableInputProps {
+    items: SearchableInputItem[];
+    value: string;
+    onSelect: (value: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    isLoading?: boolean;
+    skeletonCount?: number;
+    className?: string;
+    onSearchChange?: (search: string) => void;
+    debounceMs?: number;
+}
+declare function SearchableInput({ items, value, onSelect, placeholder, disabled, isLoading, className, onSearchChange, debounceMs, }: SearchableInputProps): React.JSX.Element;
+
+interface SearchableItem {
+    value: string;
+    label: string;
+    icon?: ReactNode;
+    description?: string;
+}
+interface SearchablePopoverProps {
+    items: SearchableItem[];
+    value: string;
+    onSelect: (value: string) => void;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    emptyMessage?: string;
+    disabled?: boolean;
+    isLoading?: boolean;
+    skeletonCount?: number;
+    className?: string;
+    triggerClassName?: string;
+    contentClassName?: string;
+    width?: string;
+    onSearchChange?: (search: string) => void;
+    searchValue?: string;
+    hasNextPage?: boolean;
+    isFetchingNextPage?: boolean;
+    onFetchNextPage?: () => void;
+    resolvedSelectedItem?: SearchableItem;
+}
+declare function SearchablePopover({ items, value, onSelect, placeholder, searchPlaceholder, emptyMessage, disabled, isLoading, triggerClassName, contentClassName, onSearchChange, searchValue, hasNextPage, isFetchingNextPage, onFetchNextPage, resolvedSelectedItem, }: SearchablePopoverProps): React.JSX.Element;
+
+interface LucideReactIconProps extends LucideProps {
+    icon: string | number | boolean | null | undefined | object;
+}
+declare const LucideReactIcon: React__default.FC<LucideReactIconProps>;
+
+interface UseUnsavedChangesOptions {
+    browserMessage?: string;
+    dialogTitle?: string;
+    dialogBody?: string;
+}
+interface UnsavedChangesDialogProps {
+    open: boolean;
+    onStay: () => void;
+    onLeave: () => void;
+    title?: string;
+    body?: string;
+}
+interface UseUnsavedChangesReturn {
+    isDirty: boolean;
+    markDirty: () => void;
+    resetDirty: () => void;
+    guardedNavigate: (action: () => void) => void;
+    dialogProps: UnsavedChangesDialogProps;
+}
+declare function useUnsavedChanges(options?: UseUnsavedChangesOptions): UseUnsavedChangesReturn;
+declare function UnsavedChangesDialog({ open, onStay, onLeave, title, body, }: UnsavedChangesDialogProps): React__default.JSX.Element | null;
+
+interface SelectOption {
+    id: string;
+    name: string;
+    image_url?: string | null;
+    collection_type?: string;
+    [key: string]: unknown;
+}
+interface MultiSelectPickerProps {
+    selected: string[];
+    onChange: (items: string[]) => void;
+    options?: SelectOption[];
+    isLoading?: boolean;
+    isFetchingNextPage?: boolean;
+    hasNextPage?: boolean;
+    onFetchNextPage?: () => void;
+    placeholder?: string;
+    onCreateOption?: (name: string) => void;
+    onSearchChange?: (search: string) => void;
+    searchValue?: string;
+}
+declare function MultiSelectPicker({ selected, onChange, options, isLoading, isFetchingNextPage, hasNextPage, onFetchNextPage, placeholder, onCreateOption, onSearchChange, searchValue, }: MultiSelectPickerProps): React.JSX.Element;
+
+type ObjectFit = "cover" | "contain" | "fill" | "none" | "scale-down";
+interface BaseSmartImageProps {
+    src: string | null | undefined;
+    alt: string;
+    className?: string;
+    imageClassName?: string;
+    priority?: boolean;
+    isRelative?: boolean;
+    sizes?: string;
+    objectFit?: ObjectFit;
+    /**
+     * Optional fallback image src rendered instead of the broken-image
+     * placeholder if the primary src fails to load.
+     */
+    fallbackSrc?: string;
+    /**
+     * Passed-through to the underlying Next.js <Image> to suppress
+     * hydration warnings on SSR-rendered images.
+     */
+    suppressHydrationWarning?: boolean;
+}
+/**
+ * SmartImageProps for the standard (non-motion) variant.
+ * Adds optional `style` for container sizing (e.g. explicit width/height).
+ */
+type SmartImageProps = BaseSmartImageProps & {
+    style?: CSSProperties;
+    draggable?: boolean;
+};
+/**
+ * SmartMotionImageProps for the Framer Motion variant.
+ * Extends SmartImageProps with all `motion.div` props (initial, animate, etc.)
+ */
+type SmartMotionImageProps = BaseSmartImageProps & Omit<HTMLMotionProps<"div">, "draggable"> & {
+    style?: CSSProperties;
+    draggable?: boolean;
+};
+/**
+ * Standard smart image component for Kasuvia storefronts and dashboards.
+ *
+ * Wraps Next.js `<Image fill>` with:
+ * - Strict src validation (rejects null / empty / "null" strings)
+ * - A shimmer skeleton shown while the image loads
+ * - A labelled placeholder shown when there is no valid src
+ * - A distinct failed-to-load placeholder (or optional `fallbackSrc`)
+ * - An `objectFit` prop (defaults to "cover") for flexibility
+ *
+ * Peer dependencies: next, framer-motion, lucide-react
+ */
+declare const SmartImage: React.ForwardRefExoticComponent<BaseSmartImageProps & {
+    style?: CSSProperties;
+    draggable?: boolean;
+} & React.RefAttributes<HTMLImageElement>>;
+/**
+ * Framer Motion variant of SmartImage.
+ * Accepts all `motion.div` props (e.g. `initial`, `animate`, `whileHover`)
+ * alongside the standard SmartImage props.
+ *
+ * Peer dependencies: next, framer-motion, lucide-react
+ */
+declare const SmartMotionImage: React.ForwardRefExoticComponent<Omit<SmartMotionImageProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+
+interface ImageEditorModalProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onImageSelect: (processedImage: Blob, fileName: string) => void;
+    aspectRatio?: number;
+    /** Max file size in bytes. Defaults to 10 MB. */
+    maxFileSize?: number;
+    acceptedFormats?: string[];
+    maxDimension?: number;
+    initialFile?: File | null;
+    /** Output blob format. Defaults to "image/jpeg". Pass "image/png" for alpha. */
+    outputFormat?: "image/jpeg" | "image/png";
+    /** JPEG export quality 0–1. */
+    outputQuality?: number;
+    /** Minimum output dimensions. */
+    minWidth?: number;
+    minHeight?: number;
+}
+/**
+ * ImageEditorModal — Studio-grade full-screen image editor.
+ *
+ * Features:
+ * - Fullscreen, theme-aware responsive modal layout
+ * - File drop / camera photo capture
+ * - Freehand / aspect-locked crop selection box with handles & rule-of-thirds grid
+ * - Pan, zoom, rotation slider, ±90° rotate buttons, horizontal & vertical flip
+ * - Brightness, contrast, saturation, blur adjustments
+ * - Offscreen canvas export slicing exact crop region into JPEG/PNG Blob
+ */
+declare function ImageEditorModal({ open, onOpenChange, onImageSelect, aspectRatio: initialAspectRatio, maxFileSize, acceptedFormats, maxDimension, initialFile, outputFormat, outputQuality, minWidth, minHeight, }: ImageEditorModalProps): React.JSX.Element | null;
+
+interface ImageViewerModalProps {
+    isOpen: boolean;
+    onClose: () => void;
+    images?: string[];
+    selectedImage: number;
+    setSelectedImage: (index: number) => void;
+    productName: string;
+}
+/**
+ * ImageViewerModal — Self-contained full-screen product image viewer.
+ *
+ * Designed to work standalone across any application (kasuvia-storefront, kasuvia, etc.)
+ * with zero reliance on external CSS purging or Tailwind utility scanning.
+ */
+declare function ImageViewerModal({ isOpen, onClose, images, selectedImage, setSelectedImage, productName, }: ImageViewerModalProps): React.ReactPortal | null;
+
+interface AnalyticsScriptsProps {
+    websiteId?: string;
+    scriptUrl?: string;
+    recorderUrl?: string;
+}
+/**
+ * AnalyticsScripts — Consent-gated Umami tracker + session-replay loader.
+ *
+ * REAL GAP FIXED (owner-requested legal-compliance review): Umami's tracker
+ * AND its session-replay/heatmap recorder used to render unconditionally the
+ * moment a project had analytics provisioned — no consent check anywhere.
+ * Session replay specifically is non-essential tracking under GDPR/NDPR
+ * consent rules regardless of PII-masking/sample-rate mitigations already
+ * built into the recorder's own config — masking reduces risk, it doesn't
+ * remove the consent requirement.
+ *
+ * This component is the actual technical gate: it renders nothing until the
+ * visitor has affirmatively accepted via CookieConsentBanner, and re-checks
+ * live if they change their choice without needing a page reload.
+ *
+ * Peer dependencies: next (next/script)
+ */
+declare function AnalyticsScripts({ websiteId, scriptUrl, recorderUrl }: AnalyticsScriptsProps): React.JSX.Element | null;
+
+interface CookieConsentBannerProps {
+    /**
+     * URL for the privacy policy page. Defaults to "/privacy".
+     */
+    privacyUrl?: string;
+    /**
+     * Custom className for the outer banner container.
+     */
+    className?: string;
+    /**
+     * Custom className for the "Accept" button.
+     */
+    acceptButtonClassName?: string;
+    /**
+     * Custom className for the "Reject non-essential" button.
+     */
+    rejectButtonClassName?: string;
+}
+/**
+ * CookieConsentBanner — GDPR/NDPR compliant consent gate.
+ *
+ * Owner-requested (legal-compliance review): analytics/session-replay tracking
+ * must not run before the visitor has actually chosen to allow it — see
+ * AnalyticsScripts, which gates the real script tags on this same stored choice.
+ *
+ * Shown once, bottom banner (not a blocking modal — the standard, least-intrusive
+ * pattern), with Accept and Reject weighted equally, matching GDPR/NDPR guidance
+ * against making "reject" harder to find than "accept".
+ *
+ * Styled with utility classes by default. Pass custom classNames to restyle with
+ * your storefront's theme (e.g. shadcn/Tailwind classes) without touching the SDK.
+ */
+declare function CookieConsentBanner({ privacyUrl, className, acceptButtonClassName, rejectButtonClassName, }: CookieConsentBannerProps): React.JSX.Element | null;
+
+export { AnalyticsScripts, type AnalyticsScriptsProps, BespokeAvailabilityBadge, type BespokeAvailabilityBadgeProps, BespokeProgressTracker, type BespokeProgressTrackerProps, type BespokeStageKey, CardSkeleton, type CardSkeletonProps, CartItem, type CartItemProps, CartItemSkeleton, type CartItemSkeletonProps, CartSidebar, type CartSidebarProps, CartTypeMismatchBanner, type CartTypeMismatchBannerProps, CookieConsentBanner, type CookieConsentBannerProps, DeliverableReviewer, type DeliverableReviewerProps, ImageEditorModal, type ImageEditorModalProps, ImageViewerModal, type ImageViewerModalProps, LucideReactIcon, type LucideReactIconProps, MapPinDrop, type MapPinDropProps, MultiSelectPicker, type MultiSelectPickerProps, OfflineBanner, type OfflineBannerProps, OrderItemSkeleton, type OrderItemSkeletonProps, ProductCard, type ProductCardProps, ProductCardSkeleton, type ProductCardSkeletonProps, ProductGrid, type ProductGridProps, SearchableInput, type SearchableInputItem, type SearchableInputProps, type SearchableItem, SearchablePopover, type SearchablePopoverProps, type SelectOption, SlotPicker, type SlotPickerProps, SmartImage, type SmartImageProps, SmartMotionImage, type SmartMotionImageProps, TableSkeleton, type TableSkeletonProps, TruncatedValue, type TruncatedValueProps, UnsavedChangesDialog, type UnsavedChangesDialogProps, type UseUnsavedChangesOptions, type UseUnsavedChangesReturn, useUnsavedChanges };