@burdenoff/microfe-store 2026.714.6 → 2026.715.1

package/dist/hooks/useBackendCart.d.ts

@@ -0,0 +1,73 @@
+import { AddToCartInput, CreateStoreOrderInput } from '../generated/global-types';
+
+export interface Cart {
+    id: string;
+    userId?: string;
+    organizationId?: string;
+    sessionId?: string;
+    status: 'ACTIVE' | 'ABANDONED' | 'CONVERTED' | 'EXPIRED';
+    currency: string;
+    subtotal: number;
+    total: number;
+    itemCount: number;
+    notes?: string;
+    expiresAt?: string;
+    lastActivityAt: string;
+    createdAt: string;
+    updatedAt: string;
+    requiresShipping: boolean;
+    isEmpty: boolean;
+    items: CartItem[];
+}
+export interface CartItem {
+    id: string;
+    cartId: string;
+    productId: string;
+    variantId?: string;
+    itemType: 'DIGITAL' | 'PHYSICAL' | 'BUNDLE';
+    quantity: number;
+    unitPrice: number;
+    compareAtPrice?: number;
+    subtotal: number;
+    workspaceId?: string;
+    productName: string;
+    variantName?: string;
+    productIcon?: string;
+    product?: {
+        id: string;
+        name: string;
+        slug?: string;
+        icon?: string;
+        price?: number;
+        pricingModel?: string;
+    };
+    addedAt: string;
+    updatedAt: string;
+}
+/**
+ * Hook for backend cart operations
+ */
+export declare function useBackendCart(): {
+    cart: Cart | null;
+    cartItems: CartItem[];
+    itemCount: number;
+    subtotal: number;
+    tax: number;
+    total: number;
+    currency: string;
+    loading: boolean;
+    addingToCart: boolean;
+    updatingCartItem: boolean;
+    removingFromCart: boolean;
+    clearingCart: boolean;
+    checkingOut: boolean;
+    error: Error | null;
+    addProductToCart: (input: AddToCartInput) => Promise<Cart | undefined>;
+    updateQuantity: (cartItemId: string, quantity: number) => Promise<Cart | undefined>;
+    removeProductFromCart: (cartItemId: string) => Promise<Cart | undefined>;
+    clearAllItems: () => Promise<Cart | undefined>;
+    createOrder: (input: CreateStoreOrderInput) => Promise<{
+        id: string;
+    }>;
+    refetchCart: (forceNetwork?: boolean) => Promise<void>;
+};

package/dist/hooks/useCart.d.ts

@@ -0,0 +1,62 @@
+import { Product, ProductVariant } from '../types';
+
+/**
+ * Hook for cart management (now using backend cart)
+ *
+ * This hook provides a unified interface for cart operations,
+ * using the backend for cart data and Zustand for UI state.
+ */
+export declare function useCart(): {
+    cart: import('./useBackendCart').Cart | null;
+    cartItems: {
+        id: string;
+        productId: string;
+        productName: string;
+        productIcon: string | undefined;
+        variantName: string | undefined;
+        subtotal: number;
+        product: {
+            id: string;
+            name: string;
+            displayName: string;
+            icon: string | undefined;
+            iconUrl: string | undefined;
+            publisher: {
+                displayName?: string;
+                name?: string;
+            } | undefined;
+            pricingModel: string | undefined;
+        };
+        variantId: string | undefined;
+        variant: {
+            name: string;
+            version: string;
+        } | undefined;
+        quantity: number;
+        unitPrice: number;
+        totalPrice: number;
+        itemType: "physical" | "digital" | "bundle";
+    }[];
+    itemCount: number;
+    subtotal: number;
+    tax: number;
+    total: number;
+    cartOpen: boolean;
+    loading: boolean;
+    addingToCart: boolean;
+    updatingCartItem: boolean;
+    removingFromCart: boolean;
+    clearingCart: boolean;
+    checkingOut: boolean;
+    addProduct: (product: Product, variant?: ProductVariant, quantity?: number, workspaceId?: string) => Promise<void>;
+    removeProduct: (cartItemId: string) => Promise<void>;
+    updateQuantity: (cartItemId: string, quantity: number) => Promise<void>;
+    clearCart: () => Promise<void>;
+    createOrder: (input: import('../generated/global-types').CreateStoreOrderInput) => Promise<{
+        id: string;
+    }>;
+    refetchCart: (forceNetwork?: boolean) => Promise<void>;
+    toggleCart: () => void;
+    openCart: () => void;
+    closeCart: () => void;
+};

