@stacksjs/commerce 0.70.380 → 0.71.1

package/dist/auctions/bids/fetch.d.ts

@@ -0,0 +1,21 @@
+import type { BidRow } from '../types';
+/**
+ * The bid currently winning a lot, or null when nobody has bid.
+ *
+ * There is exactly one `leading` row per open lot; `placeBid` maintains that
+ * invariant inside a transaction. `orderBy` is still spelled out so a stray
+ * second row (a hand-edited record, a restored backup) resolves to the highest
+ * one rather than to whatever the storage engine returns first.
+ */
+export declare function leadingBid(itemId: number): Promise<BidRow | null>;
+/** Every bid on a lot, newest first - the lot's activity feed. */
+export declare function bidsForItem(itemId: number): Promise<BidRow[]>;
+/** Every bid in an auction, oldest first - the settlement input. */
+export declare function bidsForAuction(auctionId: number): Promise<BidRow[]>;
+/**
+ * One bidder's bids across an auction, for the "your bids" panel a parent
+ * refreshes all night and for addressing outbid notices.
+ */
+export declare function bidsByBidder(auctionId: number, bidderEmail: string): Promise<BidRow[]>;
+/** Distinct bidders in an auction, for audience resolution on notifications. */
+export declare function biddersFor(auctionId: number): Promise<{ name: string, email: string }[]>;

package/dist/auctions/bids/index.d.ts

@@ -0,0 +1,2 @@
+export { bidsByBidder, bidsForAuction, bidsForItem, biddersFor, leadingBid } from './fetch';
+export { placeBid } from './place';

package/dist/auctions/bids/place.d.ts

@@ -0,0 +1,15 @@
+import type { BidRequest, PlacedBid } from '../types';
+/**
+ * Place a bid.
+ *
+ * The decision of what should happen is the pure engine's
+ * (`resolveBid`); everything here is the consequences: which rows change, what
+ * the lot's close time becomes, and who needs to be told. Keeping the two apart
+ * is what lets a bidding war be tested without a database and a database write
+ * be reviewed without re-deriving the auction rules.
+ *
+ * Every write runs in one transaction. A silent auction's worst failure mode is
+ * two `leading` bids on one lot - two people are told they won the same
+ * vacation package, and someone has to call one of them back.
+ */
+export declare function placeBid(request: BidRequest): Promise<PlacedBid>;

package/dist/auctions/engine/anti-snipe.d.ts

@@ -0,0 +1,22 @@
+import type { AuctionItemRow, AuctionRules } from '../types';
+/**
+ * Whether a bid landing at `now` should push this lot's close out, and to when.
+ *
+ * Sniping is the reason paper bid sheets get guarded by a parent with a
+ * stopwatch: a bid dropped in the last four seconds wins not because it was the
+ * highest anyone would pay, but because nobody could answer it. Extending the
+ * close whenever a bid lands inside the window converts the last minute back
+ * into an auction - the lot ends when bidding actually stops.
+ *
+ * `max_extensions` is the counterweight. Without it two determined bidders can
+ * hold one lot open indefinitely, and the gala staff cannot go home. Once a lot
+ * has been extended that many times it closes on schedule, and the bidding war
+ * is settled by whoever was ahead.
+ *
+ * Returns null when nothing should change.
+ */
+export declare function extendedCloseAt(item: Pick<AuctionItemRow, 'closes_at' | 'extension_count'>, closesAt: Date, rules: Pick<AuctionRules, 'antiSnipeMinutes' | 'extendOnBidWindowMinutes' | 'maxExtensions'>, now: Date): Date | null;
+/**
+ * The close time in force for a lot: its own override, else the auction's.
+ */
+export declare function effectiveCloseAt(item: Pick<AuctionItemRow, 'closes_at'>, auctionClosesAt: string | Date): Date;

package/dist/auctions/engine/increments.d.ts

