@stacksjs/commerce 0.70.37 → 0.70.43

package/dist/src/shippings/shipping-rates/update.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Update a shipping rate
+ *
+ * @param id The shipping rate ID to update
+ * @param data The shipping rate data to update
+ * @returns The updated shipping rate record
+ */
+export declare function update(id: number, data: ShippingRateUpdate): Promise<ShippingRateJsonResponse>;
+/**
+ * Update multiple shipping rates at once
+ *
+ * @param updates Array of objects containing rate ID and update data
+ * @returns Number of shipping rates updated
+ */
+export declare function bulkUpdate(updates: Array<{
+  id: number
+  data: ShippingRateUpdate
+}>): Promise<number>;
+/**
+ * Update shipping rates by zone
+ *
+ * @param zone The zone to update rates for
+ * @param data The update data to apply
+ * @returns Number of shipping rates updated
+ */
+export declare function updateByZone(zone: number, data: ShippingRateUpdate): Promise<number>;
+/**
+ * Update shipping rates by method
+ *
+ * @param method The shipping method to update rates for
+ * @param data The update data to apply
+ * @returns Number of shipping rates updated
+ */
+export declare function updateByMethod(method: string, data: ShippingRateUpdate): Promise<number>;
+declare type ShippingRateJsonResponse = ModelRow<typeof ShippingRate>;
+declare type ShippingRateUpdate = UpdateModelData<typeof ShippingRate>;

package/dist/src/shippings/shipping-zones/destroy.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Delete a shipping zone by ID
+ *
+ * @param id The ID of the shipping zone to delete
+ * @returns True if the shipping zone was deleted, false otherwise
+ */
+export declare function destroy(id: number): Promise<boolean>;
+/**
+ * Soft delete a shipping zone by ID (updates status to 'inactive')
+ *
+ * @param id The ID of the shipping zone to soft delete
+ * @returns True if the shipping zone was soft deleted, false otherwise
+ */
+export declare function softDelete(id: number): Promise<boolean>;
+/**
+ * Delete multiple shipping zones by ID
+ *
+ * @param ids Array of shipping zone IDs to delete
+ * @returns Number of shipping zones deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;
+/**
+ * Soft delete multiple shipping zones by ID (updates status to 'inactive')
+ *
+ * @param ids Array of shipping zone IDs to soft delete
+ * @returns Number of shipping zones soft deleted
+ */
+export declare function bulkSoftDelete(ids: number[]): Promise<number>;

package/dist/src/shippings/shipping-zones/fetch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Fetch all shipping zones
+ */
+export declare function fetchAll(): Promise<ShippingZoneJsonResponse[]>;
+/**
+ * Fetch a shipping zone by ID
+ */
+export declare function fetchById(id: number): Promise<ShippingZoneJsonResponse | undefined>;
+/**
+ * Format shipping zone options for dropdown menus or selectors
+ *
+ * @returns Array of formatted shipping zone options with id, name, and status
+ */
+export declare function formatZoneOptions(): Promise<{ id: number, name: string, status: string | string[], countries: string | undefined }[]>;
+/**
+ * Get active shipping zones
+ *
+ * @returns List of active shipping zones
+ */
+export declare function getActiveShippingZones(): Promise<ShippingZoneJsonResponse[]>;
+/**
+ * Get shipping zones by country code
+ *
+ * @param countryCode ISO country code
+ * @returns List of shipping zones covering the specified country
+ */
+export declare function getZonesByCountry(countryCode: string): Promise<ShippingZoneJsonResponse[]>;
+declare type ShippingZoneJsonResponse = ModelRow<typeof ShippingZone>;

package/dist/src/shippings/shipping-zones/index.d.ts

@@ -0,0 +1,23 @@
+export {
+  bulkDestroy,
+  bulkSoftDelete,
+  destroy,
+  softDelete,
+} from './destroy';
+export {
+  fetchAll,
+  fetchById,
+  formatZoneOptions,
+  getActiveShippingZones,
+  getZonesByCountry,
+} from './fetch';
+export {
+  bulkStore,
+  store,
+} from './store';
+export {
+  update,
+  updateCountries,
+  updateRegionsAndPostalCodes,
+  updateStatus,
+} from './update';

