@classytic/commerce-sdk 0.1.1

package/dist/logistics/index.d.ts

@@ -0,0 +1,248 @@
+import { g as PickupStore, P as ProviderName, d as ProviderCharges, f as TrackingResult, j as CreateShipmentPayload, C as CancelShipmentResult } from '../logistics-CrpKadKE.js';
+export { A as Area, m as CalculateChargeParams, k as CancelShipmentPayload, p as CheckoutSettings, n as DeliveryFeeSource, q as DeliveryMethod, r as DeliveryOption, b as District, D as Division, L as LogisticsApi, i as LogisticsConfig, c as LogisticsProvider, o as PickupBranchInfo, a as ProviderAreaIds, h as ProviderConfig, S as ShipmentStatus, e as ShipmentTimelineEvent, T as TrackingData, U as UpdateShipmentStatusPayload, l as logisticsApi } from '../logistics-CrpKadKE.js';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { h as OrderShipping, S as ShippingStatus } from '../order-B3dCvHgK.js';
+import '../api-factory-B_h4RKBm.js';
+
+declare const LOGISTICS_KEYS: {
+    all: readonly ["logistics"];
+    pickupStores: (provider?: string) => readonly ["logistics", "pickup-stores", string | undefined];
+    shipment: (id: string) => readonly ["logistics", "shipment", string];
+    tracking: (id: string) => readonly ["logistics", "tracking", string];
+    charge: (params: {
+        deliveryAreaId: number;
+        amount: number;
+        weight?: number;
+    }) => readonly ["logistics", "charge", {
+        deliveryAreaId: number;
+        amount: number;
+        weight?: number;
+    }];
+    config: () => readonly ["logistics", "config"];
+};
+interface QueryOptions {
+    enabled?: boolean;
+    staleTime?: number;
+    refetchInterval?: number | false;
+}
+interface ChargeParams {
+    deliveryAreaId: number;
+    pickupAreaId?: number;
+    amount: number;
+    weight?: number;
+    provider?: ProviderName;
+}
+interface UseDeliveryChargeParams {
+    deliveryAreaId: number | null | undefined;
+    amount: number;
+    weight?: number;
+    enabled?: boolean;
+}
+interface UseDeliveryChargeReturn {
+    charges: ProviderCharges | null;
+    deliveryCharge: number;
+    codCharge: number;
+    totalCharge: number;
+    isLoading: boolean;
+    isFetching: boolean;
+    error: Error | null;
+    refetch: () => void;
+}
+interface UseLogisticsActionsReturn {
+    createShipment: (params: {
+        orderId: string;
+        data: CreateShipmentPayload;
+    }) => Promise<OrderShipping | undefined>;
+    isCreatingShipment: boolean;
+    cancelShipment: (params: {
+        shipmentId: string;
+        reason?: string;
+    }) => Promise<CancelShipmentResult | undefined>;
+    isCancellingShipment: boolean;
+    updateShipmentStatus: (params: {
+        shipmentId: string;
+        data: UpdateShipmentStatusParams;
+    }) => Promise<OrderShipping | undefined>;
+    isUpdatingStatus: boolean;
+    isLoading: boolean;
+}
+interface UpdateShipmentStatusParams {
+    status: ShippingStatus | string;
+    note?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Fetch pickup stores from logistics provider
+ *
+ * @param token - Auth token (admin required)
+ * @param provider - Optional provider filter
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * function PickupStoreSelect() {
+ *   const { data: stores, isLoading } = usePickupStores(token);
+ *
+ *   return (
+ *     <Select>
+ *       {stores?.map(store => (
+ *         <SelectItem key={store.id} value={store.id.toString()}>
+ *           {store.name} - {store.areaName}
+ *         </SelectItem>
+ *       ))}
+ *     </Select>
+ *   );
+ * }
+ * ```
+ */
+declare function usePickupStores(token: string, provider?: string, options?: QueryOptions): _tanstack_react_query.UseQueryResult<PickupStore[], Error>;
+/**
+ * Calculate delivery charge via provider API
+ *
+ * @param token - Auth token (optional for public)
+ * @param params - Charge calculation parameters
+ * @param options - Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: charges } = useDeliveryChargeCalculation(token, {
+ *   deliveryAreaId: 1206,
+ *   amount: isCOD ? cartTotal : 0,
+ * });
+ * ```
+ */
+declare function useDeliveryChargeCalculation(token: string | null, params: ChargeParams | null, options?: QueryOptions): _tanstack_react_query.UseQueryResult<ProviderCharges, Error>;
+/**
+ * Convenience hook for delivery charge with extracted values
+ *
+ * @param params - Delivery charge parameters
+ *
+ * @example
+ * ```tsx
+ * function CheckoutDelivery({ areaId, subtotal, isCOD }) {
+ *   const { deliveryCharge, isLoading } = useDeliveryCharge({
+ *     deliveryAreaId: areaId,
+ *     amount: isCOD ? subtotal : 0,
+ *   });
+ *
+ *   return (
+ *     <p>Delivery: {isLoading ? "..." : `৳${deliveryCharge}`}</p>
+ *   );
+ * }
+ * ```
+ */
+declare function useDeliveryCharge({ deliveryAreaId, amount, weight, enabled, }: UseDeliveryChargeParams): UseDeliveryChargeReturn;
+/**
+ * Get shipping info by order ID
+ *
+ * @param token - Auth token
+ * @param orderId - Order ID
+ * @param options - Query options
+ */
+declare function useShipment(token: string, orderId: string | null, options?: QueryOptions): _tanstack_react_query.UseQueryResult<OrderShipping, Error>;
+/**
+ * Track shipment - fetches latest status from provider
+ *
+ * @param token - Auth token
+ * @param shipmentId - Order ID or tracking number
+ * @param options - Query options (supports refetchInterval for auto-refresh)
+ *
+ * @example
+ * ```tsx
+ * function ShipmentTracker({ shipmentId }) {
+ *   const { data, isLoading } = useTrackShipment(token, shipmentId, {
+ *     refetchInterval: 5 * 60 * 1000, // Auto-refresh every 5 minutes
+ *   });
+ *
+ *   return (
+ *     <Timeline events={data?.tracking?.timeline || []} />
+ *   );
+ * }
+ * ```
+ */
+declare function useTrackShipment(token: string, shipmentId: string | null, options?: QueryOptions): _tanstack_react_query.UseQueryResult<TrackingResult, Error>;
+/**
+ * Create shipment mutation
+ *
+ * @param token - Auth token
+ *
+ * @example
+ * ```tsx
+ * function CreateShipmentButton({ order }) {
+ *   const { mutate, isPending } = useCreateShipment(token);
+ *
+ *   return (
+ *     <Button
+ *       onClick={() =>
+ *         mutate({
+ *           orderId: order._id,
+ *           data: { provider: "redx", useProviderApi: true },
+ *         })
+ *       }
+ *       disabled={isPending}
+ *     >
+ *       Create Shipment
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCreateShipment(token: string): _tanstack_react_query.UseMutationResult<OrderShipping | undefined, Error, {
+    orderId: string;
+    data: CreateShipmentPayload;
+}, unknown>;
+/**
+ * Cancel shipment mutation
+ *
+ * @param token - Auth token
+ */
+declare function useCancelShipment(token: string): _tanstack_react_query.UseMutationResult<CancelShipmentResult | undefined, Error, {
+    shipmentId: string;
+    reason?: string;
+}, unknown>;
+/**
+ * Update shipment status mutation
+ *
+ * @param token - Auth token
+ */
+declare function useUpdateShipmentStatus(token: string): _tanstack_react_query.UseMutationResult<OrderShipping | undefined, Error, {
+    shipmentId: string;
+    data: UpdateShipmentStatusParams;
+}, unknown>;
+/**
+ * Combined hook for all logistics mutations
+ *
+ * @param token - Auth token
+ *
+ * @example
+ * ```tsx
+ * function ShipmentActions({ order }) {
+ *   const {
+ *     createShipment,
+ *     cancelShipment,
+ *     isLoading,
+ *   } = useLogisticsActions(token);
+ *
+ *   return (
+ *     <>
+ *       <Button
+ *         onClick={() =>
+ *           createShipment({
+ *             orderId: order._id,
+ *             data: { provider: "redx", useProviderApi: true },
+ *           })
+ *         }
+ *       >
+ *         Create Shipment
+ *       </Button>
+ *       <Button onClick={() => cancelShipment({ shipmentId: order._id })}>
+ *         Cancel
+ *       </Button>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useLogisticsActions(token: string): UseLogisticsActionsReturn;
+
+export { CancelShipmentResult, CreateShipmentPayload, LOGISTICS_KEYS, PickupStore, ProviderCharges, ProviderName, TrackingResult, type UseDeliveryChargeReturn, type UseLogisticsActionsReturn, useCancelShipment, useCreateShipment, useDeliveryCharge, useDeliveryChargeCalculation, useLogisticsActions, usePickupStores, useShipment, useTrackShipment, useUpdateShipmentStatus };

package/dist/logistics/index.js

@@ -0,0 +1,7 @@
+"use client";
+export { LOGISTICS_KEYS, LogisticsApi, logisticsApi, useCancelShipment, useCreateShipment, useDeliveryCharge, useDeliveryChargeCalculation, useLogisticsActions, usePickupStores, useShipment, useTrackShipment, useUpdateShipmentStatus } from '../chunk-2YAZ5WG6.js';
+import '../chunk-QCTXAMLA.js';
+import '../chunk-U3XT35GZ.js';
+import '../chunk-IHCBBLLW.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/logistics/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/logistics-CrpKadKE.d.ts

@@ -0,0 +1,410 @@
+import { B as BaseApi, R as RequestOptions, A as ApiResponse } from './api-factory-B_h4RKBm.js';
+import { a as ShippingProvider, h as OrderShipping, S as ShippingStatus } from './order-B3dCvHgK.js';
+
+/**
+ * Logistics Types
+ *
+ * Types for logistics API responses (tracking, charges, config).
+ * For area data types, install @classytic/bd-areas:
+ *
+ * ```typescript
+ * import type { Area, Division, District, ProviderAreaIds } from '@classytic/bd-areas';
+ * import { searchAreas, getAreasByDistrict } from '@classytic/bd-areas';
+ * ```
+ */
+
+type ProviderName = 'redx' | 'pathao' | 'steadfast' | 'paperfly' | 'sundarban' | 'sa_paribahan' | 'dhl' | 'fedex' | 'manual' | 'other';
+interface ProviderAreaIds {
+    redx?: number;
+    pathao?: number;
+    steadfast?: number;
+    paperfly?: number;
+}
+interface Area {
+    internalId: number;
+    name: string;
+    districtId: number;
+    districtName: string;
+    divisionId: number;
+    divisionName: string;
+    postCode?: string;
+    providerAreaIds?: ProviderAreaIds;
+}
+interface Division {
+    id: number;
+    name: string;
+    nameBn?: string;
+}
+interface District {
+    id: number;
+    divisionId: number;
+    name: string;
+    nameBn?: string;
+}
+type ShipmentStatus = 'pickup-requested' | 'pickup-pending' | 'picked-up' | 'ready-for-delivery' | 'in-transit' | 'agent-hold' | 'delivery-in-progress' | 'out-for-delivery' | 'delivered' | 'failed-attempt' | 'agent-returning' | 'returning' | 'returned' | 'cancelled' | 'on-hold';
+type LogisticsProvider = 'redx' | 'pathao' | 'steadfast' | 'paperfly' | 'sundarban' | 'sa_paribahan' | 'dhl' | 'fedex' | 'manual' | 'other';
+/**
+ * Response from GET /logistics/charge
+ *
+ * Use deliveryCharge for customer-facing price.
+ * codCharge is the provider's fee for cash collection (not charged to customer).
+ */
+interface ProviderCharges {
+    /** Base delivery charge from provider */
+    deliveryCharge: number;
+    /** COD charge (provider's fee, not customer-facing) */
+    codCharge: number;
+    /** Total charge (deliveryCharge + codCharge) */
+    totalCharge: number;
+    /** Currency code (default: BDT) */
+    currency?: string;
+}
+interface ShipmentTimelineEvent {
+    status: ShipmentStatus;
+    message?: string;
+    messageLocal?: string;
+    timestamp: string;
+    raw?: Record<string, unknown>;
+}
+interface TrackingData {
+    trackingId: string;
+    status: ShipmentStatus;
+    providerStatus?: string;
+    currentLocation?: string;
+    estimatedDelivery?: string;
+    timeline: ShipmentTimelineEvent[];
+}
+interface TrackingResult {
+    orderId: string;
+    shipping: OrderShipping;
+    tracking: TrackingData;
+}
+/**
+ * Pickup store from RedX API
+ * Admin creates these via RedX dashboard
+ * Used for: selecting pickup location when creating shipments
+ */
+interface PickupStore {
+    /** RedX store ID */
+    id: number;
+    /** Store name */
+    name: string;
+    /** Store address */
+    address?: string;
+    /** Contact phone */
+    phone?: string;
+    /** Area ID (RedX area) - used for charge calculation */
+    areaId?: number;
+    /** Area name */
+    areaName?: string;
+    /** Creation date */
+    createdAt?: string;
+}
+interface ProviderConfig {
+    provider: LogisticsProvider;
+    apiUrl?: string;
+    apiKey?: string;
+    isActive: boolean;
+    isDefault?: boolean;
+    settings?: Record<string, unknown>;
+}
+interface LogisticsConfig {
+    _id: string;
+    defaultProvider: LogisticsProvider;
+    providers: ProviderConfig[];
+    supportedProviders: LogisticsProvider[];
+}
+interface CreateShipmentPayload {
+    /** Shipping provider */
+    provider: ShippingProvider;
+    /** Use provider API integration (e.g., RedX) */
+    useProviderApi?: boolean;
+    /** Pickup store ID for provider API shipments */
+    pickupStoreId?: number;
+    /** Parcel weight in grams */
+    weight?: number;
+    /** Special handling instructions */
+    instructions?: string;
+    /** Manual tracking number (for non-API shipments) */
+    trackingNumber?: string;
+    /** Manual consignment ID (optional) */
+    consignmentId?: string;
+    /** Manual tracking URL */
+    trackingUrl?: string;
+    /** Shipping label URL */
+    labelUrl?: string;
+    /** Estimated delivery date */
+    estimatedDelivery?: string;
+    /** Extra metadata for audit or provider data */
+    metadata?: Record<string, unknown>;
+}
+interface UpdateShipmentStatusPayload {
+    status: ShippingStatus | string;
+    note?: string;
+    metadata?: Record<string, unknown>;
+}
+interface CancelShipmentPayload {
+    reason?: string;
+}
+interface CancelShipmentResult {
+    orderId: string;
+    shipping: OrderShipping;
+}
+interface CalculateChargeParams {
+    /** Delivery area internalId from bd-areas */
+    deliveryAreaId: number;
+    /** COD amount in BDT (use 0 for prepaid) */
+    amount: number;
+    /** Parcel weight in grams (default: 500g) */
+    weight?: number;
+    /** Pickup area internalId (optional - auto-fetched from merchant's RedX pickup store) */
+    pickupAreaId?: number;
+    /** Specific provider (optional - uses default provider if not specified) */
+    provider?: ProviderName;
+}
+type DeliveryFeeSource = 'static' | 'provider';
+/**
+ * Branch info for store pickup
+ */
+interface PickupBranchInfo {
+    branchId: string;
+    branchCode: string;
+    branchName: string;
+}
+/**
+ * Checkout settings from platform config
+ */
+interface CheckoutSettings {
+    /** Enable store pickup option */
+    allowStorePickup: boolean;
+    /** Branches available for pickup (empty = all active) */
+    pickupBranches: PickupBranchInfo[];
+    /** Fee source: 'static' (from zones) or 'provider' (from RedX API) */
+    deliveryFeeSource: DeliveryFeeSource;
+    /** Minimum order for free delivery (0 = disabled) */
+    freeDeliveryThreshold: number;
+}
+type DeliveryMethod = 'standard' | 'express' | 'pickup';
+/**
+ * Delivery option for checkout UI
+ */
+interface DeliveryOption {
+    method: DeliveryMethod;
+    label: string;
+    price: number;
+    estimatedDays?: string;
+    /** For pickup: branch info */
+    pickupBranch?: PickupBranchInfo;
+}
+
+type FetchOptions = Omit<RequestOptions, 'token' | 'organizationId'>;
+/**
+ * Logistics API
+ *
+ * Manages logistics utilities and delivery charge calculation.
+ *
+ * NOTE: For area data (divisions, districts, areas), use @classytic/bd-areas directly:
+ * ```typescript
+ * import { searchAreas, getAreasByDistrict, getArea } from '@classytic/bd-areas';
+ * ```
+ *
+ * Public Endpoints:
+ * - GET /logistics/charge - Calculate delivery charge via provider (RedX)
+ *
+ * Shipping Endpoints (Admin/Store Manager):
+ * - POST /orders/:id/shipping - Request shipping (manual or provider API)
+ * - PATCH /orders/:id/shipping - Update shipping status
+ * - GET /orders/:id/shipping - Get shipping info
+ * - GET /logistics/shipments/:id/track - Track shipment
+ * - POST /logistics/shipments/:id/cancel - Cancel shipment
+ *
+ * Admin Endpoints:
+ * - GET /logistics/config - Get config (read-only)
+ * - GET /logistics/pickup-stores - List pickup stores
+ * - GET /logistics/health/circuit-status - Get circuit breaker status
+ * - POST /logistics/health/circuit-reset/:provider - Reset circuit breaker
+ */
+declare class LogisticsApi extends BaseApi<OrderShipping, CreateShipmentPayload> {
+    constructor(config?: {});
+    /**
+     * Calculate delivery charge via provider API (e.g., RedX)
+     * GET /logistics/charge
+     *
+     * Use this to get real-time delivery charges from the logistics provider
+     * before creating an order.
+     *
+     * @param deliveryAreaId - Area internalId from @classytic/bd-areas
+     * @param amount - COD amount in BDT (use 0 for prepaid orders)
+     * @param weight - Parcel weight in grams (default: 500g)
+     *
+     * @example
+     * import { searchAreas } from '@classytic/bd-areas';
+     *
+     * // 1. User selects area
+     * const areas = searchAreas('mohamm');
+     * const selectedArea = areas[0]; // { internalId: 1206, name: 'Mohammadpur', ... }
+     *
+     * // 2. Calculate delivery charge
+     * const { data } = await logisticsApi.calculateCharge({
+     *   deliveryAreaId: selectedArea.internalId,
+     *   amount: isCOD ? cartTotal : 0,
+     * });
+     * // { deliveryCharge: 60, codCharge: 15, totalCharge: 75 }
+     */
+    calculateCharge({ deliveryAreaId, pickupAreaId, amount, weight, provider, options, }: {
+        deliveryAreaId: number;
+        pickupAreaId?: number;
+        amount: number;
+        weight?: number;
+        provider?: ProviderName;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<ProviderCharges>>;
+    /**
+     * Get logistics configuration (read-only from .env)
+     * GET /logistics/config
+     *
+     * NOTE: Configuration is managed via environment variables.
+     * To change settings, update .env file and restart server.
+     */
+    getConfig({ token, options, }: {
+        token: string;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<LogisticsConfig>>;
+    /**
+     * Get pickup stores from RedX API
+     * GET /logistics/pickup-stores
+     *
+     * Pickup stores are created by admin in RedX dashboard.
+     * Use this to list available pickup locations when creating shipments.
+     *
+     * @example
+     * // Admin: List pickup stores for shipment creation
+     * const { data: stores } = await logisticsApi.getPickupStores({ token });
+     *
+     * // Display in dropdown for admin to select
+     * stores.forEach(store => {
+     *   console.log(`${store.name} - ${store.areaName} (ID: ${store.id})`);
+     * });
+     *
+     * // Use selected store when creating shipment
+     * await logisticsApi.createShipment({
+     *   token,
+     *   data: {
+     *     orderId: order._id,
+     *     pickupStoreId: selectedStore.id,  // From dropdown
+     *   },
+     * });
+     */
+    getPickupStores({ token, provider, options, }: {
+        token: string;
+        provider?: string;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<PickupStore[]>>;
+    /**
+     * Request shipping for an order (manual or provider API)
+     * POST /orders/:id/shipping
+     *
+     * This updates the order.shipping object and optionally triggers
+     * provider API shipment creation when useProviderApi=true.
+     *
+     * @example
+     * // Manual: Record tracking details
+     * const shipping = await logisticsApi.createShipment({
+     *   token,
+     *   orderId: order._id,
+     *   data: {
+     *     provider: "other",
+     *     trackingNumber: "COURIER123456",
+     *     trackingUrl: "https://courier-website.com/track/COURIER123456",
+     *   },
+     * });
+     *
+     * @example
+     * // Provider API: Create shipment with pickup store
+     * const { data: stores } = await logisticsApi.getPickupStores({ token });
+     * const shipping = await logisticsApi.createShipment({
+     *   token,
+     *   orderId: order._id,
+     *   data: {
+     *     provider: "redx",
+     *     useProviderApi: true,
+     *     pickupStoreId: stores[0].id,  // Select pickup location
+     *     weight: 500,                  // Parcel weight in grams
+     *     instructions: 'Handle with care',
+     *   },
+     * });
+     */
+    createShipment({ token, orderId, data, options, }: {
+        token: string;
+        orderId: string;
+        data: CreateShipmentPayload;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<OrderShipping>>;
+    /**
+     * Get shipping info for an order
+     * GET /orders/:id/shipping
+     */
+    getShipment({ token, id, options, }: {
+        token: string;
+        id: string;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<OrderShipping | null>>;
+    /**
+     * Track shipment (fetch latest from provider)
+     * GET /logistics/shipments/:id/track
+     *
+     * @param id - Order ID or tracking number
+     */
+    trackShipment({ token, id, options, }: {
+        token: string;
+        id: string;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<TrackingResult>>;
+    /**
+     * Update shipping status for an order
+     * PATCH /orders/:id/shipping
+     */
+    updateShipmentStatus({ token, id, data, options, }: {
+        token: string;
+        id: string;
+        data: UpdateShipmentStatusPayload;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<OrderShipping>>;
+    /**
+     * Cancel shipment
+     * POST /logistics/shipments/:id/cancel
+     *
+     * @param id - Order ID or tracking number
+     */
+    cancelShipment({ token, id, data, options, }: {
+        token: string;
+        id: string;
+        data?: CancelShipmentPayload;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<CancelShipmentResult>>;
+    /**
+     * Get circuit breaker status for all providers
+     * GET /logistics/health/circuit-status
+     */
+    getCircuitStatus({ token, options, }: {
+        token: string;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<Record<string, {
+        state: string;
+        failureCount: number;
+    }>>>;
+    /**
+     * Reset circuit breaker for a provider
+     * POST /logistics/health/circuit-reset/:provider
+     */
+    resetProviderCircuit({ token, provider, options, }: {
+        token: string;
+        provider: string;
+        options?: FetchOptions;
+    }): Promise<ApiResponse<{
+        message: string;
+    }>>;
+}
+declare const logisticsApi: LogisticsApi;
+
+export { type Area as A, type CancelShipmentResult as C, type Division as D, LogisticsApi as L, type ProviderName as P, type ShipmentStatus as S, type TrackingData as T, type UpdateShipmentStatusPayload as U, type ProviderAreaIds as a, type District as b, type LogisticsProvider as c, type ProviderCharges as d, type ShipmentTimelineEvent as e, type TrackingResult as f, type PickupStore as g, type ProviderConfig as h, type LogisticsConfig as i, type CreateShipmentPayload as j, type CancelShipmentPayload as k, logisticsApi as l, type CalculateChargeParams as m, type DeliveryFeeSource as n, type PickupBranchInfo as o, type CheckoutSettings as p, type DeliveryMethod as q, type DeliveryOption as r };