@@ -0,0 +1,29 @@
+import type { AuctionItemRow, IncrementTier } from '../types';
+/**
+ * The increment that applies at `amount`.
+ *
+ * A lot's own `min_increment` overrides the ladder entirely - that is the
+ * escape hatch for the lot that wants round hundreds regardless of where the
+ * bidding starts.
+ */
+export declare function incrementFor(amount: number, ladder?: IncrementTier[], itemIncrement?: number | null): number;
+/**
+ * The smallest bid that can be placed on this lot right now.
+ *
+ * With no bids yet that is the starting bid itself, not the starting bid plus
+ * an increment: the first bidder should be able to type the number printed on
+ * the bid sheet.
+ */
+export declare function nextMinimumBid(item: Pick<AuctionItemRow, 'starting_bid' | 'min_increment'>, leadingAmount: number | null, ladder?: IncrementTier[]): number;
+/**
+ * The default increment ladder, in cents.
+ *
+ * A flat increment is wrong at both ends of a gala catalogue: $5 steps turn a
+ * $4,000 vacation package into a hundred-bid slog, and $100 steps price
+ * everyone out of the $60 class art project. The ladder is what a live
+ * auctioneer does by instinct - bigger money moves in bigger steps.
+ *
+ * Tiers are read in order and the first whose `upTo` exceeds the current
+ * amount wins, so they must stay sorted ascending with a single `null` last.
+ */
+export declare const DEFAULT_INCREMENT_LADDER: IncrementTier[];

package/dist/auctions/engine/index.d.ts

@@ -0,0 +1,14 @@
+export type { IncomingBid, LeadingBid } from './proxy';
+/**
+ * The pure auction engine.
+ *
+ * Nothing in here reads a clock, a config file or a database - every input is
+ * an argument. That is what lets the interesting rules (a proxy-bid war, a tie,
+ * an anti-snipe extension at the boundary, a reserve that was not met) be
+ * tested exhaustively in milliseconds, and it is why the persistence layer in
+ * `../bids` and `../auctions` stays as thin as it does.
+ */
+export { effectiveCloseAt, extendedCloseAt } from './anti-snipe';
+export { DEFAULT_INCREMENT_LADDER, incrementFor, nextMinimumBid } from './increments';
+export { resolveBid } from './proxy';
+export { determineWinner, settle } from './winners';

package/dist/auctions/engine/proxy.d.ts

@@ -0,0 +1,27 @@
+import type { AuctionItemRow, BidResolution, BidRow, IncrementTier } from '../types';
+/**
+ * Resolve one incoming bid against the standing leader.
+ *
+ * This is proxy bidding, the model every online auction has converged on: a
+ * bidder states a ceiling, and the house bids on their behalf in increments
+ * only as far as it must. The visible number is therefore almost never the
+ * ceiling - it is one increment above whatever the losing side was willing to
+ * pay, which is exactly the price discovery a paper bid sheet cannot do.
+ *
+ * The function is pure. It reads no clock, touches no database, and returns
+ * what *should* happen; `placeBid` is what makes it so. That split is what
+ * makes the interesting cases - a ceiling war, a tie, a bidder raising their
+ * own maximum - testable without a gala.
+ */
+export declare function resolveBid(item: Pick<AuctionItemRow, 'starting_bid' | 'min_increment' | 'buy_now_price'>, leader: LeadingBid, incoming: IncomingBid, ladder?: IncrementTier[]): BidResolution;
+/**
+ * The bid a challenger is offering, reduced to what the engine needs.
+ */
+export declare interface IncomingBid {
+  bidderEmail: string
+  bidderName: string
+  amount: number
+  maxAmount?: number | null
+}
+/** The current leader, or null when nobody has bid on the lot yet. */
+export type LeadingBid = Pick<BidRow, 'bidder_email' | 'bidder_name' | 'amount' | 'max_amount'> | null;

package/dist/auctions/engine/winners.d.ts

@@ -0,0 +1,22 @@
+import type { AuctionItemRow, AuctionSettlement, BidRow, ItemOutcome, PledgeRow } from '../types';
+/**
+ * Decide a single lot's outcome from its bids.
+ *
+ * Ordering is explicit rather than inherited from whatever the query returned:
+ * highest amount wins, and the earlier bid wins a tie. Two bids can legitimately
+ * share an amount when one bidder's proxy stepped up to exactly another's
+ * ceiling, and "first to commit" is the rule every bid sheet has always used.
+ */
+export declare function determineWinner(item: Pick<AuctionItemRow, 'id' | 'lot_number' | 'title' | 'reserve_price'>, bids: BidRow[]): ItemOutcome;
+/**
+ * Roll a set of lot outcomes and pledges into the number the school actually
+ * cares about.
+ *
+ * `valueDelta` compares winning bids against fair market value. It is the
+ * honest read on a catalogue: a positive delta means donors paid over the value
+ * of what they took home, which is the point of a benefit auction; a negative
+ * one means the room got bargains and the procurement committee has a
+ * conversation to have. Lots with no stated value are excluded rather than
+ * counted as zero, which would make every catalogue look like a loss.
+ */
+export declare function settle(items: Pick<AuctionItemRow, 'id' | 'fair_market_value'>[], outcomes: ItemOutcome[], pledges: PledgeRow[], opts: { auctionId: number, currency: string, goalAmount?: number | null }): AuctionSettlement;