package/dist/src/shippings/shipping-zones/store.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Create a new shipping zone
+ *
+ * @param data The shipping zone data to store
+ * @returns The newly created shipping zone record
+ */
+export declare function store(data: NewShippingZone): Promise<ShippingZoneJsonResponse>;
+/**
+ * Create multiple shipping zones at once
+ *
+ * @param data Array of shipping zone data to store
+ * @returns Number of shipping zones created
+ */
+export declare function bulkStore(data: NewShippingZone[]): Promise<number>;
+// Import dependencies
+declare type ShippingZoneJsonResponse = ModelRow<typeof ShippingZone>;
+declare type NewShippingZone = NewModelData<typeof ShippingZone>;

package/dist/src/shippings/shipping-zones/update.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Update a shipping zone
+ *
+ * @param id The ID of the shipping zone
+ * @param data The shipping zone data to update
+ * @returns The updated shipping zone record
+ */
+export declare function update(id: number, data: ShippingZoneUpdate): Promise<ShippingZoneJsonResponse>;
+/**
+ * Update a shipping zone's status
+ *
+ * @param id The ID of the shipping zone
+ * @param status The new status
+ * @returns The updated shipping zone with the new status
+ */
+export declare function updateStatus(id: number, status: string | string[]): Promise<ShippingZoneJsonResponse>;
+/**
+ * Update countries for a shipping zone
+ *
+ * @param id The ID of the shipping zone
+ * @param countries The updated countries JSON string
+ * @returns The updated shipping zone
+ */
+export declare function updateCountries(id: number, countries: string): Promise<ShippingZoneJsonResponse>;
+/**
+ * Update regions and/or postal codes for a shipping zone
+ *
+ * @param id The ID of the shipping zone
+ * @param regions Optional updated regions JSON string
+ * @param postal_codes Optional updated postal codes JSON string
+ * @returns The updated shipping zone
+ */
+export declare function updateRegionsAndPostalCodes(id: number, regions?: string, postal_codes?: string): Promise<ShippingZoneJsonResponse>;
+declare type ShippingZoneJsonResponse = ModelRow<typeof ShippingZone>;
+declare type ShippingZoneUpdate = UpdateModelData<typeof ShippingZone>;

package/dist/src/tax/destroy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Delete a tax rate by ID
+ *
+ * @param id The ID of the tax rate to delete
+ * @returns True if the tax rate was deleted, false otherwise
+ */
+export declare function destroy(id: number): Promise<boolean>;
+/**
+ * Delete multiple tax rates by ID
+ *
+ * @param ids Array of tax rate IDs to delete
+ * @returns Number of tax rates deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;

package/dist/src/tax/fetch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Fetch a tax rate by ID
+ */
+export declare function fetchById(id: number): Promise<TaxRateJsonResponse | undefined>;
+/**
+ * Fetch all tax rates
+ */
+export declare function fetchAll(): Promise<TaxRateJsonResponse[]>;
+declare type TaxRateJsonResponse = ModelRow<typeof TaxRate>;

package/dist/src/tax/index.d.ts

@@ -0,0 +1,21 @@
+// Functions from destroy.ts
+export {
+  bulkDestroy,
+  destroy,
+} from './destroy';
+// Functions from fetch.ts
+export {
+  fetchAll,
+  fetchById,
+} from './fetch';
+// Functions from store.ts
+export {
+  bulkStore,
+  store,
+} from './store';
+// Functions from update.ts
+export {
+  update,
+  updateRate,
+  updateStatus,
+} from './update';

package/dist/src/tax/store.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Create a new tax rate
+ *
+ * @param data Tax rate data to store
+ * @returns The newly created tax rate record
+ */
+export declare function store(data: NewTaxRate): Promise<TaxRateJsonResponse>;
+/**
+ * Create multiple tax rates at once
+ *
+ * @param data Array of tax rate data to store
+ * @returns Number of tax rates created
+ */
+export declare function bulkStore(data: NewTaxRate[]): Promise<number>;
+declare type TaxRateJsonResponse = ModelRow<typeof TaxRate>;
+declare type NewTaxRate = NewModelData<typeof TaxRate>;