package/dist/hooks/useInstallations.d.ts

@@ -0,0 +1,47 @@
+import { StoreInstallationStatus, InstallationFilterInput } from '../generated/global-types';
+
+export interface InstalledApp {
+    id: string;
+    productId: string;
+    workspaceId: string;
+    organizationId?: string | null;
+    status: StoreInstallationStatus;
+    installedAt: string;
+    version?: string | null;
+    updatedAt: string;
+    workspaceName?: string | null;
+    workspaceType?: string | null;
+    installedById: string;
+    manifest?: Record<string, unknown> | null;
+    metadata?: Record<string, unknown> | null;
+    context?: Record<string, unknown> | null;
+    grantedPermissions?: Array<{
+        resource: string;
+        level: 'read' | 'write';
+    }> | null;
+    uninstalledAt?: string | null;
+    uninstalledById?: string | null;
+}
+interface InstallationsState {
+    installations: InstalledApp[];
+    totalCount: number;
+    hasMore: boolean;
+    loading: boolean;
+    error: Error | null;
+    uninstallingIds: Set<string>;
+    refetch: () => Promise<void>;
+    loadMore: () => void;
+    uninstall: (installation: Pick<InstalledApp, 'workspaceId' | 'productId'>, reason?: string) => Promise<boolean>;
+}
+export declare function useInstallations(options?: {
+    filter?: InstallationFilterInput;
+    limit?: number;
+    offset?: number;
+}): InstallationsState;
+export declare function useInstallation(installationId?: string): {
+    installation: InstalledApp | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+export {};

package/dist/hooks/useOrders.d.ts

@@ -0,0 +1,47 @@
+import { OrderStatus } from '../generated/global-types';
+
+interface StoreOrder {
+    id: string;
+    status: string;
+    total: number;
+    currency: string;
+    lineItems: Array<{
+        productId: string;
+        name: string;
+        quantity: number;
+        unitPrice: number;
+        subtotal: number;
+        itemType?: string;
+        pricingModel?: string;
+        productType?: string;
+        productIcon?: string;
+        variantId?: string;
+        variantName?: string;
+        version?: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+    fulfillment?: {
+        status?: string | null;
+        trackingNumber?: string | null;
+        trackingUrl?: string | null;
+        carrier?: string | null;
+        estimatedDeliveryDate?: string | null;
+    } | null;
+}
+/**
+ * Hook for fetching and managing orders with offset-based pagination.
+ */
+export declare function useOrders(options?: {
+    limit?: number;
+    offset?: number;
+    status?: OrderStatus;
+}): {
+    orders: StoreOrder[];
+    hasMore: boolean;
+    loading: boolean;
+    error: Error | null;
+    refetchOrders: () => Promise<void>;
+    loadMore: () => void;
+};
+export {};

package/dist/hooks/useProductSearch.d.ts

@@ -0,0 +1,22 @@
+import { ProductFilter, ProductSort, SortBy } from '../types';
+
+/**
+ * Hook for product search and filtering
+ */
+export declare function useProductSearch(): {
+    searchQuery: string;
+    activeFilters: ProductFilter;
+    viewMode: import('..').ViewMode;
+    sortBy: SortBy;
+    showFiltersPanel: boolean;
+    graphqlSort: ProductSort;
+    graphqlFilter: ProductFilter;
+    hasActiveFilters: boolean;
+    setSearchQuery: (query: string) => void;
+    updateFilters: (filters: Partial<ProductFilter>) => void;
+    clearFilters: () => void;
+    resetFilters: () => void;
+    setViewMode: (mode: import('..').ViewMode) => void;
+    setSortBy: (sort: SortBy) => void;
+    toggleFiltersPanel: () => void;
+};