package/dist/auctions/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Auctions.
+ *
+ * A benefit auction is commerce with the prices taken out: lots instead of
+ * products, bidders instead of customers, and a hard stop time instead of a
+ * checkout. It sits inside commerce because everything downstream of the
+ * hammer - what was sold, for how much, who owes it, what gets receipted - is
+ * ordinary commerce, and splitting the two would mean two vocabularies for one
+ * night's money.
+ *
+ * Three layers, deliberately separable:
+ *
+ *   engine/                 pure rules - increments, proxy bidding, anti-snipe, winners
+ *   lots/ bids/ pledges/    persistence on top of those rules
+ *   realtime, notifications how the room and the bidders find out
+ *
+ * Everything is in integer cents. See `./types` for the row shapes and why they
+ * are declared here rather than imported from the generated ORM types.
+ *
+ * Both spellings work, since a file that only places bids should not have to
+ * reach through two namespaces to do it:
+ *
+ *   commerce.auctions.placeBid(...)        flat, like every other commerce module
+ *   commerce.auctions.bids.placeBid(...)   grouped, when a file touches several layers
+ */
+export * from './bids/index';
+export * as bids from './bids/index';
+export * from './engine/index';
+export * as engine from './engine/index';
+export * from './lots/index';
+export * as lots from './lots/index';
+export * from './notifications';
+export * from './pledges/index';
+export * as pledges from './pledges/index';
+export * from './realtime';
+export * from './rules';
+export * from './types';

package/dist/auctions/lots/fetch.d.ts

@@ -0,0 +1,38 @@
+import { nextMinimumBid } from '../engine/increments';
+import type { AuctionItemRow, AuctionRow } from '../types';
+export declare function fetchAuction(id: number): Promise<AuctionRow | null>;
+/** The auction attached to an event, which is how the public page finds it. */
+export declare function fetchAuctionForEvent(eventId: number): Promise<AuctionRow | null>;
+export declare function fetchItems(auctionId: number): Promise<AuctionItemRow[]>;
+/**
+ * The catalogue as a bidder sees it: every lot with its current price, how
+ * contested it is, and the number to beat.
+ *
+ * One grouped query rather than a query per lot - a gala catalogue is a hundred
+ * lots and the page is opened by a few hundred phones at once, so the N+1 here
+ * would be the whole evening's load.
+ *
+ * Proxy ceilings are not selected. They must never reach a template.
+ */
+export declare function fetchCatalogue(auctionId: number): Promise<ItemWithBidState[]>;
+/**
+ * The live numbers behind the gala monitor: what the room has committed so far,
+ * against the goal.
+ */
+export declare function auctionTotals(auctionId: number): Promise<AuctionTotals>;
+export declare interface ItemWithBidState extends AuctionItemRow {
+  currentBid: number
+  bidCount: number
+  nextMinimumBid: number
+  leaderName: string | null
+}
+export declare interface AuctionTotals {
+  currentBidTotal: number
+  pledgeTotal: number
+  raised: number
+  goalAmount: number | null
+  bidCount: number
+  bidderCount: number
+  lotsOffered: number
+  lotsWithBids: number
+}

package/dist/auctions/lots/index.d.ts

@@ -0,0 +1,3 @@
+export type { AuctionTotals, ItemWithBidState } from './fetch';
+export { auctionTotals, fetchAuction, fetchAuctionForEvent, fetchCatalogue, fetchItems } from './fetch';
+export { closeAuction, closeDueItems, closeItem, closingSoon, openAuction, settleAuction } from './lifecycle';

package/dist/auctions/lots/lifecycle.d.ts