package/dist/src/tax/update.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Update a tax rate
+ *
+ * @param id The id of the tax rate to update
+ * @param data The tax rate data to update
+ * @returns The updated tax rate record
+ */
+export declare function update(id: number, data: TaxRateUpdate): Promise<TaxRateJsonResponse>;
+/**
+ * Update a tax rate's status
+ *
+ * @param id The ID of the tax rate
+ * @param status The new status
+ * @returns The updated tax rate with the new status
+ */
+export declare function updateStatus(id: number, status: 'active' | 'inactive'): Promise<TaxRateJsonResponse>;
+/**
+ * Update rate information for a tax rate
+ *
+ * @param id The ID of the tax rate
+ * @param rate The updated rate value
+ * @returns The updated tax rate
+ */
+export declare function updateRate(id: number, rate: number): Promise<TaxRateJsonResponse>;
+declare type TaxRateJsonResponse = ModelRow<typeof TaxRate>;
+declare type TaxRateUpdate = UpdateModelData<typeof TaxRate>;

package/dist/src/types.d.ts

@@ -0,0 +1,265 @@
+// Define the input for creating a customer
+export declare interface CreateCustomerInput {
+  name: string
+  email: string
+  phone: string
+  orders?: number
+  total_spent?: number
+  last_order?: string
+  status?: string
+  avatar?: string
+  user_id?: number
+}
+// Define the input for updating a customer
+export declare interface UpdateCustomerInput {
+  name?: string
+  email?: string
+  phone?: string
+  orders?: number
+  total_spent?: number
+  last_order?: string
+  status?: string
+  avatar?: string
+  user_id?: number
+}
+// Define the structure of an order item
+export declare interface OrderItem {
+  product_id: string
+  quantity: number
+  price: number
+  special_instructions?: string
+}
+// Type for status count
+export declare interface StatusCount {
+  status: string
+  count: number | string
+}
+// Type for order type count
+export declare interface OrderTypeCount {
+  order_type: string
+  count: number | string
+}
+// Type for the stats return value
+export declare interface OrderStats {
+  total: number
+  by_status: StatusCount[]
+  by_type: OrderTypeCount[]
+  recent: OrderJsonResponse[]
+  revenue: number
+}
+/**
+ * Represents a simplified order item structure with required properties for total calculation
+ */
+export declare interface OrderItemForCalculation {
+  price: number
+  quantity: number
+}
+/**
+ * Represents the totals calculated for an order
+ */
+export declare interface OrderTotals {
+  subtotal: number
+  tax_amount: number
+  total_amount: number
+}
+/**
+ * Represents statistics for a discount type
+ */
+export declare interface DiscountTypeCount {
+  discount_type: string | undefined
+  count: string | number | bigint
+}
+/**
+ * Represents comprehensive coupon statistics
+ */
+export declare interface CouponStats {
+  total: number
+  active: number
+  by_type: DiscountTypeCount[]
+  most_used: {
+    id: number | undefined
+    code: string | undefined
+    discount_type: string | undefined
+    discount_value: number | undefined
+    usage_count: number | undefined
+  }[]
+  upcoming: {
+    id: number | undefined
+    code: string | undefined
+    discount_type: string | undefined
+    discount_value: number | undefined
+    start_date: Date | string
+    end_date: Date | string
+  }[]
+}
+export declare interface OrderWithTotals {
+  order_items: OrderItemJsonResponse[] | []
+  id: number
+  customer_id: number
+  customer: CustomerJsonResponse | undefined
+  coupon_id: number
+  coupon: CouponJsonResponse | undefined
+  status: string
+  total_amount: number
+  tax_amount: number | undefined
+  discount_amount: number | undefined
+  delivery_fee: number | undefined
+  tip_amount: number | undefined
+  order_type: string
+  delivery_address: string | undefined
+  special_instructions: string | undefined
+  estimated_delivery_time: string | undefined
+  applied_coupon_id: string | undefined
+  uuid: string | undefined
+  created_at: Date | undefined
+  updated_at: Date | undefined
+  customer_name: string | null
+  customer_email: string | null
+  totalItems: number
+  totalPrice: number
+}
+export declare interface FetchGiftCardsOptions {
+  page?: number
+  limit?: number
+  search?: string
+  status?: string
+  is_active?: boolean
+  is_digital?: boolean
+  is_reloadable?: boolean
+  sortBy?: string
+  sortOrder?: 'asc' | 'desc'
+  purchaser_id?: string
+  from_date?: string
+  to_date?: string
+  min_balance?: number
+  max_balance?: number
+}
+declare interface BaseResponse {
+  paging: {
+    total_records: number
+    page: number
+    total_pages: number
+  }
+  next_cursor: number | null
+}
+export declare interface GiftCardResponse extends BaseResponse {
+  data: GiftCardJsonResponse[]
+}
+export declare interface GiftCardStats {
+  total: number
+  active: number
+  by_status: Array<{ status: string, count: number }>
+  by_balance: {
+    low: number
+    medium: number
+    high: number
+  }
+  expiring_soon: GiftCardJsonResponse[]
+  recently_used: GiftCardJsonResponse[]
+}
+export declare interface FetchReviewsOptions {
+  page?: number
+  limit?: number
+}
+export declare interface ReviewResponse extends BaseResponse {
+  data: ReviewJsonResponse[]
+}
+export declare interface ManufacturerResponse extends BaseResponse {
+  data: ManufacturerJsonResponse[]
+}
+export declare interface ReviewStats {
+  total: number
+  average_rating: number
+  rating_distribution: {
+    one_star: number
+    two_star: number
+    three_star: number
+    four_star: number
+    five_star: number
+  }
+  recent_reviews: ReviewJsonResponse[]
+}
+/**
+ * Represents comprehensive category statistics
+ */
+export declare interface CategoryStats {
+  total: number
+  active: number
+  root_categories: number
+  child_categories: number
+  with_images: number
+  recently_added: Array<any>
+  top_parent_categories: Array<{
+    id: string
+    name: string
+    child_count: number
+  }>
+}
+/**
+ * Options for fetching product manufacturers
+ */
+export declare interface FetchManufacturersOptions {
+  country?: string
+  featured?: boolean
+  search?: string
+}
+export declare interface FetchCouponsOptions {
+  page?: number
+  limit?: number
+  search?: string
+  is_active?: boolean
+  discount_type?: string
+  sortBy?: string
+  sortOrder?: 'asc' | 'desc'
+  product_id?: string
+  category_id?: string
+  from_date?: string
+  to_date?: string
+}
+/**
+ * Interface for coupon count statistics
+ */
+export declare interface CouponCountStats {
+  total: number
+  active: number
+  inactive: number
+}
+/**
+ * Interface for time-based coupon statistics
+ */
+export declare interface CouponTimeStats {
+  week: CouponCountStats
+  month: CouponCountStats
+  year: CouponCountStats
+  all_time: CouponCountStats
+}
+/**
+ * Interface for coupon redemption statistics
+ */
+export declare interface CouponRedemptionStats {
+  total: number
+  week: number
+  month: number
+  year: number
+  by_type: Record<string, number>
+}
+export declare interface FetchOrdersOptions {
+  page?: number
+  limit?: number
+  search?: string
+  status?: string
+  order_type?: string
+  customer_id?: number
+  sortBy?: string
+  sortOrder?: 'asc' | 'desc'
+  from_date?: string
+  to_date?: string
+}
+// Import the CustomerTable type from the ORM
+declare type CouponJsonResponse = ModelRow<typeof Coupon>;
+declare type CustomerJsonResponse = ModelRow<typeof Customer>;
+declare type GiftCardJsonResponse = ModelRow<typeof GiftCard>;
+declare type ManufacturerJsonResponse = ModelRow<typeof Manufacturer>;
+declare type OrderJsonResponse = ModelRow<typeof Order>;
+declare type OrderItemJsonResponse = ModelRow<typeof OrderItem>;
+declare type ReviewJsonResponse = ModelRow<typeof Review>;

package/dist/src/utils/typed-stats.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Run a typed aggregate query against a table.
+ *
+ * @example
+ * ```ts
+ * const stats = await aggregateStats('receipts', {
+ *   total: { kind: 'count' },
+ *   success: { kind: 'count', filter: { column: 'status', op: '=', value: 'success' } },
+ *   averageSize: { kind: 'avg', column: 'size' },
+ * }, qb => qb.where('timestamp', '>=', start).where('timestamp', '<=', end))
+ * // typeof stats: { total: number; success: number; averageSize: number }
+ * ```
+ */
+export declare function aggregateStats<TKeys extends string>(table: string, descriptors: Record<TKeys, StatsDescriptor>, applyWhere?: (qb: any) => any): Promise<Record<TKeys, number>>;
+/**
+ * Stats descriptors map: each key is the result-row alias; each value is
+ * a `{ kind, column, where? }` triple describing the aggregate to emit.
+ */
+export type StatsDescriptor = | { kind: 'count', column?: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'sum', column: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'avg', column: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'min', column: string, filter?: { column: string, op: string, value: unknown } }
+  | { kind: 'max', column: string, filter?: { column: string, op: string, value: unknown } }

package/dist/src/waitlists/index.d.ts

@@ -0,0 +1,12 @@
+import * as products from './products/index';
+import * as restaurant from './restaurant/index';
+declare const waitlists: WaitlistsNamespace;
+declare interface WaitlistsNamespace {
+  products: typeof products
+  restaurant: typeof restaurant
+}
+export {
+  products,
+  restaurant,
+};
+export default waitlists;