@@ -0,0 +1,42 @@
+import type { AuctionItemRow, AuctionRow, AuctionSettlement, ItemOutcome } from '../types';
+/**
+ * Open an auction for bidding.
+ *
+ * Lots go open with it. A lot held back deliberately (a live-auction headline
+ * item that is only listed for display) keeps whatever status it already has if
+ * it is not `draft`.
+ */
+export declare function openAuction(auctionId: number, now?: Date): Promise<AuctionRow | null>;
+/**
+ * Close one lot and decide it.
+ *
+ * Returns the outcome, or null when the lot was already resolved - which makes
+ * the function safe to call from a per-minute job that may overlap with an
+ * organizer clicking "close now" on the same lot.
+ */
+export declare function closeItem(item: AuctionItemRow, now?: Date): Promise<ItemOutcome | null>;
+/**
+ * Close every lot whose time is up, honouring anti-snipe extensions.
+ *
+ * This is what the per-minute job calls. It reads each lot's own close time
+ * (which a late bid may have pushed out seconds ago) rather than the auction's,
+ * so an extension always wins over the schedule.
+ */
+export declare function closeDueItems(auctionId: number, now?: Date): Promise<ItemOutcome[]>;
+/**
+ * Close the auction itself: resolve every remaining lot, then mark it closed.
+ */
+export declare function closeAuction(auctionId: number, now?: Date): Promise<ItemOutcome[]>;
+/**
+ * The settlement sheet: what every lot did, what the night raised, and how it
+ * measured against the goal and against fair market value.
+ *
+ * Read-only by default. Pass `{ markSettled: true }` once the school has
+ * actually invoiced, which is a decision a person makes, not a job.
+ */
+export declare function settleAuction(auctionId: number, opts?: { markSettled?: boolean, now?: Date }): Promise<AuctionSettlement | null>;
+/**
+ * Lots that close within `withinMinutes`, for the "closing soon" notice and for
+ * the organizer's watchlist of items still short of their fair market value.
+ */
+export declare function closingSoon(auctionId: number, withinMinutes: number, now?: Date): Promise<AuctionItemRow[]>;

package/dist/auctions/notifications.d.ts

@@ -0,0 +1,34 @@
+import type { AuctionItemRow, ItemOutcome, PlacedBid } from './types';
+/**
+ * Told to the bidder who just lost the lead.
+ *
+ * It names the lot and the number to beat, because the entire purpose of the
+ * message is to let someone re-bid from their phone in one tap. A notice that
+ * only says "you have been outbid" makes them go find the lot themselves, and
+ * most of them do not.
+ */
+export declare function outbidNotification(result: PlacedBid, currency?: string): AuctionNotification | null;
+/** Told to the winner of a lot once it closes. */
+export declare function winnerNotification(outcome: ItemOutcome, currency?: string): AuctionNotification | null;
+/**
+ * Told to everyone still leading a lot that is about to close, and to bidders
+ * watching one. Sent by the app's scheduler rather than inline, because "soon"
+ * is a decision about the school's evening, not about this bid.
+ */
+export declare function closingSoonNotification(item: AuctionItemRow, to: { name: string, email: string }, currentBid: number, currency?: string): AuctionNotification;
+/**
+ * Notification payloads for the three things a bidder must be told.
+ *
+ * These are builders, not senders. The auction package has no opinion about
+ * whether a school reaches parents by email, SMS or a row in their dashboard
+ * inbox - it knows what happened and phrases it; `@stacksjs/notifications`
+ * decides where it goes. That split is also what lets an app schedule a notice
+ * for later (the closing-soon nudge) rather than sending it inline.
+ */
+export declare interface AuctionNotification {
+  to: { name: string, email: string }
+  subject: string
+  body: string
+  type: 'outbid' | 'winner' | 'closing_soon'
+  data: Record<string, unknown>
+}

package/dist/auctions/pledges/index.d.ts

@@ -0,0 +1,27 @@
+import type { PledgeRow, PledgeStatus } from '../types';
+/**
+ * Record a fund-a-need pledge.
+ *
+ * Fund-a-need is the part of a benefit auction that is not an auction at all:
+ * the room is asked to give at fixed levels and nobody competes for anything.
+ * It shares the auction only for the tally board, which is why it lives beside
+ * bidding but never passes through the bidding engine.
+ */
+export declare function makePledge(request: PledgeRequest): Promise<PledgeRow>;
+/** Confirmed pledge money for an auction, in cents. */
+export declare function pledgeTotal(auctionId: number): Promise<number>;
+export declare function fetchPledges(auctionId: number): Promise<PledgeRow[]>;
+/**
+ * The tally board: how much each level has raised and how many gave at it.
+ * Levels are reported in descending gift size, which is the order they are read
+ * out in the room.
+ */
+export declare function pledgeLevels(auctionId: number): Promise<{ level: string, amount: number, count: number }[]>;
+export declare interface PledgeRequest {
+  auctionId: number
+  donorName: string
+  donorEmail: string
+  amount: number
+  level?: string | null
+  status?: PledgeStatus
+}

package/dist/auctions/realtime.d.ts

@@ -0,0 +1,20 @@
+import type { PlacedBid, PledgeRow } from './types';
+/**
+ * The channel an auction's live updates are published on. One channel per
+ * auction rather than per lot: a gala's bidding page shows the whole catalogue
+ * at once, and a phone in a gym should hold one socket, not forty.
+ */
+export declare function auctionChannel(auctionId: number): string;
+/**
+ * Publish a bid to everyone watching the auction.
+ *
+ * The payload carries the new price and the next minimum rather than a
+ * "refresh" signal, so a phone that is already on the lot updates in place. It
+ * deliberately does NOT carry proxy ceilings: the hidden maximum is the one
+ * number that must never leave the server, or the whole mechanism collapses.
+ */
+export declare function broadcastBid(result: PlacedBid): Promise<void>;
+/** Publish a fund-a-need pledge, for the running total on the tally board. */
+export declare function broadcastPledge(pledge: PledgeRow, runningTotal: number): Promise<void>;
+/** Publish a lot closing, so open bid sheets stop accepting input. */
+export declare function broadcastItemClosed(auctionId: number, itemId: number, outcome: { status: string, amount: number, winnerName?: string }): Promise<void>;

package/dist/auctions/rules.d.ts

@@ -0,0 +1,17 @@
+import type { AuctionRow, AuctionRules } from './types';
+/**
+ * The rules in force for one auction: the app's `config/auction.ts` defaults,
+ * with the auction row's own columns winning where they are set.
+ *
+ * Per-auction overrides matter because one school runs both a two-week online
+ * catalogue (long extensions, forgiving windows) and a ninety-minute in-room
+ * gala (two-minute extensions, or none at all) in the same season, and neither
+ * should have to be the global default.
+ */
+export declare function rulesFor(auction?: Pick<AuctionRow, 'anti_snipe_minutes' | 'extend_on_bid_window_minutes' | 'max_extensions'> | null): AuctionRules;
+/**
+ * The auction's currency, falling back to the storefront's. An auction
+ * inherits the currency the rest of commerce already runs in unless it says
+ * otherwise - a school does not raise money in a different one than it bills in.
+ */
+export declare function currencyFor(auction?: Pick<AuctionRow, 'currency'> | null): string;

package/dist/auctions/types.d.ts