package/dist/src/waitlists/products/destroy.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Delete a waitlist product entry by ID
+ *
+ * @param id The ID of the waitlist product to delete
+ * @returns The deleted waitlist product record
+ */
+export declare function destroy(id: number): Promise<WaitlistProductJsonResponse | undefined>;
+/**
+ * Delete multiple waitlist product entries by their IDs
+ *
+ * @param ids Array of waitlist product IDs to delete
+ * @returns Number of waitlist products deleted
+ */
+export declare function bulkDestroy(ids: number[]): Promise<number>;
+declare type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>;

package/dist/src/waitlists/products/fetch.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Fetch a waitlist product by ID
+ */
+export declare function fetchById(id: number): Promise<WaitlistProductJsonResponse | undefined>;
+/**
+ * Fetch all waitlist products
+ */
+export declare function fetchAll(): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch the count of waitlist products grouped by source
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns An object containing the count for each source
+ */
+export declare function fetchCountBySource(startDate?: Date, _endDate?: Date): Promise<Record<string, number>>;
+/**
+ * Fetch the count of waitlist products for a specific date
+ * @param date The date to count entries for (defaults to today)
+ * @returns The count of entries for the specified date
+ */
+export declare function fetchCountByDate(date?: Date): Promise<number>;
+/**
+ * Fetch the count of waitlist products with a specific quantity
+ * @param quantity The quantity to count orders for
+ * @returns The count of orders with the specified quantity
+ */
+export declare function fetchCountByQuantity(quantity: number): Promise<number>;
+/**
+ * Fetch the count of waitlist products grouped by quantity
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns An object containing the count for each quantity
+ */
+export declare function fetchCountByAllQuantities(startDate?: Date, _endDate?: Date): Promise<Record<number, number>>;
+/**
+ * Fetch waitlist products between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products within the date range
+ */
+export declare function fetchBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch waitlist products that were notified between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products that were notified within the date range
+ */
+export declare function fetchNotifiedBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch waitlist products that were purchased between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products that were purchased within the date range
+ */
+export declare function fetchPurchasedBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch waitlist products that were cancelled between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns Array of waitlist products that were cancelled within the date range
+ */
+export declare function fetchCancelledBetweenDates(startDate: Date, endDate: Date): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch all waitlist products with waiting status
+ * @returns Array of waitlist products with waiting status
+ */
+export declare function fetchWaiting(): Promise<WaitlistProductJsonResponse[]>;
+/**
+ * Fetch the count of waitlist products by status
+ * @param status The status to filter by
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns The count of waitlist products with the specified status
+ */
+export declare function fetchCountByStatus(status: string, startDate?: Date, _endDate?: Date): Promise<number>;
+/**
+ * Fetch conversion rates for waitlist products
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns Object containing total conversion rate and breakdown by status
+ */
+export declare function fetchConversionRates(_startDate?: Date, _endDate?: Date): Promise<{
+    totalConversionRate: number
+    statusBreakdown: Record<string, { count: number, percentage: number }>
+  }>;
+/**
+ * Fetch the count of waitlist products between two dates
+ * @param startDate The start date of the range
+ * @param endDate The end date of the range
+ * @returns The count of waitlist products within the date range
+ */
+export declare function fetchCountBetweenDates(startDate: Date, endDate: Date): Promise<number>;
+/**
+ * Fetch the count of waitlist products grouped by date
+ * @param startDate Optional start date to filter by
+ * @param endDate Optional end date to filter by
+ * @returns An array of objects containing date and count
+ */
+export declare function fetchCountByDateGrouped(startDate?: Date, _endDate?: Date): Promise<{ date: string, count: number }[]>;
+declare type WaitlistProductJsonResponse = ModelRow<typeof WaitlistProduct>;