@@ -0,0 +1,168 @@
+export declare interface AuctionRow {
+  id: number
+  uuid?: string
+  event_id: number
+  title: string
+  description?: string | null
+  status: AuctionStatus
+  currency: string
+  goal_amount?: number | null
+  opens_at: string | Date
+  closes_at: string | Date
+  anti_snipe_minutes: number
+  extend_on_bid_window_minutes: number
+  max_extensions: number
+}
+export declare interface AuctionItemRow {
+  id: number
+  uuid?: string
+  auction_id: number
+  lot_number: number
+  title: string
+  description?: string | null
+  image_url?: string | null
+  category?: string | null
+  donor_name?: string | null
+  fair_market_value?: number | null
+  starting_bid: number
+  min_increment?: number | null
+  buy_now_price?: number | null
+  reserve_price?: number | null
+  status: AuctionItemStatus
+  closes_at?: string | Date | null
+  extension_count: number
+}
+export declare interface BidRow {
+  id: number
+  uuid?: string
+  auction_item_id: number
+  auction_id: number
+  bidder_name: string
+  bidder_email: string
+  amount: number
+  max_amount?: number | null
+  status: BidStatus
+  placed_at: string | Date
+}
+export declare interface PledgeRow {
+  id: number
+  uuid?: string
+  auction_id: number
+  donor_name: string
+  donor_email: string
+  amount: number
+  level?: string | null
+  status: PledgeStatus
+  created_at?: string | Date
+}
+/**
+ * One rung of the increment ladder: below `upTo` cents, bids step by `step`
+ * cents. The last rung carries `upTo: null` and applies to everything above.
+ */
+export declare interface IncrementTier {
+  upTo: number | null
+  step: number
+}
+export declare interface AuctionRules {
+  increments: IncrementTier[]
+  antiSnipeMinutes: number
+  extendOnBidWindowMinutes: number
+  maxExtensions: number
+}
+/** What a caller passes to `placeBid`. */
+export declare interface BidRequest {
+  itemId: number
+  bidderName: string
+  bidderEmail: string
+  amount: number
+  maxAmount?: number | null
+  now?: Date
+}
+/**
+ * The result of resolving one bid against the current leader. This is what the
+ * pure engine returns; the persistence layer turns it into row writes and the
+ * caller turns it into notifications.
+ */
+export declare interface BidResolution {
+  accepted: boolean
+  reason?: BidRejectionReason
+  message?: string
+  leader?: {
+    bidderEmail: string
+    bidderName: string
+    amount: number
+    maxAmount: number | null
+    isChallenger: boolean
+  }
+  challengerAmount?: number
+  outbid?: {
+    bidderEmail: string
+    bidderName: string
+    amount: number
+  }
+  buyNow?: boolean
+  nextMinimumBid: number
+}
+export declare interface PlacedBid extends BidResolution {
+  bid?: BidRow
+  item?: AuctionItemRow
+  extendedTo?: Date
+}
+export declare interface ItemOutcome {
+  itemId: number
+  lotNumber: number
+  title: string
+  status: AuctionItemStatus
+  winningBidId?: number
+  winnerName?: string
+  winnerEmail?: string
+  amount: number
+  passedReason?: 'no_bids' | 'reserve_not_met'
+}
+export declare interface AuctionSettlement {
+  auctionId: number
+  currency: string
+  totalRaised: number
+  bidRevenue: number
+  pledgeRevenue: number
+  goalAmount: number | null
+  itemsSold: number
+  itemsPassed: number
+  sellThrough: number
+  valueDelta: number
+  outcomes: ItemOutcome[]
+}
+/**
+ * Auction types.
+ *
+ * Money is integer minor units (cents) everywhere - amounts, increments,
+ * ceilings, goals and totals alike. A silent auction adds thousands of bids
+ * together and then reports the number to a board of trustees; floats lose that
+ * argument. Formatting happens at the edge, never in this package.
+ *
+ * The row shapes below are declared here rather than imported from
+ * `@stacksjs/orm`'s generated model types on purpose. This package has to build
+ * and run against an app whose ORM types were generated before the auction
+ * models existed - which is every app that installs the published framework
+ * before the next release. The models under
+ * `storage/framework/defaults/app/Models/commerce/` are the source of the
+ * columns; these interfaces are the contract the engine reads them through.
+ */
+/** Where an auction is in its life. */
+export type AuctionStatus = 'draft' | 'preview' | 'open' | 'closed' | 'settled';
+/** Where a single lot is in its life. */
+export type AuctionItemStatus = 'open' | 'closed' | 'sold' | 'passed';
+/**
+ * Bid state. `leading` is the one bid per item that currently wins; every
+ * other live bid is `outbid`. Both resolve to `won` / `lost` at close.
+ * `invalid` is a bid an organizer retracted (a mis-keyed amount, a guest who
+ * bid on the wrong lot), kept for the audit trail rather than deleted.
+ */
+export type BidStatus = 'leading' | 'outbid' | 'won' | 'lost' | 'invalid';
+export type PledgeStatus = 'pending' | 'confirmed' | 'cancelled';
+export type BidRejectionReason = | 'auction_not_open'
+    | 'item_not_open'
+    | 'below_minimum'
+    | 'max_below_amount'
+    | 'already_leading'
+    | 'item_not_found';

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import * as auctions from './auctions/index';
 import * as coupons from './coupons/index';
 import * as customers from './customers/index';
 import * as devices from './devices/index';
@@ -13,6 +14,7 @@ import * as tax from './tax/index';
 import * as waitlists from './waitlists/index';
 export declare const commerce: CommerceNamespace;
 export declare interface CommerceNamespace {
+  auctions: AuctionsModule
   coupons: CouponsModule
   customers: CustomersModule
   errors: ErrorsModule
@@ -27,6 +29,7 @@ export declare interface CommerceNamespace {
   devices: DevicesModule
   receipts: ReceiptsModule
 }
+declare type AuctionsModule = typeof auctions;
 declare type CouponsModule = typeof coupons;
 declare type CustomersModule = typeof customers;
 declare type ErrorsModule = typeof errors;
@@ -41,6 +44,7 @@ declare type WaitlistsModule = typeof waitlists;
 declare type DevicesModule = typeof devices;
 declare type ReceiptsModule = typeof receipts;
 export {
+  auctions,
   coupons,
   customers,
   devices,