Skip to content
Adocommerce Kit

Generated API reference

Public TypeScript exports generated from every supported package entrypoint.

This page is generated from the public TypeScript entrypoints in the workspace. Run pnpm docs:build after changing an exported contract.

@adocommercekit/core

ADMIN_LIST_DEFAULT_LIMIT

Value

25

ADMIN_LIST_MAX_LIMIT

Value

100

ADMIN_TOTAL_CEILING

Value

Row ceiling for the total probe. Beyond it an admin list reports total: null and the UI renders “1–25 of many” — an exact count past a thousand rows is not information a human acts on, and an unbounded COUNT(*) over the 100k rehearsal dataset blows the §3.3 budget.

1000

AdminCursor

Interface

The decoded keyset position: the sort key of the last row of the previous page plus its id, which breaks ties deterministically.

AdminCursor
Public members
  • key: string
  • id: string

AdminKeysetWindow

Interface

AdminKeysetWindow
Public members
  • column: string
  • value: string | number | bigint
  • idColumn: string
  • id: string
  • direction: AdminSortDirection

AdminListPage

Interface

One page of an admin list query (ASPEC §3.3).

nextCursor is null on the last page. total is null whenever the filtered count is not obtainable from a single indexed COUNT(*); the UI renders “1–25 of many” in that case.

AdminListPage<T>
Public members
  • items: T[]
  • nextCursor: string | null
  • total: number | null

AdminSortDirection

Type

AdminSortDirection

boundedAdminTotal

Function

Turns a bounded primary-key probe into a total. Callers select at most ADMIN_TOTAL_CEILING + 1 keys; overflowing the ceiling means “many”.

(probe: readonly unknown[]) => number | null

CartNotActiveException

Class

CartNotActiveException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CartPricesChangedException

Class

CartPricesChangedException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

clampAdminLimit

Function

Clamps a caller-supplied page size into [1, 100], defaulting to 25.

(limit?: number) => number

COMMERCE_CAPABILITIES

Value

{ readonly deferredPayments: "payments.deferred.v1"; readonly cashOnDelivery: "payments.cod.v1"; readonly dynamicShippingQuotes: "shipping.dynamic_quotes.v1"; readonly fulfillmentProviders: "fulfillment.providers.v1"; }

COMMERCE_ERROR_STATUSES

Value

Readonly<Partial<Record<CommerceErrorCode, number | "varies">>>

CommerceCapability

Type

CommerceCapability

CommerceCapabilityRegistry

Class

Runtime capability lookup for independently installed commerce packages.

CommerceCapabilityRegistry
Public members
  • #capabilities: ReadonlySet<string>
  • supports: (capability: string) => boolean
  • require: (capability: string) => void
  • list: () => readonly string[]

CommerceConfigException

Class

CommerceConfigException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CommerceConfigInput

Interface

CommerceConfigInput
Public members
  • tablePrefix: string | undefined
  • channels: { default: string; }
  • currencies: { supported: CurrencyCode[]; default: CurrencyCode; exponents?: Partial<Record<CurrencyCode, 0 | 2 | 3>>; rounding?: Rounding; }
  • customers: { userModel: LazyImport<unknown> | null; userForeignKey?: string; }
  • carts: { tokenStrategy?: DriverFactory; abandonedAfterMinutes?: number; guardMaxLineQuantity?: number; }
  • pricing: { resolver?: DriverFactory; taxInclusivePricing?: boolean; }
  • images: { storage?: DriverFactory<ProductImageStorage>; maxBytes?: number; maxPerProduct?: number; } | undefined
  • inventory: { reservationTtlMinutes?: number; backorderPolicy?: "deny" | "allow" | "per_item"; allocation?: DriverFactory; }
  • payments: { default: string; methods: Record<string, DriverFactory>; captureMode?: "automatic" | "manual"; deferred?: { inventoryPolicy?: "reserve" | "commit"; }; codFee?: { amount: bigint | number | string; currency: string; label?: string; }; }
  • shipping: { calculators: Record<string, DriverFactory>; eligibility?: DriverFactory; quoteProviders?: Record<string, DriverFactory>; selectionSecret?: string; }
  • fulfillment: { providers?: Record<string, DriverFactory>; } | undefined
  • taxes: { calculator?: DriverFactory; addressResolver?: DriverFactory; }
  • orders: { numberGenerator?: DriverFactory; autoConfirm?: boolean; }
  • models: Partial<ModelRegistryOverrides> | undefined
  • events: { outbox?: { enabled: boolean; drainBatchSize?: number; }; } | undefined
  • jobs: { dispatcher?: "queue" | "inline"; } | undefined

CommerceErrorCode

Type

CommerceErrorCode

CommerceErrorDetails

Type

Readonly<Record<string, unknown>>

CommerceException

Class

CommerceException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CommerceForbiddenException

Class

Raised at the HTTP/Inertia boundary when the actor lacks the ability an admin endpoint declares. The ability name travels in the payload on purpose: it is frozen catalog vocabulary (ASPEC §3.2), not a secret, and the panel needs it to explain the denial.

CommerceForbiddenException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CommerceManager

Class

CommerceManager
Public members
  • #factoryCache: WeakMap<DriverFactory, Promise<unknown>>
  • #drivers: ResolvedCommerceDrivers | undefined
  • #bootPromise: Promise<ResolvedCommerceDrivers> | undefined
  • capabilities: CommerceCapabilityRegistry
  • app: ApplicationService
  • config: ResolvedCommerceConfig
  • isBooted: boolean
  • drivers: ResolvedCommerceDrivers
  • #resolve: (factory: DriverFactory) => Promise<unknown>
  • boot: (options: { queueAvailable: boolean; }) => Promise<ResolvedCommerceDrivers>
  • #resolveAll: (options: { queueAvailable: boolean; }) => Promise<ResolvedCommerceDrivers>
  • shutdown: () => Promise<void>

CompensationError

Interface

CompensationError
Public members
  • step: string
  • error: unknown

configure

Function

(command: Configure) => Promise<void>

configureMoney

Function

(options: { exponents?: Readonly<Partial<Record<string, 0 | 2 | 3>>>; rounding?: Rounding; }) => void

CurrencyCode

Type

string

currencyExponent

Function

(currency: CurrencyCode) => 0 | 2 | 3

CurrencyMismatchException

Class

CurrencyMismatchException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

decodeAdminCursor

Function

(cursor: string | undefined | null) => AdminCursor | null

defineConfig

Function

Normalize configuration without resolving imports or driver factories.

(input: CommerceConfigInput) => ResolvedCommerceConfig

defineStateMachine

Function

<S extends string, T extends string>(definition: { name: string; states: readonly S[]; initial: S; transitions: Record<T, { from: S | S[]; to: S; }>; }) => StateMachineDefinition<S, T>

DriverFactory

Type

DriverFactory<T>

encodeAdminCursor

Function

(cursor: AdminCursor) => string

IdempotencyConflictException

Class

IdempotencyConflictException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

InsufficientStockException

Class

InsufficientStockException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

keysetWindow

Function

Builds the WHERE fragment that resumes a keyset scan after window.

(sort, id) > (value, id) is expanded to sort > value OR (sort = value AND id > id) so the composite index on (sort, id) is usable on every dialect — row-value comparison is PostgreSQL-only.

(window: AdminKeysetWindow) => (builder: ChainableContract) => void

LineQuantityException

Class

LineQuantityException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

LucidStateMachinePersistence

Class

LucidStateMachinePersistence<S, T, Trx>
Public members
  • #stateColumn: string
  • #auditTable: string
  • #subjectType: string
  • database: StateMachineDatabase<Trx>
  • subjectTable: string
  • buffer: (name: string, payload: Readonly<Record<string, unknown>>, trx: Trx) => void | Promise<void>
  • transaction: <R>(callback: (trx: Trx) => Promise<R>) => Promise<R>
  • conditionalUpdate: (subjectId: string, from: S, to: S, trx: Trx) => Promise<boolean>
  • insertAudit: (audit: StateTransitionAudit<S, T>, trx: Trx) => Promise<void>
  • bufferEvent: (name: string, payload: Readonly<Record<string, unknown>>, trx: Trx) => void | Promise<void>

ModelRegistryOverrides

Interface

ModelRegistryOverrides
Public members
  • channel: LazyImport<unknown>
  • product: LazyImport<unknown>
  • productImage: LazyImport<unknown>
  • productOption: LazyImport<unknown>
  • productOptionValue: LazyImport<unknown>
  • productVariant: LazyImport<unknown>
  • category: LazyImport<unknown>
  • priceList: LazyImport<unknown>
  • price: LazyImport<unknown>
  • customerGroup: LazyImport<unknown>
  • customer: LazyImport<unknown>
  • address: LazyImport<unknown>
  • cart: LazyImport<unknown>
  • cartLine: LazyImport<unknown>
  • cartAdjustment: LazyImport<unknown>
  • shippingMethod: LazyImport<unknown>
  • taxZone: LazyImport<unknown>
  • taxRate: LazyImport<unknown>
  • taxCategory: LazyImport<unknown>
  • order: LazyImport<unknown>
  • orderLine: LazyImport<unknown>
  • paymentIntent: LazyImport<unknown>
  • payment: LazyImport<unknown>
  • paymentInstruction: LazyImport<unknown>
  • shipment: LazyImport<unknown>
  • stockLocation: LazyImport<unknown>
  • inventoryItem: LazyImport<unknown>
  • inventoryLevel: LazyImport<unknown>
  • reservation: LazyImport<unknown>
  • orderAdjustment: LazyImport<unknown>
  • shipmentLine: LazyImport<unknown>
  • refund: LazyImport<unknown>
  • webhookEvent: LazyImport<unknown>
  • idempotencyKey: LazyImport<unknown>
  • eventOutbox: LazyImport<unknown>

Money

Class

Money
Public members
  • amount: bigint
  • currency: string
  • assertCurrency: (other: Money) => void
  • add: (other: Money) => Money
  • subtract: (other: Money) => Money
  • multiply: (factor: number | bigint, rounding?: Rounding) => Money
  • percentage: (basisPoints: number, rounding?: Rounding) => Money
  • negate: () => Money
  • allocate: (ratios: number[]) => Money[]
  • split: (parts: number) => Money[]
  • isZero: () => boolean
  • isNegative: () => boolean
  • equals: (other: Money) => boolean
  • compare: (other: Money) => -1 | 0 | 1
  • toDecimal: () => string
  • toJSON: () => { amount: string; currency: CurrencyCode; }

moneyColumn

Function

Maps one Money property to a <prefix>_amount BIGINT and <prefix>_currency CHAR(3) column pair.

(options?: { columnPrefix?: string; }) => PropertyDecorator

paginateAdminRows

Function

Slices one extra row off the end of an over-fetched result set and turns it into the next cursor. Callers request limit + 1 rows.

<T>(rows: T[], limit: number, cursorOf: (row: T) => AdminCursor) => { items: T[]; nextCursor: string | null; }

PaymentDeclineCode

Type

PaymentDeclineCode

PaymentDeclinedException

Class

PaymentDeclinedException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

PaymentProviderException

Class

PaymentProviderException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

PriceNotFoundException

Class

PriceNotFoundException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

ProductInUseException

Class

ProductInUseException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

renderCommerceException

Function

(error: CommerceException) => { error: { details?: Readonly<Record<string, unknown>> | undefined; code: CommerceErrorCode; message: string; }; }

ResolvedCommerceConfig

Interface

ResolvedCommerceConfig
Public members
  • tablePrefix: string
  • channels: { default: string; }
  • currencies: { supported: CurrencyCode[]; default: CurrencyCode; exponents: Readonly<Partial<Record<CurrencyCode, 0 | 2 | 3>>>; rounding: Rounding; }
  • customers: { userModel: LazyImport<unknown> | null; userForeignKey: string; }
  • carts: { tokenStrategy: DriverFactory; abandonedAfterMinutes: number; guardMaxLineQuantity: number; }
  • pricing: { resolver: DriverFactory; taxInclusivePricing: boolean; }
  • images: { storage?: DriverFactory<ProductImageStorage>; maxBytes: number; maxPerProduct: number; }
  • inventory: { reservationTtlMinutes: number; backorderPolicy: "deny" | "allow" | "per_item"; allocation?: DriverFactory; }
  • payments: { default: string; methods: Readonly<Record<string, DriverFactory>>; captureMode: "automatic" | "manual"; deferred: { inventoryPolicy: "reserve" | "commit"; }; codFee?: { amount: bigint | number | string; currency: string; label: string; }; }
  • shipping: { calculators: Readonly<Record<string, DriverFactory>>; eligibility?: DriverFactory; quoteProviders: Readonly<Record<string, DriverFactory>>; selectionSecret?: string; }
  • fulfillment: { providers: Readonly<Record<string, DriverFactory>>; }
  • taxes: { calculator: DriverFactory; addressResolver?: DriverFactory; }
  • orders: { numberGenerator?: DriverFactory; autoConfirm: boolean; }
  • models: Readonly<Partial<ModelRegistryOverrides>>
  • events: { outbox: { enabled: boolean; drainBatchSize: number; }; }
  • jobs: { dispatcher: "queue" | "inline"; automatic: boolean; }

Rounding

Type

Rounding

ShippingNotEligibleException

Class

ShippingNotEligibleException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

sqlDateTime

Function

(value: DateTime) => string

StateMachineRunner

Class

StateMachineRunner<S, T, Trx>
Public members
  • #guards: Map<T, TransitionGuard<S, T, Trx>[]>
  • #beforeHooks: Map<T, TransitionHook<S, T, Trx>[]>
  • #afterHooks: Map<T, TransitionHook<S, T, Trx>[]>
  • definition: StateMachineDefinition<S, T>
  • persistence: StateMachinePersistence<S, T, Trx>
  • can: (subject: Stateful<S>, transition: T) => boolean
  • registerGuard: (transition: T, guard: TransitionGuard<S, T, Trx>) => void
  • registerHook: (transition: T, hook: "before" | "after", handler: TransitionHook<S, T, Trx>) => void
  • apply: (subject: Stateful<S>, transition: T, context?: TransitionContext, options?: { trx?: Trx; actor?: string | undefined; }) => Promise<void>

StateTransitionException

Class

StateTransitionException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

stubsRoot

Value

Path to the root directory where the stubs are stored. We use this path within commands and the configure hook

string

validateCommerceConfig

Function

(config: ResolvedCommerceConfig, options: { queueAvailable: boolean; }) => void

WebhookSignatureException

Class

WebhookSignatureException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

Workflow

Class

Workflow<C>
Public members
  • #steps: WorkflowStep<C>[]
  • name: string
  • transactionRunner: WorkflowTransactionRunner<C> | undefined
  • logger: WorkflowLogger
  • steps: readonly WorkflowStep<C>[]
  • insertBefore: (step: string, newStep: WorkflowStep<C>) => Workflow<C>
  • insertAfter: (step: string, newStep: WorkflowStep<C>) => Workflow<C>
  • replace: (step: string, newStep: WorkflowStep<C>) => Workflow<C>
  • remove: (step: string) => Workflow<C>
  • run: (context: C) => Promise<void>
  • #contextRunner: (context: C) => WorkflowTransactionRunner<C>
  • #index: (name: string) => number
  • #assertUniqueNames: () => void

WorkflowFailedException

Class

WorkflowFailedException
Public members
  • compensationErrors: readonly CompensationError[]
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

@adocommercekit/core/services/main

AdminCheckoutFunnelStage

Type

AdminCheckoutFunnelStage

AdminCheckoutStage

Type

AdminCheckoutStage

AdminCustomerFilter

Interface

AdminCustomerFilter
Public members
  • search: string | undefined
  • groupId: string | undefined
  • sort: AdminCustomerSort | undefined
  • direction: AdminSortDirection | undefined
  • cursor: string | undefined
  • limit: number | undefined

AdminCustomerSort

Type

AdminCustomerSort

AdminInventoryLevelFilter

Interface

AdminInventoryLevelFilter
Public members
  • locationId: string | undefined
  • belowReorderPoint: boolean | undefined
  • sort: AdminInventoryLevelSort | undefined
  • direction: AdminSortDirection | undefined
  • cursor: string | undefined
  • limit: number | undefined

AdminInventoryLevelSort

Type

AdminInventoryLevelSort

AdminLowStockLevel

Type

AdminLowStockLevel

AdminMetricsInterval

Type

AdminMetricsInterval

AdminMetricsPeriod

Type

The dashboard result shapes are declared as type aliases rather than interfaces on purpose. TypeScript gives an object type alias an implicit index signature but never an interface, so only an alias is assignable to the JSON-serializable constraint inertia.defer() places on a deferred prop. These values are pure JSON by construction, and the declaration should say so.

AdminMetricsPeriod

AdminMetricsRange

Interface

AdminMetricsRange
Public members
  • channelId: string | undefined
  • currency: string
  • from: DateTime<boolean>
  • to: DateTime<boolean>

AdminMetricsService

Class

Read-only dashboard aggregates (ASPEC §3.4).

Every method is scoped to exactly one currency: the dashboard renders one currency at a time and there is no cross-currency aggregation, mirroring the ledger’s integrity rule. Money crosses the wire as stringified minor units so no precision is lost.

Revenue is derived from the payment ledger (captures minus succeeded refunds), never from order totals, so the dashboard reconciles with the ledger exports to the cent.

AdminMetricsService
Public members
  • db: Database
  • config: ResolvedCommerceConfig
  • dialect: "postgres" | "mysql" | "sqlite"
  • table: (suffix: string) => string
  • bucketSql: (column: string, interval: AdminMetricsInterval) => string
  • bucketKeys: (range: AdminMetricsRange, interval: AdminMetricsInterval) => string[]
  • capturedPayments: (range: AdminMetricsRange) => DatabaseQueryBuilderContract<any>
  • succeededRefunds: (range: AdminMetricsRange) => DatabaseQueryBuilderContract<any>
  • placedOrders: (range: AdminMetricsRange) => DatabaseQueryBuilderContract<any>
  • summary: (range: AdminMetricsRange) => Promise<AdminMetricsSummary>
  • period: (ordersPlaced: number, grossRevenue: string, refundTotal: string, activeCarts: number) => AdminMetricsPeriod
  • revenueSeries: (interval: AdminMetricsInterval, range: AdminMetricsRange) => Promise<AdminRevenueBucket[]>
  • ordersByStatus: (range: AdminMetricsRange) => Promise<AdminOrdersByStatus[]>
  • topProducts: (range: AdminMetricsRange, limit?: number) => Promise<AdminTopProduct[]>
  • paymentMethodMix: (range: AdminMetricsRange) => Promise<AdminPaymentMethodSlice[]>
  • checkoutFunnel: (range: AdminMetricsRange) => Promise<AdminCheckoutFunnelStage[]>
  • lowStock: (range: AdminMetricsRange, limit?: number) => Promise<AdminLowStockLevel[]>

AdminMetricsSummary

Type

AdminMetricsSummary

AdminOrderFilter

Interface

AdminOrderFilter
Public members
  • status: OrderState[] | undefined
  • channelId: string | undefined
  • customerId: string | undefined
  • numberPrefix: string | undefined
  • email: string | undefined
  • placedAfter: DateTime<boolean> | undefined
  • placedBefore: DateTime<boolean> | undefined
  • sort: AdminOrderSort | undefined
  • direction: AdminSortDirection | undefined
  • cursor: string | undefined
  • limit: number | undefined

AdminOrdersByStatus

Type

AdminOrdersByStatus

AdminOrderSort

Type

AdminOrderSort

AdminPaymentFilter

Interface

AdminPaymentFilter
Public members
  • state: PaymentState[] | undefined
  • provider: string | undefined
  • orderId: string | undefined
  • sort: AdminPaymentSort | undefined
  • direction: AdminSortDirection | undefined
  • cursor: string | undefined
  • limit: number | undefined

AdminPaymentMethodSlice

Type

AdminPaymentMethodSlice

AdminPaymentSort

Type

AdminPaymentSort

AdminProductFilter

Interface

AdminProductFilter
Public members
  • status: ProductStatus[] | undefined
  • categoryId: string | undefined
  • search: string | undefined
  • sort: AdminProductSort | undefined
  • direction: AdminSortDirection | undefined
  • cursor: string | undefined
  • limit: number | undefined

AdminProductSort

Type

AdminProductSort

AdminRevenueBucket

Type

AdminRevenueBucket

AdminTopProduct

Type

AdminTopProduct

cartesianProduct

Function

<T>(axes: readonly (readonly T[])[]) => T[][]

CartService

Class

CartService
Public members
  • #processors: CartProcessor[]
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • tokenStrategy: CartTokenStrategy
  • priceResolver: PriceResolver
  • events: TransactionalEventEmitter | undefined
  • registerProcessor: (processor: CartProcessor) => void
  • findOrCreateFromContext: (ctx: HttpContext) => Promise<Cart>
  • create: (input: { channelId: string; currency: string; token?: string; }, options?: MutationOptions) => Promise<Cart>
  • findByToken: (token: string) => Promise<Cart | null>
  • addLine: (cart: Cart, input: { variantId: string; quantity: number; }, options?: MutationOptions) => Promise<Cart>
  • updateLineQuantity: (cart: Cart, lineId: string, quantity: number, options?: MutationOptions) => Promise<Cart>
  • removeLine: (cart: Cart, lineId: string, options?: MutationOptions) => Promise<Cart>
  • setEmail: (cart: Cart, email: string, options?: MutationOptions) => Promise<Cart>
  • setAddresses: (cart: Cart, input: { shipping?: AddressInput; billing?: AddressInput; }, options?: MutationOptions) => Promise<Cart>
  • setShippingMethod: (cart: Cart, methodId: string, options?: MutationOptions) => Promise<Cart>
  • assignCustomer: (cart: Cart, customerId: string, options?: MutationOptions) => Promise<Cart>
  • mergeCarts: (target: Cart, source: Cart, options?: MutationOptions) => Promise<Cart>
  • recalculate: (cart: Cart, options?: MutationOptions) => Promise<Cart>
  • totals: (cart: Cart) => CartTotals
  • updateCart: (cart: Cart, values: Partial<Cart>, options?: MutationOptions) => Promise<Cart>
  • lockActiveCart: (id: string, trx: TransactionClientContract) => Promise<Cart>
  • channelContext: (cart: Cart, trx: TransactionClientContract) => Promise<ChannelContext>
  • load: (id: string, trx?: TransactionClientContract) => Promise<Cart>
  • assertQuantity: (quantity: number) => void

cartSnapshot

Function

(cart: Parameters<CartProcessor["process"]>[0], ctx: RecalculationContext) => CartSnapshot

CatalogService

Class

CatalogService
Public members
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • productImages: ProductImageService
  • events: TransactionalEventEmitter | undefined
  • listProducts: (filter?: AdminProductFilter) => Promise<AdminListPage<Product>>
  • createProduct: (data: CreateProductInput, options?: MutationOptions) => Promise<Product>
  • updateProduct: (id: string, data: UpdateProductInput, options?: MutationOptions) => Promise<Product>
  • archiveProduct: (id: string, options?: MutationOptions) => Promise<Product>
  • deleteProduct: (id: string, options?: MutationOptions) => Promise<void>
  • addOption: (productId: string, input: { name: string; values: string[]; }, options?: MutationOptions) => Promise<ProductOption>
  • generateVariants: (productId: string, options?: MutationOptions) => Promise<ProductVariant[]>
  • createCategory: (data: { name: string; slug: string; parentId?: string | null; position?: number; }, options?: MutationOptions) => Promise<Category>
  • categoryDescendants: (categoryId: string) => Promise<Category[]>
  • listCategories: () => Promise<Category[]>
  • updateCategory: (id: string, data: { name?: string; slug?: string; parentId?: string | null; position?: number; }, options?: MutationOptions) => Promise<Category>
  • deleteCategory: (id: string, options?: MutationOptions) => Promise<void>
  • syncProductCategories: (productId: string, categoryIds: readonly string[], options?: MutationOptions) => Promise<void>
  • assignCategory: (productId: string, categoryId: string, options?: MutationOptions) => Promise<void>
  • findBySlug: (slug: string, ctx: ChannelContext) => Promise<Product | null>

ChannelService

Class

ChannelService
Public members
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • events: TransactionalEventEmitter | undefined
  • create: (data: CreateChannelInput, options?: MutationOptions) => Promise<Channel>
  • findByCode: (code: string) => Promise<Channel | null>
  • list: () => Promise<Channel[]>
  • resolve: (channelCode?: string, currency?: string) => Promise<ChannelContext>
  • bootstrapDefault: (options?: MutationOptions) => Promise<Channel>

chargeableWeight

Function

(parcel: Parcel, volumetricDivisor?: number) => number

CheckoutService

Class

CheckoutService
Public members
  • registry: ModelRegistry
  • workflow: PlaceOrderWorkflow
  • idempotency: IdempotencyService
  • inventory: InventoryService
  • payments: PaymentService
  • place: (cart: Cart, input: PlaceOrderInput) => Promise<Order>
  • reconcileStuck: (before?: DateTime<true>) => Promise<number>
  • loadOrder: (id: string) => Promise<Order>

CommerceManager

Class

CommerceManager
Public members
  • #factoryCache: WeakMap<DriverFactory, Promise<unknown>>
  • #drivers: ResolvedCommerceDrivers | undefined
  • #bootPromise: Promise<ResolvedCommerceDrivers> | undefined
  • capabilities: CommerceCapabilityRegistry
  • app: ApplicationService
  • config: ResolvedCommerceConfig
  • isBooted: boolean
  • drivers: ResolvedCommerceDrivers
  • #resolve: (factory: DriverFactory) => Promise<unknown>
  • boot: (options: { queueAvailable: boolean; }) => Promise<ResolvedCommerceDrivers>
  • #resolveAll: (options: { queueAvailable: boolean; }) => Promise<ResolvedCommerceDrivers>
  • shutdown: () => Promise<void>

CreateChannelInput

Interface

CreateChannelInput
Public members
  • code: string
  • name: string
  • defaultCurrency: string
  • supportedCurrencies: string[]
  • isDefault: boolean | undefined
  • metadata: Record<string, unknown> | undefined

CreateCustomerInput

Interface

CreateCustomerInput
Public members
  • email: string | null | undefined
  • firstName: string | undefined
  • lastName: string | undefined
  • phone: string | undefined
  • userId: string | undefined
  • groupId: string | undefined
  • metadata: Record<string, unknown> | undefined

CustomerExportAuthorizationError

Class

CustomerExportAuthorizationError
Public members
  • code: "CUSTOMER_EXPORT_UNAUTHORIZED"
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

CustomerPortabilityExport

Interface

CustomerPortabilityExport
Public members
  • schemaVersion: "commerce.customer-export.v1"
  • exportedAt: string
  • customer: { id: string; email: string | null; firstName: string | null; lastName: string | null; phone: string | null; metadata: Record<string, unknown> | null; createdAt: string; }
  • addresses: { firstName: string; lastName: string; company: string | null; line1: string; line2: string | null; city: string; region: string | null; postalCode: string | null; countryCode: string; phone: string | null; metadata: Record<string, unknown> | null; }[]
  • orders: { number: string; state: string; currency: string; email: string; shippingAddress: AddressInput; billingAddress: AddressInput; totals: { subtotal: string; shipping: string; tax: string; discount: string; grand: string; }; placedAt: string; lines: Array<{ productName: string; variantName: string | null; sku: string | null; quantity: number; unitPrice: string; fulfilledQuantity: number; refundedQuantity: number; }>; adjustments: Array<{ sourceType: string; label: string; amount: string; included: boolean; metadata: Record<string, unknown> | null; }>; shipments: Array<{ state: string; carrier: string | null; trackingNumber: string | null; }>; }[]

CustomerService

Class

CustomerService
Public members
  • db: Database
  • registry: ModelRegistry
  • events: TransactionalEventEmitter | undefined
  • list: (filter?: AdminCustomerFilter) => Promise<AdminListPage<Customer>>
  • create: (data: CreateCustomerInput, options?: MutationOptions) => Promise<Customer>
  • createGroup: (data: { code: string; name: string; }, options?: MutationOptions) => Promise<CustomerGroup>
  • addAddress: (customerId: string, data: AddressInput & { isDefaultShipping?: boolean; isDefaultBilling?: boolean; }, options?: MutationOptions) => Promise<Address>
  • findByUserId: (userId: string) => Promise<Customer | null>
  • export: (customerId: string, authorize: (customer: Customer) => boolean | Promise<boolean>) => Promise<CustomerPortabilityExport>
  • anonymize: (customerId: string, options?: MutationOptions) => Promise<Customer>

EncryptionPort

Interface

EncryptionPort
Public members
  • encrypt: (value: unknown) => string | Promise<string>
  • decrypt: ((value: string) => unknown | Promise<unknown>) | undefined

EventOutboxService

Class

EventOutboxService
Public members
  • #consumers: Set<OutboxConsumer>
  • db: Database
  • table: string
  • batchSize: number
  • registerConsumer: (consumer: OutboxConsumer) => () => void
  • write: (name: string, payload: unknown, transaction: TransactionHookClient) => Promise<void>
  • drain: (now?: DateTime<true>) => Promise<{ sent: number; failed: number; }>

FulfillmentService

Class

FulfillmentService
Public members
  • db: Database
  • registry: ModelRegistry
  • providers: Readonly<Record<string, FulfillmentProvider>>
  • inventory: InventoryService
  • orders: OrderService
  • events: TransactionalEventEmitter | undefined
  • create: (order: Order, lines: Array<{ orderLineId: string; quantity: number; }>, options?: MutationOptions) => Promise<Shipment>
  • prepare: (shipment: Shipment, providerCode: string, input?: { service?: string; insurance?: { amount: Money; }; idempotencyKey?: string; }) => Promise<Shipment>
  • handoff: (shipment: Shipment, options?: MutationOptions) => Promise<Shipment>
  • recordStatus: (shipment: Shipment, state: "delivered" | "delivery_failed" | "returned", input?: { occurredAt?: DateTime; eventId?: string; }, options?: MutationOptions) => Promise<Shipment>
  • preparationInput: (shipment: Shipment) => Promise<{ order: Order; parcels: Parcel[]; }>

IdempotencyService

Class

IdempotencyService
Public members
  • db: Database
  • registry: ModelRegistry
  • hash: (request: unknown) => string
  • claim: (scope: string, key: string, request: unknown) => Promise<IdempotencyClaim>
  • complete: (record: IdempotencyKey, response: unknown, options?: MutationOptions) => Promise<void>
  • abandon: (record: IdempotencyKey) => Promise<void>
  • purgeExpired: (now?: DateTime<true>) => Promise<number>
  • canonicalJson: (value: unknown) => string
  • normalize: (value: unknown) => unknown
  • isUniqueViolation: (error: unknown) => boolean

InventoryService

Class

InventoryService
Public members
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • allocation: StockAllocationStrategy
  • events: TransactionalEventEmitter | undefined
  • listLevels: (filter?: AdminInventoryLevelFilter) => Promise<AdminListPage<InventoryLevel>>
  • createLocation: (input: { code: string; name: string; address?: AddressInput; isDefault?: boolean; }, options?: MutationOptions) => Promise<StockLocation>
  • createItem: (input: { variantId: string; tracked?: boolean; backorderable?: boolean; }, options?: MutationOptions) => Promise<InventoryItem>
  • setLevel: (itemId: string, locationId: string, onHand: number, options?: MutationOptions) => Promise<InventoryLevel>
  • availability: (variantId: string, locationId?: string) => Promise<{ onHand: number; reserved: number; available: number; }>
  • adjustOnHand: (itemId: string, locationId: string, delta: number, reason: string, options?: MutationOptions) => Promise<InventoryLevel>
  • reserveForCart: (cart: Cart, options?: MutationOptions) => Promise<Reservation[]>
  • releaseCartReservations: (cart: Cart, options?: MutationOptions) => Promise<void>
  • consumeReservations: (cart: Cart, _order: unknown, options?: MutationOptions) => Promise<void>
  • bindReservationExpiry: (cart: Cart, expiresAt: DateTime, options?: MutationOptions) => Promise<void>
  • compensateDeferred: (cart: Cart, policy: "reserve" | "commit", options?: MutationOptions) => Promise<void>
  • settleDeferred: (cart: Cart, order: unknown, policy: "reserve" | "commit", options?: MutationOptions) => Promise<void>
  • restockReturnedShipment: (shipment: Shipment, options?: MutationOptions) => Promise<void>
  • expireStale: (now?: DateTime<true>) => Promise<number>
  • auditReservedTotals: () => Promise<Array<{ levelId: string; stored: number; actual: number; }>>
  • releaseReservation: (reservation: Reservation, trx: TransactionClientContract) => Promise<void>

OrderService

Class

OrderService
Public members
  • machine: StateMachineRunner<OrderState, OrderTransition, TransactionClientContract>
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • inventory: InventoryService
  • numberGenerator: OrderNumberGenerator | undefined
  • events: TransactionalEventEmitter | undefined
  • findByNumber: (number: string) => Promise<Order | null>
  • list: (filter?: AdminOrderFilter) => Promise<AdminListPage<Order>>
  • createFromCart: (cart: Cart, options?: MutationOptions) => Promise<Order>
  • transition: (order: Order, transition: OrderTransition, context?: TransitionContext, options?: MutationOptions) => Promise<Order>
  • cancel: (order: Order, reason: string, options?: MutationOptions) => Promise<Order>
  • addAdjustment: (order: Order, draft: AdjustmentDraft, options?: MutationOptions) => Promise<Order>
  • recomputeTotals: (orderId: string, trx: TransactionClientContract) => Promise<void>
  • nextSequentialNumber: (trx: TransactionClientContract) => Promise<string>
  • transitionEvent: (order: Order, transition: OrderTransition, context: Readonly<Record<string, unknown>>) => OrderConfirmed | OrderCanceled | OrderFulfilled | OrderCompleted | undefined
  • load: (id: string, trx?: TransactionClientContract) => Promise<Order>

OutboxConsumer

Type

OutboxConsumer

PaymentService

Class

PaymentService
Public members
  • machine: StateMachineRunner<PaymentIntentState, "authorize" | "require_action" | "pend" | "capture" | "fail" | "settle" | "void" | "refund_partial" | "refund" | "expire" | "review", TransactionClientContract>
  • db: Database
  • registry: ModelRegistry
  • providers: Readonly<Record<string, PaymentProvider>>
  • encryption: EncryptionPort
  • config: ResolvedCommerceConfig
  • inventory: InventoryService
  • orders: OrderService
  • events: TransactionalEventEmitter | undefined
  • provider: (code: string) => PaymentProvider
  • paymentMethodCodes: (providerCode: string) => string[]
  • listPayments: (filter?: AdminPaymentFilter) => Promise<AdminListPage<Payment>>
  • createIntent: (subject: Cart | Order, method: string, options?: MutationOptions & { idempotencyKey?: string; }) => Promise<PaymentIntent>
  • confirm: (intent: PaymentIntent, input: { token?: string; }, options?: MutationOptions & { idempotencyKey?: string; }) => Promise<PaymentIntent>
  • paymentForIntent: (intentId: string, trx?: TransactionClientContract) => Promise<Payment | null>
  • settle: (intent: PaymentIntent, input: { amount: Money; reference?: string; occurredAt?: DateTime; providerStatus?: string; raw?: unknown; }, options?: MutationOptions) => Promise<PaymentIntent>
  • settleCod: (order: Order, amount: Money, reference: string, options?: MutationOptions) => Promise<PaymentIntent>
  • rejectDeferred: (intent: PaymentIntent, reason: string, options?: MutationOptions & { idempotencyKey?: string; }) => Promise<PaymentIntent>
  • expirePending: (now?: DateTime<true>) => Promise<number>
  • expireOne: (intentId: string, now: DateTime, providerStatus: string, occurredAt?: DateTime) => Promise<void>
  • markReview: (intent: PaymentIntent, order: Order | null, reason: string, trx: TransactionClientContract) => Promise<PaymentIntent>
  • capture: (payment: Payment, amount?: Money, options?: MutationOptions & { idempotencyKey?: string; }) => Promise<Payment>
  • refund: (payment: Payment, input: { amount?: Money; reason?: string; }, options?: MutationOptions & { idempotencyKey?: string; }) => Promise<Refund>
  • void: (intent: PaymentIntent, options?: MutationOptions & { idempotencyKey?: string; }) => Promise<PaymentIntent>
  • ingestWebhook: (providerCode: string, raw: RawWebhookRequest) => Promise<WebhookIngestResult>
  • applyWebhookEvent: (providerCode: string, event: NormalizedPaymentEvent, trx: TransactionClientContract) => Promise<void>
  • ensureAuthorizedPayment: (intent: PaymentIntent, raw: unknown, trx: TransactionClientContract) => Promise<Payment>
  • normalizedWebhookPayload: (event: NormalizedPaymentEvent | { type: "unhandled"; providerEventId: string; raw?: unknown; }) => Record<string, unknown>
  • intent: (id: string, trx?: TransactionClientContract) => Promise<PaymentIntent>
  • isUniqueViolation: (error: unknown) => boolean

PlaceOrderContext

Interface

PlaceOrderContext
Public members
  • cart: Cart
  • input: PlaceOrderInput
  • idempotency: IdempotencyKey
  • trx: TransactionClientContract | undefined
  • order: Order | undefined
  • intent: PaymentIntent | undefined
  • payment: Payment | undefined
  • transaction: (callback: (context: PlaceOrderContext) => Promise<void>) => Promise<void>

PlaceOrderWorkflow

Class

PlaceOrderWorkflow
Public members
  • #workflow: Workflow<PlaceOrderContext>
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • carts: CartService
  • inventory: InventoryService
  • orders: OrderService
  • payments: PaymentService
  • shipping: ShippingService
  • idempotency: IdempotencyService
  • events: TransactionalEventEmitter
  • steps: readonly WorkflowStep<PlaceOrderContext>[]
  • insertBefore: (step: string, newStep: WorkflowStep<PlaceOrderContext>) => PlaceOrderWorkflow
  • insertAfter: (step: string, newStep: WorkflowStep<PlaceOrderContext>) => PlaceOrderWorkflow
  • replace: (step: string, newStep: WorkflowStep<PlaceOrderContext>) => PlaceOrderWorkflow
  • remove: (step: string) => PlaceOrderWorkflow
  • run: (context: PlaceOrderContext) => Promise<void>
  • finalizeExisting: (cart: Cart, order: Order, intent: PaymentIntent) => Promise<Order>
  • releaseCartReservations: (cart: Cart) => Promise<void>
  • defaultSteps: () => WorkflowStep<PlaceOrderContext>[]
  • validateCart: (context: PlaceOrderContext) => Promise<void>
  • lockCart: (context: PlaceOrderContext) => Promise<void>
  • createPayment: (context: PlaceOrderContext) => Promise<void>
  • finalize: (context: PlaceOrderContext, completeIdempotency: boolean) => Promise<void>
  • emit: (context: PlaceOrderContext) => Promise<void>
  • context: (cart: Cart, input: PlaceOrderInput, idempotency: IdempotencyKey) => PlaceOrderContext

PricingService

Class

PricingService
Public members
  • db: Database
  • registry: ModelRegistry
  • createPriceList: (data: { name: string; channelId?: string | null; customerGroupId?: string | null; priority?: number; startsAt?: DateTime | null; endsAt?: DateTime | null; isDefault?: boolean; }, options?: MutationOptions) => Promise<PriceList>
  • createPrice: (data: { priceListId: string; variantId: string; unitPrice: Money; minQuantity?: number; }, options?: MutationOptions) => Promise<Price>

ProductImageService

Class

ProductImageService
Public members
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • storage: ProductImageStorage | undefined
  • events: TransactionalEventEmitter | undefined
  • upload: (productId: string, input: ProductImageUpload, options?: MutationOptions) => Promise<ProductImage>
  • update: (productId: string, imageId: string, input: UpdateProductImageInput, options?: MutationOptions) => Promise<ProductImage>
  • reorder: (productId: string, imageIds: string[], options?: MutationOptions) => Promise<ProductImage[]>
  • remove: (productId: string, imageId: string, options?: MutationOptions) => Promise<void>
  • scheduleProductDeletion: (productId: string, trx: TransactionClientContract) => Promise<void>
  • inspect: (input: ProductImageUpload) => { extension: "jpg" | "png" | "webp"; mimeType: "image/jpeg" | "image/png" | "image/webp"; width: number; height: number; }
  • requireStorage: () => ProductImageStorage
  • find: (productId: string, imageId: string, trx: TransactionClientContract) => Promise<ProductImage>
  • assertVariants: (productId: string, input: string[], trx: TransactionClientContract) => Promise<string[]>
  • scheduleStorageDeletion: (image: Pick<ProductImage, "disk" | "key">, trx: TransactionClientContract) => void
  • normalizePositions: (productId: string, trx: TransactionClientContract) => Promise<void>

ProductImageUpload

Interface

ProductImageUpload
Public members
  • contents: Uint8Array<ArrayBufferLike>
  • clientName: string
  • contentType: string | undefined

ResolvedCommerceDrivers

Interface

ResolvedCommerceDrivers
Public members
  • cartTokenStrategy: CartTokenStrategy
  • priceResolver: PriceResolver
  • productImageStorage: ProductImageStorage | undefined
  • paymentMethods: Readonly<Record<string, PaymentProvider>>
  • shippingCalculators: Readonly<Record<string, ShippingCalculator>>
  • shippingQuoteProviders: Readonly<Record<string, DynamicShippingQuoteProvider>>
  • fulfillmentProviders: Readonly<Record<string, FulfillmentProvider>>
  • inventoryAllocation: StockAllocationStrategy | undefined
  • shippingEligibility: ShippingEligibility | undefined
  • taxCalculator: TaxCalculator
  • taxAddressResolver: unknown
  • orderNumberGenerator: OrderNumberGenerator | undefined

ShippingCartProcessor

Class

ShippingCartProcessor
Public members
  • name: "shipping"
  • position: 500
  • shipping: ShippingService
  • process: (cart: Parameters<CartProcessor["process"]>[0], ctx: RecalculationContext) => Promise<AdjustmentDraft[]>

ShippingService

Class

ShippingService
Public members
  • db: Database
  • registry: ModelRegistry
  • calculators: Readonly<Record<string, ShippingCalculator>>
  • eligibility: ShippingEligibility
  • quoteProviders: Readonly<Record<string, DynamicShippingQuoteProvider>>
  • selectionSecret: string | undefined
  • createMethod: (data: { code: string; name: string; calculator: string; calculatorConfig: Record<string, unknown>; channelId?: string | null; position?: number; enabled?: boolean; }, options?: MutationOptions) => Promise<ShippingMethod>
  • eligibleMethods: (snapshot: CartSnapshot, channelId: string, trx?: TransactionClientContract) => Promise<ShippingMethod[]>
  • calculator: (code: string) => ShippingCalculator
  • quote: (cart: Cart, providerCode: string, options?: { cod?: { amount: Money; }; insurance?: { amount: Money; }; }) => Promise<ShippingQuote[]>
  • selectQuote: (cart: Cart, selectionToken: string, options?: MutationOptions) => Promise<Cart>
  • assertSelectedQuote: (cart: Cart, suppliedToken?: string, trx?: TransactionClientContract) => Promise<QuoteSelectionPayload | null>
  • verifySelection: (cart: Cart, token: string, trx?: TransactionClientContract) => Promise<QuoteSelectionPayload>
  • quoteRequest: (cart: Cart, options: { cod?: { amount: Money; }; insurance?: { amount: Money; }; }, trx?: TransactionClientContract) => Promise<ShippingQuoteRequest>
  • signSelection: (payload: QuoteSelectionPayload) => string
  • decodeSelection: (token: string) => QuoteSelectionPayload

TaxCartProcessor

Class

TaxCartProcessor
Public members
  • name: "tax"
  • position: 1000
  • config: ResolvedCommerceConfig
  • calculator: TaxCalculator
  • process: (cart: Parameters<CartProcessor["process"]>[0], ctx: RecalculationContext) => Promise<AdjustmentDraft[]>

TaxService

Class

TaxService
Public members
  • db: Database
  • registry: ModelRegistry
  • createCategory: (data: { code: string; name: string; }, options?: MutationOptions) => Promise<TaxCategory>
  • createZone: (data: { name: string; countryCodes: string[]; regionPattern?: string | null; postalPattern?: string | null; }, options?: MutationOptions) => Promise<TaxZone>
  • createRate: (data: { zoneId: string; taxCategoryId?: string | null; name: string; rateBp: number; }, options?: MutationOptions) => Promise<TaxRate>

UpdateProductImageInput

Interface

UpdateProductImageInput
Public members
  • altText: string | null | undefined
  • variantIds: string[] | undefined

@adocommercekit/core/models

Address

Class

Address
Public members
  • customerId: string | null
  • firstName: string
  • lastName: string
  • company: string | null
  • line1: string
  • line2: string | null
  • city: string
  • region: string | null
  • postalCode: string | null
  • countryCode: string
  • phone: string | null
  • isDefaultShipping: boolean
  • isDefaultBilling: boolean
  • customer: BelongsTo<typeof Customer>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Address
  • useConnection: (connection: string) => Address
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Address>>, allowExtraProperties?: boolean) => Address
  • merge: (value: Partial<ModelAttributes<Address>>, allowExtraProperties?: boolean) => Address
  • isDirty: (fields?: "createdAt" | "updatedAt" | "customerId" | "firstName" | "lastName" | "company" | "line1" | "line2" | "city" | "region" | "postalCode" | "countryCode" | "phone" | "isDefaultShipping" | "isDefaultBilling" | "id" | "metadata" | ("createdAt" | "updatedAt" | "customerId" | "firstName" | "lastName" | "company" | "line1" | "line2" | "city" | "region" | "postalCode" | "countryCode" | "phone" | "isDefaultShipping" | "isDefaultBilling" | "id" | "metadata" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Address
  • save: () => Promise<Address>
  • saveQuietly: () => Promise<Address>
  • lockForUpdate: <T>(callback: (user: Address) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Address>
  • load: LucidRowPreload<Address>
  • loadOnce: LucidRowPreloadOnce<Address>
  • preload: LucidRowPreload<Address>
  • loadAggregate: <Self extends Address, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Address, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Address>>(relation: Name) => NonNullable<Address[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Address[Name] & {})["client"] : never

BaseCommerceModel

Class

BaseCommerceModel
Public members
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => BaseCommerceModel
  • useConnection: (connection: string) => BaseCommerceModel
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<BaseCommerceModel>>, allowExtraProperties?: boolean) => BaseCommerceModel
  • merge: (value: Partial<ModelAttributes<BaseCommerceModel>>, allowExtraProperties?: boolean) => BaseCommerceModel
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | ("createdAt" | "updatedAt" | "id" | "metadata" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => BaseCommerceModel
  • save: () => Promise<BaseCommerceModel>
  • saveQuietly: () => Promise<BaseCommerceModel>
  • lockForUpdate: <T>(callback: (user: BaseCommerceModel) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<BaseCommerceModel>
  • load: LucidRowPreload<BaseCommerceModel>
  • loadOnce: LucidRowPreloadOnce<BaseCommerceModel>
  • preload: LucidRowPreload<BaseCommerceModel>
  • loadAggregate: <Self extends BaseCommerceModel, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends BaseCommerceModel, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<BaseCommerceModel[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & BaseCommerceModel[Name] & {})["client"] : never

Cart

Class

Cart
Public members
  • token: string
  • channelId: string
  • currency: string
  • customerId: string | null
  • email: string | null
  • status: CartStatus
  • shippingAddress: AddressInput | null
  • billingAddress: AddressInput | null
  • shippingMethodId: string | null
  • completedOrderId: string | null
  • shippingQuoteToken: string | null
  • shippingQuoteExpiresAt: DateTime<boolean> | null
  • subtotalAmount: bigint
  • shippingTotalAmount: bigint
  • taxTotalAmount: bigint
  • discountTotalAmount: bigint
  • grandTotalAmount: bigint
  • lastActivityAt: DateTime<boolean>
  • channel: BelongsTo<typeof Channel>
  • customer: BelongsTo<typeof Customer>
  • shippingMethod: BelongsTo<typeof ShippingMethod>
  • lines: HasMany<typeof CartLine>
  • adjustments: HasMany<typeof CartAdjustment>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Cart
  • useConnection: (connection: string) => Cart
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Cart>>, allowExtraProperties?: boolean) => Cart
  • merge: (value: Partial<ModelAttributes<Cart>>, allowExtraProperties?: boolean) => Cart
  • isDirty: (fields?: "createdAt" | "email" | "updatedAt" | "customerId" | "id" | "metadata" | "token" | "channelId" | "currency" | "status" | "shippingAddress" | "billingAddress" | "shippingMethodId" | "completedOrderId" | "shippingQuoteToken" | "shippingQuoteExpiresAt" | "subtotalAmount" | "shippingTotalAmount" | "taxTotalAmount" | "discountTotalAmount" | "grandTotalAmount" | "lastActivityAt" | ("createdAt" | "email" | "updatedAt" | "customerId" | "id" | "metadata" | "token" | "channelId" | "currency" | "status" | "shippingAddress" | "billingAddress" | "shippingMethodId" | "completedOrderId" | "shippingQuoteToken" | "shippingQuoteExpiresAt" | "subtotalAmount" | "shippingTotalAmount" | "taxTotalAmount" | "discountTotalAmount" | "grandTotalAmount" | "lastActivityAt" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Cart
  • save: () => Promise<Cart>
  • saveQuietly: () => Promise<Cart>
  • lockForUpdate: <T>(callback: (user: Cart) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Cart>
  • load: LucidRowPreload<Cart>
  • loadOnce: LucidRowPreloadOnce<Cart>
  • preload: LucidRowPreload<Cart>
  • loadAggregate: <Self extends Cart, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Cart, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Cart>>(relation: Name) => NonNullable<Cart[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Cart[Name] & {})["client"] : never

CartAdjustment

Class

CartAdjustment
Public members
  • cartId: string
  • cartLineId: string | null
  • sourceType: string
  • sourceId: string | null
  • label: string
  • amount: Money
  • amountAmount: bigint
  • amountCurrency: string
  • included: boolean
  • eligible: boolean
  • position: number
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => CartAdjustment
  • useConnection: (connection: string) => CartAdjustment
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<CartAdjustment>>, allowExtraProperties?: boolean) => CartAdjustment
  • merge: (value: Partial<ModelAttributes<CartAdjustment>>, allowExtraProperties?: boolean) => CartAdjustment
  • isDirty: (fields?: "createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "position" | "cartId" | "cartLineId" | "sourceType" | "sourceId" | "label" | "amountAmount" | "amountCurrency" | "included" | "eligible" | ("createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "position" | "cartId" | "cartLineId" | "sourceType" | "sourceId" | "label" | "amountAmount" | "amountCurrency" | "included" | "eligible" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => CartAdjustment
  • save: () => Promise<CartAdjustment>
  • saveQuietly: () => Promise<CartAdjustment>
  • lockForUpdate: <T>(callback: (user: CartAdjustment) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<CartAdjustment>
  • load: LucidRowPreload<CartAdjustment>
  • loadOnce: LucidRowPreloadOnce<CartAdjustment>
  • preload: LucidRowPreload<CartAdjustment>
  • loadAggregate: <Self extends CartAdjustment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends CartAdjustment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<CartAdjustment[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & CartAdjustment[Name] & {})["client"] : never

CartLine

Class

CartLine
Public members
  • cartId: string
  • variantId: string
  • quantity: number
  • unitPrice: Money
  • unitPriceAmount: bigint
  • unitPriceCurrency: string
  • cart: BelongsTo<typeof Cart>
  • variant: BelongsTo<typeof ProductVariant>
  • adjustments: HasMany<typeof CartAdjustment>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => CartLine
  • useConnection: (connection: string) => CartLine
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<CartLine>>, allowExtraProperties?: boolean) => CartLine
  • merge: (value: Partial<ModelAttributes<CartLine>>, allowExtraProperties?: boolean) => CartLine
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "cartId" | "variantId" | "quantity" | "unitPrice" | "unitPriceAmount" | "unitPriceCurrency" | ("createdAt" | "updatedAt" | "id" | "metadata" | "cartId" | "variantId" | "quantity" | "unitPrice" | "unitPriceAmount" | "unitPriceCurrency" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => CartLine
  • save: () => Promise<CartLine>
  • saveQuietly: () => Promise<CartLine>
  • lockForUpdate: <T>(callback: (user: CartLine) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<CartLine>
  • load: LucidRowPreload<CartLine>
  • loadOnce: LucidRowPreloadOnce<CartLine>
  • preload: LucidRowPreload<CartLine>
  • loadAggregate: <Self extends CartLine, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends CartLine, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<CartLine>>(relation: Name) => NonNullable<CartLine[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & CartLine[Name] & {})["client"] : never

CartStatus

Type

CartStatus

Category

Class

Category
Public members
  • parentId: string | null
  • name: string
  • slug: string
  • path: string
  • position: number
  • parent: BelongsTo<typeof Category>
  • children: HasMany<typeof Category>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Category
  • useConnection: (connection: string) => Category
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Category>>, allowExtraProperties?: boolean) => Category
  • merge: (value: Partial<ModelAttributes<Category>>, allowExtraProperties?: boolean) => Category
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "position" | "parentId" | "slug" | "path" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "position" | "parentId" | "slug" | "path" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Category
  • save: () => Promise<Category>
  • saveQuietly: () => Promise<Category>
  • lockForUpdate: <T>(callback: (user: Category) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Category>
  • load: LucidRowPreload<Category>
  • loadOnce: LucidRowPreloadOnce<Category>
  • preload: LucidRowPreload<Category>
  • loadAggregate: <Self extends Category, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Category, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Category>>(relation: Name) => NonNullable<Category[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Category[Name] & {})["client"] : never

Channel

Class

Channel
Public members
  • code: string
  • name: string
  • defaultCurrency: string
  • supportedCurrencies: string[]
  • isDefault: boolean
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Channel
  • useConnection: (connection: string) => Channel
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Channel>>, allowExtraProperties?: boolean) => Channel
  • merge: (value: Partial<ModelAttributes<Channel>>, allowExtraProperties?: boolean) => Channel
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | "defaultCurrency" | "supportedCurrencies" | "isDefault" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | "defaultCurrency" | "supportedCurrencies" | "isDefault" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Channel
  • save: () => Promise<Channel>
  • saveQuietly: () => Promise<Channel>
  • lockForUpdate: <T>(callback: (user: Channel) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Channel>
  • load: LucidRowPreload<Channel>
  • loadOnce: LucidRowPreloadOnce<Channel>
  • preload: LucidRowPreload<Channel>
  • loadAggregate: <Self extends Channel, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Channel, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<Channel[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Channel[Name] & {})["client"] : never

configureBaseCommerceModel

Function

(config: Pick<ResolvedCommerceConfig, "tablePrefix">) => void

Customer

Class

Customer
Public members
  • email: string | null
  • firstName: string | null
  • lastName: string | null
  • phone: string | null
  • userId: string | null
  • groupId: string | null
  • group: BelongsTo<typeof CustomerGroup>
  • addresses: HasMany<typeof Address>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Customer
  • useConnection: (connection: string) => Customer
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Customer>>, allowExtraProperties?: boolean) => Customer
  • merge: (value: Partial<ModelAttributes<Customer>>, allowExtraProperties?: boolean) => Customer
  • isDirty: (fields?: "createdAt" | "email" | "updatedAt" | "firstName" | "lastName" | "phone" | "id" | "metadata" | "userId" | "groupId" | ("createdAt" | "email" | "updatedAt" | "firstName" | "lastName" | "phone" | "id" | "metadata" | "userId" | "groupId" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Customer
  • save: () => Promise<Customer>
  • saveQuietly: () => Promise<Customer>
  • lockForUpdate: <T>(callback: (user: Customer) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Customer>
  • load: LucidRowPreload<Customer>
  • loadOnce: LucidRowPreloadOnce<Customer>
  • preload: LucidRowPreload<Customer>
  • loadAggregate: <Self extends Customer, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Customer, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Customer>>(relation: Name) => NonNullable<Customer[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Customer[Name] & {})["client"] : never

CustomerGroup

Class

CustomerGroup
Public members
  • code: string
  • name: string
  • customers: HasMany<typeof Customer>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => CustomerGroup
  • useConnection: (connection: string) => CustomerGroup
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<CustomerGroup>>, allowExtraProperties?: boolean) => CustomerGroup
  • merge: (value: Partial<ModelAttributes<CustomerGroup>>, allowExtraProperties?: boolean) => CustomerGroup
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => CustomerGroup
  • save: () => Promise<CustomerGroup>
  • saveQuietly: () => Promise<CustomerGroup>
  • lockForUpdate: <T>(callback: (user: CustomerGroup) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<CustomerGroup>
  • load: LucidRowPreload<CustomerGroup>
  • loadOnce: LucidRowPreloadOnce<CustomerGroup>
  • preload: LucidRowPreload<CustomerGroup>
  • loadAggregate: <Self extends CustomerGroup, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends CustomerGroup, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<CustomerGroup>>(relation: Name) => NonNullable<CustomerGroup[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & CustomerGroup[Name] & {})["client"] : never

EventOutbox

Class

EventOutbox
Public members
  • id: string
  • eventName: string
  • payload: unknown
  • status: OutboxStatus
  • attempts: number
  • availableAt: DateTime<boolean>
  • createdAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => EventOutbox
  • useConnection: (connection: string) => EventOutbox
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<EventOutbox>>, allowExtraProperties?: boolean) => EventOutbox
  • merge: (value: Partial<ModelAttributes<EventOutbox>>, allowExtraProperties?: boolean) => EventOutbox
  • isDirty: (fields?: "createdAt" | "id" | "status" | "eventName" | "payload" | "attempts" | "availableAt" | ("createdAt" | "id" | "status" | "eventName" | "payload" | "attempts" | "availableAt" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => EventOutbox
  • save: () => Promise<EventOutbox>
  • saveQuietly: () => Promise<EventOutbox>
  • lockForUpdate: <T>(callback: (user: EventOutbox) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<EventOutbox>
  • load: LucidRowPreload<EventOutbox>
  • loadOnce: LucidRowPreloadOnce<EventOutbox>
  • preload: LucidRowPreload<EventOutbox>
  • loadAggregate: <Self extends EventOutbox, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends EventOutbox, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<EventOutbox[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & EventOutbox[Name] & {})["client"] : never

getModelRegistry

Function

() => ModelRegistry

IdempotencyKey

Class

IdempotencyKey
Public members
  • key: string
  • scope: string
  • requestHash: string
  • status: IdempotencyStatus
  • response: unknown
  • expiresAt: DateTime<boolean>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => IdempotencyKey
  • useConnection: (connection: string) => IdempotencyKey
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<IdempotencyKey>>, allowExtraProperties?: boolean) => IdempotencyKey
  • merge: (value: Partial<ModelAttributes<IdempotencyKey>>, allowExtraProperties?: boolean) => IdempotencyKey
  • isDirty: (fields?: "createdAt" | "updatedAt" | "key" | "id" | "metadata" | "status" | "scope" | "requestHash" | "response" | "expiresAt" | ("createdAt" | "updatedAt" | "key" | "id" | "metadata" | "status" | "scope" | "requestHash" | "response" | "expiresAt" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => IdempotencyKey
  • save: () => Promise<IdempotencyKey>
  • saveQuietly: () => Promise<IdempotencyKey>
  • lockForUpdate: <T>(callback: (user: IdempotencyKey) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<IdempotencyKey>
  • load: LucidRowPreload<IdempotencyKey>
  • loadOnce: LucidRowPreloadOnce<IdempotencyKey>
  • preload: LucidRowPreload<IdempotencyKey>
  • loadAggregate: <Self extends IdempotencyKey, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends IdempotencyKey, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<IdempotencyKey[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & IdempotencyKey[Name] & {})["client"] : never

IdempotencyStatus

Type

IdempotencyStatus

InventoryItem

Class

InventoryItem
Public members
  • variantId: string
  • tracked: boolean
  • backorderable: boolean
  • variant: BelongsTo<typeof ProductVariant>
  • levels: HasMany<typeof InventoryLevel>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => InventoryItem
  • useConnection: (connection: string) => InventoryItem
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<InventoryItem>>, allowExtraProperties?: boolean) => InventoryItem
  • merge: (value: Partial<ModelAttributes<InventoryItem>>, allowExtraProperties?: boolean) => InventoryItem
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "variantId" | "tracked" | "backorderable" | ("createdAt" | "updatedAt" | "id" | "metadata" | "variantId" | "tracked" | "backorderable" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => InventoryItem
  • save: () => Promise<InventoryItem>
  • saveQuietly: () => Promise<InventoryItem>
  • lockForUpdate: <T>(callback: (user: InventoryItem) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<InventoryItem>
  • load: LucidRowPreload<InventoryItem>
  • loadOnce: LucidRowPreloadOnce<InventoryItem>
  • preload: LucidRowPreload<InventoryItem>
  • loadAggregate: <Self extends InventoryItem, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends InventoryItem, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<InventoryItem>>(relation: Name) => NonNullable<InventoryItem[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & InventoryItem[Name] & {})["client"] : never

InventoryLevel

Class

InventoryLevel
Public members
  • itemId: string
  • locationId: string
  • onHand: number
  • reserved: number
  • reorderPoint: number | null
  • item: BelongsTo<typeof InventoryItem>
  • location: BelongsTo<typeof StockLocation>
  • reservations: HasMany<typeof Reservation>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => InventoryLevel
  • useConnection: (connection: string) => InventoryLevel
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<InventoryLevel>>, allowExtraProperties?: boolean) => InventoryLevel
  • merge: (value: Partial<ModelAttributes<InventoryLevel>>, allowExtraProperties?: boolean) => InventoryLevel
  • isDirty: (fields?: "createdAt" | "onHand" | "updatedAt" | "id" | "metadata" | "itemId" | "locationId" | "reserved" | "reorderPoint" | ("createdAt" | "onHand" | "updatedAt" | "id" | "metadata" | "itemId" | "locationId" | "reserved" | "reorderPoint" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => InventoryLevel
  • save: () => Promise<InventoryLevel>
  • saveQuietly: () => Promise<InventoryLevel>
  • lockForUpdate: <T>(callback: (user: InventoryLevel) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<InventoryLevel>
  • load: LucidRowPreload<InventoryLevel>
  • loadOnce: LucidRowPreloadOnce<InventoryLevel>
  • preload: LucidRowPreload<InventoryLevel>
  • loadAggregate: <Self extends InventoryLevel, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends InventoryLevel, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<InventoryLevel>>(relation: Name) => NonNullable<InventoryLevel[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & InventoryLevel[Name] & {})["client"] : never

ModelImport

Type

ModelImport

ModelRegistry

Class

ModelRegistry
Public members
  • #resolved: Map<keyof ModelRegistryOverrides, LucidModel>
  • #loaders: Readonly<Partial<Record<keyof ModelRegistryOverrides, ModelImport>>>
  • get: (key: ModelRegistryKey) => Promise<LucidModel>
  • boot: () => Promise<void>
  • require: (key: ModelRegistryKey) => LucidModel
  • relatedModel: (key: ModelRegistryKey) => () => LucidModel

ModelRegistryKey

Type

keyof ModelRegistryOverrides

moneyColumn

Function

Maps one Money property to a <prefix>_amount BIGINT and <prefix>_currency CHAR(3) column pair.

(options?: { columnPrefix?: string; }) => PropertyDecorator

Order

Class

Order
Public members
  • number: string
  • channelId: string
  • currency: string
  • customerId: string | null
  • email: string
  • state: OrderState
  • shippingAddress: AddressInput
  • billingAddress: AddressInput
  • subtotalAmount: bigint
  • shippingTotalAmount: bigint
  • taxTotalAmount: bigint
  • discountTotalAmount: bigint
  • grandTotalAmount: bigint
  • placedAt: DateTime<boolean>
  • cartId: string | null
  • channel: BelongsTo<typeof Channel>
  • customer: BelongsTo<typeof Customer>
  • cart: BelongsTo<typeof Cart>
  • lines: HasMany<typeof OrderLine>
  • adjustments: HasMany<typeof OrderAdjustment>
  • shipments: HasMany<typeof Shipment>
  • payments: HasMany<typeof Payment>
  • paymentInstructions: HasMany<typeof PaymentInstruction>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Order
  • useConnection: (connection: string) => Order
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Order>>, allowExtraProperties?: boolean) => Order
  • merge: (value: Partial<ModelAttributes<Order>>, allowExtraProperties?: boolean) => Order
  • isDirty: (fields?: "number" | "createdAt" | "email" | "updatedAt" | "placedAt" | "customerId" | "id" | "metadata" | "channelId" | "currency" | "shippingAddress" | "billingAddress" | "subtotalAmount" | "shippingTotalAmount" | "taxTotalAmount" | "discountTotalAmount" | "grandTotalAmount" | "cartId" | "state" | ("number" | "createdAt" | "email" | "updatedAt" | "placedAt" | "customerId" | "id" | "metadata" | "channelId" | "currency" | "shippingAddress" | "billingAddress" | "subtotalAmount" | "shippingTotalAmount" | "taxTotalAmount" | "discountTotalAmount" | "grandTotalAmount" | "cartId" | "state" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Order
  • save: () => Promise<Order>
  • saveQuietly: () => Promise<Order>
  • lockForUpdate: <T>(callback: (user: Order) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Order>
  • load: LucidRowPreload<Order>
  • loadOnce: LucidRowPreloadOnce<Order>
  • preload: LucidRowPreload<Order>
  • loadAggregate: <Self extends Order, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Order, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Order>>(relation: Name) => NonNullable<Order[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Order[Name] & {})["client"] : never

OrderAdjustment

Class

OrderAdjustment
Public members
  • orderId: string
  • orderLineId: string | null
  • sourceType: string
  • sourceId: string | null
  • label: string
  • amount: Money
  • amountAmount: bigint
  • amountCurrency: string
  • included: boolean
  • eligible: boolean
  • position: number
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => OrderAdjustment
  • useConnection: (connection: string) => OrderAdjustment
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<OrderAdjustment>>, allowExtraProperties?: boolean) => OrderAdjustment
  • merge: (value: Partial<ModelAttributes<OrderAdjustment>>, allowExtraProperties?: boolean) => OrderAdjustment
  • isDirty: (fields?: "createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "position" | "sourceType" | "sourceId" | "label" | "amountAmount" | "amountCurrency" | "included" | "eligible" | "orderId" | "orderLineId" | ("createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "position" | "sourceType" | "sourceId" | "label" | "amountAmount" | "amountCurrency" | "included" | "eligible" | "orderId" | "orderLineId" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => OrderAdjustment
  • save: () => Promise<OrderAdjustment>
  • saveQuietly: () => Promise<OrderAdjustment>
  • lockForUpdate: <T>(callback: (user: OrderAdjustment) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<OrderAdjustment>
  • load: LucidRowPreload<OrderAdjustment>
  • loadOnce: LucidRowPreloadOnce<OrderAdjustment>
  • preload: LucidRowPreload<OrderAdjustment>
  • loadAggregate: <Self extends OrderAdjustment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends OrderAdjustment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<OrderAdjustment[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & OrderAdjustment[Name] & {})["client"] : never

OrderLine

Class

OrderLine
Public members
  • orderId: string
  • variantId: string | null
  • cartLineId: string | null
  • productName: string
  • variantName: string | null
  • sku: string | null
  • quantity: number
  • unitPrice: Money
  • unitPriceAmount: bigint
  • unitPriceCurrency: string
  • fulfilledQuantity: number
  • refundedQuantity: number
  • order: BelongsTo<typeof Order>
  • variant: BelongsTo<typeof ProductVariant>
  • adjustments: HasMany<typeof OrderAdjustment>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => OrderLine
  • useConnection: (connection: string) => OrderLine
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<OrderLine>>, allowExtraProperties?: boolean) => OrderLine
  • merge: (value: Partial<ModelAttributes<OrderLine>>, allowExtraProperties?: boolean) => OrderLine
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "variantId" | "quantity" | "unitPrice" | "unitPriceAmount" | "unitPriceCurrency" | "cartLineId" | "sku" | "orderId" | "productName" | "variantName" | "fulfilledQuantity" | "refundedQuantity" | ("createdAt" | "updatedAt" | "id" | "metadata" | "variantId" | "quantity" | "unitPrice" | "unitPriceAmount" | "unitPriceCurrency" | "cartLineId" | "sku" | "orderId" | "productName" | "variantName" | "fulfilledQuantity" | "refundedQuantity" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => OrderLine
  • save: () => Promise<OrderLine>
  • saveQuietly: () => Promise<OrderLine>
  • lockForUpdate: <T>(callback: (user: OrderLine) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<OrderLine>
  • load: LucidRowPreload<OrderLine>
  • loadOnce: LucidRowPreloadOnce<OrderLine>
  • preload: LucidRowPreload<OrderLine>
  • loadAggregate: <Self extends OrderLine, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends OrderLine, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<OrderLine>>(relation: Name) => NonNullable<OrderLine[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & OrderLine[Name] & {})["client"] : never

OrderState

Type

OrderState

OrderTransition

Type

OrderTransition

OutboxStatus

Type

OutboxStatus

Payment

Class

Payment
Public members
  • intentId: string
  • orderId: string
  • state: PaymentState
  • amount: Money
  • amountAmount: bigint
  • amountCurrency: string
  • providerChargeId: string | null
  • rawPayload: unknown
  • intent: BelongsTo<typeof PaymentIntent>
  • order: BelongsTo<typeof Order>
  • refunds: HasMany<typeof Refund>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Payment
  • useConnection: (connection: string) => Payment
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Payment>>, allowExtraProperties?: boolean) => Payment
  • merge: (value: Partial<ModelAttributes<Payment>>, allowExtraProperties?: boolean) => Payment
  • isDirty: (fields?: "createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "amountAmount" | "amountCurrency" | "state" | "intentId" | "orderId" | "providerChargeId" | "rawPayload" | ("createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "amountAmount" | "amountCurrency" | "state" | "intentId" | "orderId" | "providerChargeId" | "rawPayload" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Payment
  • save: () => Promise<Payment>
  • saveQuietly: () => Promise<Payment>
  • lockForUpdate: <T>(callback: (user: Payment) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Payment>
  • load: LucidRowPreload<Payment>
  • loadOnce: LucidRowPreloadOnce<Payment>
  • preload: LucidRowPreload<Payment>
  • loadAggregate: <Self extends Payment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Payment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Payment>>(relation: Name) => NonNullable<Payment[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Payment[Name] & {})["client"] : never

PaymentInstruction

Class

PaymentInstruction
Public members
  • intentId: string
  • orderId: string
  • type: "virtual_account" | "qr_code" | "redirect" | "retail_outlet" | "bank_transfer"
  • details: Record<string, unknown>
  • expiresAt: DateTime<boolean>
  • intent: BelongsTo<typeof PaymentIntent>
  • order: BelongsTo<typeof Order>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => PaymentInstruction
  • useConnection: (connection: string) => PaymentInstruction
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<PaymentInstruction>>, allowExtraProperties?: boolean) => PaymentInstruction
  • merge: (value: Partial<ModelAttributes<PaymentInstruction>>, allowExtraProperties?: boolean) => PaymentInstruction
  • isDirty: (fields?: "details" | "createdAt" | "updatedAt" | "id" | "metadata" | "expiresAt" | "intentId" | "orderId" | "type" | ("details" | "createdAt" | "updatedAt" | "id" | "metadata" | "expiresAt" | "intentId" | "orderId" | "type" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => PaymentInstruction
  • save: () => Promise<PaymentInstruction>
  • saveQuietly: () => Promise<PaymentInstruction>
  • lockForUpdate: <T>(callback: (user: PaymentInstruction) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<PaymentInstruction>
  • load: LucidRowPreload<PaymentInstruction>
  • loadOnce: LucidRowPreloadOnce<PaymentInstruction>
  • preload: LucidRowPreload<PaymentInstruction>
  • loadAggregate: <Self extends PaymentInstruction, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends PaymentInstruction, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<PaymentInstruction>>(relation: Name) => NonNullable<PaymentInstruction[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & PaymentInstruction[Name] & {})["client"] : never

PaymentIntent

Class

PaymentIntent
Public members
  • orderId: string | null
  • cartId: string | null
  • provider: string
  • state: PaymentIntentState
  • flow: "authorize_capture" | "deferred"
  • inventoryPolicy: "reserve" | "commit" | null
  • amount: Money
  • amountAmount: bigint
  • amountCurrency: string
  • providerIntentId: string | null
  • clientSecretEnc: string | null
  • lastError: Record<string, unknown> | null
  • expiresAt: DateTime<boolean> | null
  • reviewReason: string | null
  • providerEventTime: DateTime<boolean> | null
  • currentProviderStatus: string | null
  • order: BelongsTo<typeof Order>
  • cart: BelongsTo<typeof Cart>
  • payments: HasMany<typeof Payment>
  • instructions: HasMany<typeof PaymentInstruction>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => PaymentIntent
  • useConnection: (connection: string) => PaymentIntent
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<PaymentIntent>>, allowExtraProperties?: boolean) => PaymentIntent
  • merge: (value: Partial<ModelAttributes<PaymentIntent>>, allowExtraProperties?: boolean) => PaymentIntent
  • isDirty: (fields?: "createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "cartId" | "amountAmount" | "amountCurrency" | "expiresAt" | "state" | "orderId" | "provider" | "flow" | "inventoryPolicy" | "providerIntentId" | "clientSecretEnc" | "lastError" | "reviewReason" | "providerEventTime" | "currentProviderStatus" | ("createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "cartId" | "amountAmount" | "amountCurrency" | "expiresAt" | "state" | "orderId" | "provider" | "flow" | "inventoryPolicy" | "providerIntentId" | "clientSecretEnc" | "lastError" | "reviewReason" | "providerEventTime" | "currentProviderStatus" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => PaymentIntent
  • save: () => Promise<PaymentIntent>
  • saveQuietly: () => Promise<PaymentIntent>
  • lockForUpdate: <T>(callback: (user: PaymentIntent) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<PaymentIntent>
  • load: LucidRowPreload<PaymentIntent>
  • loadOnce: LucidRowPreloadOnce<PaymentIntent>
  • preload: LucidRowPreload<PaymentIntent>
  • loadAggregate: <Self extends PaymentIntent, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends PaymentIntent, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<PaymentIntent>>(relation: Name) => NonNullable<PaymentIntent[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & PaymentIntent[Name] & {})["client"] : never

PaymentIntentState

Type

PaymentIntentState

PaymentState

Type

PaymentState

Price

Class

Price
Public members
  • priceListId: string
  • variantId: string
  • unitPrice: Money
  • unitPriceAmount: bigint
  • unitPriceCurrency: string
  • minQuantity: number
  • priceList: BelongsTo<typeof PriceList>
  • variant: BelongsTo<typeof ProductVariant>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Price
  • useConnection: (connection: string) => Price
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Price>>, allowExtraProperties?: boolean) => Price
  • merge: (value: Partial<ModelAttributes<Price>>, allowExtraProperties?: boolean) => Price
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "variantId" | "unitPrice" | "unitPriceAmount" | "unitPriceCurrency" | "priceListId" | "minQuantity" | ("createdAt" | "updatedAt" | "id" | "metadata" | "variantId" | "unitPrice" | "unitPriceAmount" | "unitPriceCurrency" | "priceListId" | "minQuantity" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Price
  • save: () => Promise<Price>
  • saveQuietly: () => Promise<Price>
  • lockForUpdate: <T>(callback: (user: Price) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Price>
  • load: LucidRowPreload<Price>
  • loadOnce: LucidRowPreloadOnce<Price>
  • preload: LucidRowPreload<Price>
  • loadAggregate: <Self extends Price, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Price, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Price>>(relation: Name) => NonNullable<Price[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Price[Name] & {})["client"] : never

PriceList

Class

PriceList
Public members
  • name: string
  • channelId: string | null
  • customerGroupId: string | null
  • priority: number
  • startsAt: DateTime<boolean> | null
  • endsAt: DateTime<boolean> | null
  • isDefault: boolean
  • channel: BelongsTo<typeof Channel>
  • customerGroup: BelongsTo<typeof CustomerGroup>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => PriceList
  • useConnection: (connection: string) => PriceList
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<PriceList>>, allowExtraProperties?: boolean) => PriceList
  • merge: (value: Partial<ModelAttributes<PriceList>>, allowExtraProperties?: boolean) => PriceList
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "channelId" | "isDefault" | "customerGroupId" | "priority" | "startsAt" | "endsAt" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "channelId" | "isDefault" | "customerGroupId" | "priority" | "startsAt" | "endsAt" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => PriceList
  • save: () => Promise<PriceList>
  • saveQuietly: () => Promise<PriceList>
  • lockForUpdate: <T>(callback: (user: PriceList) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<PriceList>
  • load: LucidRowPreload<PriceList>
  • loadOnce: LucidRowPreloadOnce<PriceList>
  • preload: LucidRowPreload<PriceList>
  • loadAggregate: <Self extends PriceList, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends PriceList, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<PriceList>>(relation: Name) => NonNullable<PriceList[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & PriceList[Name] & {})["client"] : never

Product

Class

Product
Public members
  • status: ProductStatus
  • name: string
  • slug: string
  • description: string | null
  • images: HasMany<typeof ProductImage>
  • options: HasMany<typeof ProductOption>
  • variants: HasMany<typeof ProductVariant>
  • categories: ManyToMany<typeof Category>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Product
  • useConnection: (connection: string) => Product
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Product>>, allowExtraProperties?: boolean) => Product
  • merge: (value: Partial<ModelAttributes<Product>>, allowExtraProperties?: boolean) => Product
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "status" | "slug" | "description" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "status" | "slug" | "description" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Product
  • save: () => Promise<Product>
  • saveQuietly: () => Promise<Product>
  • lockForUpdate: <T>(callback: (user: Product) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Product>
  • load: LucidRowPreload<Product>
  • loadOnce: LucidRowPreloadOnce<Product>
  • preload: LucidRowPreload<Product>
  • loadAggregate: <Self extends Product, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Product, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Product>>(relation: Name) => NonNullable<Product[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Product[Name] & {})["client"] : never

ProductImage

Class

ProductImage
Public members
  • productId: string
  • url: string
  • disk: string | null
  • key: string | null
  • altText: string | null
  • position: number
  • mimeType: string
  • sizeBytes: number
  • width: number
  • height: number
  • product: BelongsTo<typeof Product>
  • variants: ManyToMany<typeof ProductVariant>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => ProductImage
  • useConnection: (connection: string) => ProductImage
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<ProductImage>>, allowExtraProperties?: boolean) => ProductImage
  • merge: (value: Partial<ModelAttributes<ProductImage>>, allowExtraProperties?: boolean) => ProductImage
  • isDirty: (fields?: "createdAt" | "updatedAt" | "disk" | "key" | "id" | "metadata" | "position" | "productId" | "url" | "altText" | "mimeType" | "sizeBytes" | "width" | "height" | ("createdAt" | "updatedAt" | "disk" | "key" | "id" | "metadata" | "position" | "productId" | "url" | "altText" | "mimeType" | "sizeBytes" | "width" | "height" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => ProductImage
  • save: () => Promise<ProductImage>
  • saveQuietly: () => Promise<ProductImage>
  • lockForUpdate: <T>(callback: (user: ProductImage) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<ProductImage>
  • load: LucidRowPreload<ProductImage>
  • loadOnce: LucidRowPreloadOnce<ProductImage>
  • preload: LucidRowPreload<ProductImage>
  • loadAggregate: <Self extends ProductImage, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends ProductImage, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<ProductImage>>(relation: Name) => NonNullable<ProductImage[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & ProductImage[Name] & {})["client"] : never

ProductOption

Class

ProductOption
Public members
  • productId: string
  • name: string
  • position: number
  • product: BelongsTo<typeof Product>
  • values: HasMany<typeof ProductOptionValue>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => ProductOption
  • useConnection: (connection: string) => ProductOption
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<ProductOption>>, allowExtraProperties?: boolean) => ProductOption
  • merge: (value: Partial<ModelAttributes<ProductOption>>, allowExtraProperties?: boolean) => ProductOption
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "position" | "productId" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "position" | "productId" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => ProductOption
  • save: () => Promise<ProductOption>
  • saveQuietly: () => Promise<ProductOption>
  • lockForUpdate: <T>(callback: (user: ProductOption) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<ProductOption>
  • load: LucidRowPreload<ProductOption>
  • loadOnce: LucidRowPreloadOnce<ProductOption>
  • preload: LucidRowPreload<ProductOption>
  • loadAggregate: <Self extends ProductOption, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends ProductOption, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<ProductOption>>(relation: Name) => NonNullable<ProductOption[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & ProductOption[Name] & {})["client"] : never

ProductOptionValue

Class

ProductOptionValue
Public members
  • optionId: string
  • value: string
  • position: number
  • option: BelongsTo<typeof ProductOption>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => ProductOptionValue
  • useConnection: (connection: string) => ProductOptionValue
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<ProductOptionValue>>, allowExtraProperties?: boolean) => ProductOptionValue
  • merge: (value: Partial<ModelAttributes<ProductOptionValue>>, allowExtraProperties?: boolean) => ProductOptionValue
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "position" | "optionId" | "value" | ("createdAt" | "updatedAt" | "id" | "metadata" | "position" | "optionId" | "value" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => ProductOptionValue
  • save: () => Promise<ProductOptionValue>
  • saveQuietly: () => Promise<ProductOptionValue>
  • lockForUpdate: <T>(callback: (user: ProductOptionValue) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<ProductOptionValue>
  • load: LucidRowPreload<ProductOptionValue>
  • loadOnce: LucidRowPreloadOnce<ProductOptionValue>
  • preload: LucidRowPreload<ProductOptionValue>
  • loadAggregate: <Self extends ProductOptionValue, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends ProductOptionValue, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<ProductOptionValue>>(relation: Name) => NonNullable<ProductOptionValue[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & ProductOptionValue[Name] & {})["client"] : never

ProductStatus

Type

ProductStatus

ProductVariant

Class

ProductVariant
Public members
  • productId: string
  • taxCategoryId: string | null
  • sku: string | null
  • name: string | null
  • position: number
  • isDefault: boolean
  • weightGrams: number | null
  • lengthMm: number | null
  • widthMm: number | null
  • heightMm: number | null
  • images: ManyToMany<typeof ProductImage>
  • product: BelongsTo<typeof Product>
  • optionValues: ManyToMany<typeof ProductOptionValue>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => ProductVariant
  • useConnection: (connection: string) => ProductVariant
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<ProductVariant>>, allowExtraProperties?: boolean) => ProductVariant
  • merge: (value: Partial<ModelAttributes<ProductVariant>>, allowExtraProperties?: boolean) => ProductVariant
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "isDefault" | "position" | "productId" | "taxCategoryId" | "sku" | "weightGrams" | "lengthMm" | "widthMm" | "heightMm" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "isDefault" | "position" | "productId" | "taxCategoryId" | "sku" | "weightGrams" | "lengthMm" | "widthMm" | "heightMm" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => ProductVariant
  • save: () => Promise<ProductVariant>
  • saveQuietly: () => Promise<ProductVariant>
  • lockForUpdate: <T>(callback: (user: ProductVariant) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<ProductVariant>
  • load: LucidRowPreload<ProductVariant>
  • loadOnce: LucidRowPreloadOnce<ProductVariant>
  • preload: LucidRowPreload<ProductVariant>
  • loadAggregate: <Self extends ProductVariant, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends ProductVariant, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<ProductVariant>>(relation: Name) => NonNullable<ProductVariant[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & ProductVariant[Name] & {})["client"] : never

Refund

Class

Refund
Public members
  • paymentId: string
  • state: RefundState
  • reason: string | null
  • amount: Money
  • amountAmount: bigint
  • amountCurrency: string
  • providerRefundId: string | null
  • rawPayload: unknown
  • payment: BelongsTo<typeof Payment>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Refund
  • useConnection: (connection: string) => Refund
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Refund>>, allowExtraProperties?: boolean) => Refund
  • merge: (value: Partial<ModelAttributes<Refund>>, allowExtraProperties?: boolean) => Refund
  • isDirty: (fields?: "createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "amountAmount" | "amountCurrency" | "state" | "rawPayload" | "paymentId" | "reason" | "providerRefundId" | ("createdAt" | "updatedAt" | "amount" | "id" | "metadata" | "amountAmount" | "amountCurrency" | "state" | "rawPayload" | "paymentId" | "reason" | "providerRefundId" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Refund
  • save: () => Promise<Refund>
  • saveQuietly: () => Promise<Refund>
  • lockForUpdate: <T>(callback: (user: Refund) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Refund>
  • load: LucidRowPreload<Refund>
  • loadOnce: LucidRowPreloadOnce<Refund>
  • preload: LucidRowPreload<Refund>
  • loadAggregate: <Self extends Refund, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Refund, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Refund>>(relation: Name) => NonNullable<Refund[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Refund[Name] & {})["client"] : never

RefundState

Type

RefundState

Reservation

Class

Reservation
Public members
  • levelId: string
  • cartId: string
  • cartLineId: string
  • quantity: number
  • returnedQuantity: number
  • expiresAt: DateTime<boolean>
  • state: ReservationState
  • level: BelongsTo<typeof InventoryLevel>
  • cart: BelongsTo<typeof Cart>
  • cartLine: BelongsTo<typeof CartLine>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Reservation
  • useConnection: (connection: string) => Reservation
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Reservation>>, allowExtraProperties?: boolean) => Reservation
  • merge: (value: Partial<ModelAttributes<Reservation>>, allowExtraProperties?: boolean) => Reservation
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "cartId" | "quantity" | "cartLineId" | "expiresAt" | "levelId" | "returnedQuantity" | "state" | ("createdAt" | "updatedAt" | "id" | "metadata" | "cartId" | "quantity" | "cartLineId" | "expiresAt" | "levelId" | "returnedQuantity" | "state" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Reservation
  • save: () => Promise<Reservation>
  • saveQuietly: () => Promise<Reservation>
  • lockForUpdate: <T>(callback: (user: Reservation) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Reservation>
  • load: LucidRowPreload<Reservation>
  • loadOnce: LucidRowPreloadOnce<Reservation>
  • preload: LucidRowPreload<Reservation>
  • loadAggregate: <Self extends Reservation, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Reservation, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Reservation>>(relation: Name) => NonNullable<Reservation[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Reservation[Name] & {})["client"] : never

ReservationState

Type

ReservationState

Shipment

Class

Shipment
Public members
  • orderId: string
  • state: ShipmentState
  • trackingNumber: string | null
  • carrier: string | null
  • shippedAt: DateTime<boolean> | null
  • deliveredAt: DateTime<boolean> | null
  • provider: string | null
  • providerShipmentId: string | null
  • waybill: string | null
  • handedOffAt: DateTime<boolean> | null
  • deliveryFailedAt: DateTime<boolean> | null
  • returnedAt: DateTime<boolean> | null
  • inventoryRestockedAt: DateTime<boolean> | null
  • order: BelongsTo<typeof Order>
  • lines: HasMany<typeof ShipmentLine>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => Shipment
  • useConnection: (connection: string) => Shipment
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<Shipment>>, allowExtraProperties?: boolean) => Shipment
  • merge: (value: Partial<ModelAttributes<Shipment>>, allowExtraProperties?: boolean) => Shipment
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "state" | "orderId" | "trackingNumber" | "carrier" | "shippedAt" | "deliveredAt" | "provider" | "providerShipmentId" | "waybill" | "handedOffAt" | "deliveryFailedAt" | "returnedAt" | "inventoryRestockedAt" | ("createdAt" | "updatedAt" | "id" | "metadata" | "state" | "orderId" | "trackingNumber" | "carrier" | "shippedAt" | "deliveredAt" | "provider" | "providerShipmentId" | "waybill" | "handedOffAt" | "deliveryFailedAt" | "returnedAt" | "inventoryRestockedAt" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => Shipment
  • save: () => Promise<Shipment>
  • saveQuietly: () => Promise<Shipment>
  • lockForUpdate: <T>(callback: (user: Shipment) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<Shipment>
  • load: LucidRowPreload<Shipment>
  • loadOnce: LucidRowPreloadOnce<Shipment>
  • preload: LucidRowPreload<Shipment>
  • loadAggregate: <Self extends Shipment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends Shipment, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<Shipment>>(relation: Name) => NonNullable<Shipment[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Shipment[Name] & {})["client"] : never

ShipmentLine

Class

ShipmentLine
Public members
  • shipmentId: string
  • orderLineId: string
  • quantity: number
  • shipment: BelongsTo<typeof Shipment>
  • orderLine: BelongsTo<typeof OrderLine>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => ShipmentLine
  • useConnection: (connection: string) => ShipmentLine
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<ShipmentLine>>, allowExtraProperties?: boolean) => ShipmentLine
  • merge: (value: Partial<ModelAttributes<ShipmentLine>>, allowExtraProperties?: boolean) => ShipmentLine
  • isDirty: (fields?: "createdAt" | "updatedAt" | "id" | "metadata" | "quantity" | "orderLineId" | "shipmentId" | ("createdAt" | "updatedAt" | "id" | "metadata" | "quantity" | "orderLineId" | "shipmentId" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => ShipmentLine
  • save: () => Promise<ShipmentLine>
  • saveQuietly: () => Promise<ShipmentLine>
  • lockForUpdate: <T>(callback: (user: ShipmentLine) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<ShipmentLine>
  • load: LucidRowPreload<ShipmentLine>
  • loadOnce: LucidRowPreloadOnce<ShipmentLine>
  • preload: LucidRowPreload<ShipmentLine>
  • loadAggregate: <Self extends ShipmentLine, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends ShipmentLine, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<ShipmentLine>>(relation: Name) => NonNullable<ShipmentLine[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & ShipmentLine[Name] & {})["client"] : never

ShipmentState

Type

ShipmentState

ShippingMethod

Class

ShippingMethod
Public members
  • code: string
  • name: string
  • calculator: string
  • calculatorConfig: Record<string, unknown>
  • channelId: string | null
  • position: number
  • enabled: boolean
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => ShippingMethod
  • useConnection: (connection: string) => ShippingMethod
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<ShippingMethod>>, allowExtraProperties?: boolean) => ShippingMethod
  • merge: (value: Partial<ModelAttributes<ShippingMethod>>, allowExtraProperties?: boolean) => ShippingMethod
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "channelId" | "code" | "calculator" | "calculatorConfig" | "position" | "enabled" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "channelId" | "code" | "calculator" | "calculatorConfig" | "position" | "enabled" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => ShippingMethod
  • save: () => Promise<ShippingMethod>
  • saveQuietly: () => Promise<ShippingMethod>
  • lockForUpdate: <T>(callback: (user: ShippingMethod) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<ShippingMethod>
  • load: LucidRowPreload<ShippingMethod>
  • loadOnce: LucidRowPreloadOnce<ShippingMethod>
  • preload: LucidRowPreload<ShippingMethod>
  • loadAggregate: <Self extends ShippingMethod, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends ShippingMethod, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<ShippingMethod[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & ShippingMethod[Name] & {})["client"] : never

StockLocation

Class

StockLocation
Public members
  • code: string
  • name: string
  • address: AddressInput | null
  • isDefault: boolean
  • levels: HasMany<typeof InventoryLevel>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => StockLocation
  • useConnection: (connection: string) => StockLocation
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<StockLocation>>, allowExtraProperties?: boolean) => StockLocation
  • merge: (value: Partial<ModelAttributes<StockLocation>>, allowExtraProperties?: boolean) => StockLocation
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | "isDefault" | "address" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | "isDefault" | "address" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => StockLocation
  • save: () => Promise<StockLocation>
  • saveQuietly: () => Promise<StockLocation>
  • lockForUpdate: <T>(callback: (user: StockLocation) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<StockLocation>
  • load: LucidRowPreload<StockLocation>
  • loadOnce: LucidRowPreloadOnce<StockLocation>
  • preload: LucidRowPreload<StockLocation>
  • loadAggregate: <Self extends StockLocation, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends StockLocation, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<StockLocation>>(relation: Name) => NonNullable<StockLocation[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & StockLocation[Name] & {})["client"] : never

TaxCategory

Class

TaxCategory
Public members
  • code: string
  • name: string
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => TaxCategory
  • useConnection: (connection: string) => TaxCategory
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<TaxCategory>>, allowExtraProperties?: boolean) => TaxCategory
  • merge: (value: Partial<ModelAttributes<TaxCategory>>, allowExtraProperties?: boolean) => TaxCategory
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "code" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => TaxCategory
  • save: () => Promise<TaxCategory>
  • saveQuietly: () => Promise<TaxCategory>
  • lockForUpdate: <T>(callback: (user: TaxCategory) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<TaxCategory>
  • load: LucidRowPreload<TaxCategory>
  • loadOnce: LucidRowPreloadOnce<TaxCategory>
  • preload: LucidRowPreload<TaxCategory>
  • loadAggregate: <Self extends TaxCategory, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends TaxCategory, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<TaxCategory[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & TaxCategory[Name] & {})["client"] : never

TaxRate

Class

TaxRate
Public members
  • zoneId: string
  • taxCategoryId: string | null
  • name: string
  • rateBp: number
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => TaxRate
  • useConnection: (connection: string) => TaxRate
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<TaxRate>>, allowExtraProperties?: boolean) => TaxRate
  • merge: (value: Partial<ModelAttributes<TaxRate>>, allowExtraProperties?: boolean) => TaxRate
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "taxCategoryId" | "zoneId" | "rateBp" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "taxCategoryId" | "zoneId" | "rateBp" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => TaxRate
  • save: () => Promise<TaxRate>
  • saveQuietly: () => Promise<TaxRate>
  • lockForUpdate: <T>(callback: (user: TaxRate) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<TaxRate>
  • load: LucidRowPreload<TaxRate>
  • loadOnce: LucidRowPreloadOnce<TaxRate>
  • preload: LucidRowPreload<TaxRate>
  • loadAggregate: <Self extends TaxRate, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends TaxRate, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<TaxRate[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & TaxRate[Name] & {})["client"] : never

TaxZone

Class

TaxZone
Public members
  • name: string
  • countryCodes: string[]
  • regionPattern: string | null
  • postalPattern: string | null
  • rates: HasMany<typeof TaxRate>
  • id: string
  • metadata: Record<string, unknown> | null
  • createdAt: DateTime<boolean>
  • updatedAt: DateTime<boolean>
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => TaxZone
  • useConnection: (connection: string) => TaxZone
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<TaxZone>>, allowExtraProperties?: boolean) => TaxZone
  • merge: (value: Partial<ModelAttributes<TaxZone>>, allowExtraProperties?: boolean) => TaxZone
  • isDirty: (fields?: "createdAt" | "updatedAt" | "name" | "id" | "metadata" | "countryCodes" | "regionPattern" | "postalPattern" | ("createdAt" | "updatedAt" | "name" | "id" | "metadata" | "countryCodes" | "regionPattern" | "postalPattern" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => TaxZone
  • save: () => Promise<TaxZone>
  • saveQuietly: () => Promise<TaxZone>
  • lockForUpdate: <T>(callback: (user: TaxZone) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<TaxZone>
  • load: LucidRowPreload<TaxZone>
  • loadOnce: LucidRowPreloadOnce<TaxZone>
  • preload: LucidRowPreload<TaxZone>
  • loadAggregate: <Self extends TaxZone, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends TaxZone, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends ExtractModelRelations<TaxZone>>(relation: Name) => NonNullable<TaxZone[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & TaxZone[Name] & {})["client"] : never

WebhookEvent

Class

WebhookEvent
Public members
  • id: string
  • provider: string
  • providerEventId: string
  • type: string
  • payload: unknown
  • status: WebhookEventStatus
  • error: string | null
  • receivedAt: DateTime<boolean>
  • processedAt: DateTime<boolean> | null
  • providerEventTime: DateTime<boolean> | null
  • providerStatus: string | null
  • $attributes: ModelObject
  • $extras: ModelObject
  • $original: ModelObject
  • $preloaded: { [relation: string]: LucidRow | LucidRow[]; }
  • $sideloaded: ModelObject
  • $primaryKeyValue: string | number | undefined
  • $isPersisted: boolean
  • $isNew: boolean
  • $isLocal: boolean
  • $dirty: ModelObject
  • $isDirty: boolean
  • $isDeleted: boolean
  • $options: ModelOptions | undefined
  • $trx: TransactionClientContract | undefined
  • $setOptionsAndTrx: (options?: ModelAdapterOptions) => void
  • useTransaction: (trx: TransactionClientContract) => WebhookEvent
  • useConnection: (connection: string) => WebhookEvent
  • $getQueryFor: { (action: "insert", client: QueryClientContract): ReturnType<QueryClientContract["insertQuery"]>; (action: "update" | "delete" | "refresh", client: QueryClientContract): ModelQueryBuilderContract<LucidModel>; }
  • $setAttribute: (key: string, value: any) => void
  • $getAttribute: (key: string) => any
  • $getAttributeFromCache: (key: string, callback: CacheNode["getter"]) => any
  • $hasRelated: (key: string) => boolean
  • $setRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $pushRelated: (key: string, result: OneOrMany<LucidRow> | null) => void
  • $getRelated: (key: string, defaultValue?: any) => OneOrMany<LucidRow> | undefined | null
  • $consumeAdapterResult: (adapterResult: ModelObject, sideloadAttributes?: ModelObject) => void
  • $hydrateOriginals: () => void
  • fill: (value: Partial<ModelAttributes<WebhookEvent>>, allowExtraProperties?: boolean) => WebhookEvent
  • merge: (value: Partial<ModelAttributes<WebhookEvent>>, allowExtraProperties?: boolean) => WebhookEvent
  • isDirty: (fields?: "id" | "status" | "payload" | "provider" | "type" | "providerEventTime" | "providerEventId" | "error" | "receivedAt" | "processedAt" | "providerStatus" | ("id" | "status" | "payload" | "provider" | "type" | "providerEventTime" | "providerEventId" | "error" | "receivedAt" | "processedAt" | "providerStatus" | undefined)[] | undefined) => boolean
  • enableForceUpdate: () => WebhookEvent
  • save: () => Promise<WebhookEvent>
  • saveQuietly: () => Promise<WebhookEvent>
  • lockForUpdate: <T>(callback: (user: WebhookEvent) => T | Promise<T>) => Promise<T>
  • delete: () => Promise<void>
  • deleteQuietly: () => Promise<void>
  • refresh: () => Promise<WebhookEvent>
  • load: LucidRowPreload<WebhookEvent>
  • loadOnce: LucidRowPreloadOnce<WebhookEvent>
  • preload: LucidRowPreload<WebhookEvent>
  • loadAggregate: <Self extends WebhookEvent, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback: (builder: RelatedBuilder) => void) => LazyLoadAggregatesContract<Self>
  • loadCount: <Self extends WebhookEvent, Name extends ExtractModelRelations<Self>, RelatedBuilder = NonNullable<Self[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & Self[Name] & {})["subQuery"] : never>(name: Name, callback?: ((builder: RelatedBuilder) => void) | undefined) => LazyLoadAggregatesContract<Self>
  • serializeAttributes: (fields?: CherryPickFields, raw?: boolean) => ModelObject
  • serializeComputed: (fields?: CherryPickFields) => ModelObject
  • serializeRelations: { (fields: undefined, raw: true): { [key: string]: LucidRow | LucidRow[]; }; (cherryPick: CherryPick["relations"] | undefined, raw: false | undefined): ModelObject; (cherryPick?: CherryPick["relations"], raw?: boolean): ModelObject; }
  • serialize: (cherryPick?: CherryPick) => ModelObject
  • toObject: () => ModelObject
  • toJSON: () => ModelObject
  • toAttributes: () => Record<string, any>
  • related: <Name extends undefined>(relation: Name) => NonNullable<WebhookEvent[Name]> extends ModelRelations<LucidModel, LucidModel> ? (ModelRelations<LucidModel, LucidModel> & WebhookEvent[Name] & {})["client"] : never

WebhookEventStatus

Type

WebhookEventStatus

@adocommercekit/core/events

CartAbandoned

Class

CartAbandoned
Public members
  • cartId: string
  • channel: string

CartCreated

Class

CartCreated
Public members
  • cartId: string
  • channel: string

CartLineAdded

Class

CartLineAdded
Public members
  • cartId: string
  • lineId: string
  • variantId: string
  • quantity: number

CartLineQuantityChanged

Class

CartLineQuantityChanged
Public members
  • cartId: string
  • lineId: string
  • variantId: string
  • quantity: number

CartLineRemoved

Class

CartLineRemoved
Public members
  • cartId: string
  • lineId: string
  • variantId: string

CartRecalculated

Class

CartRecalculated
Public members
  • cartId: string
  • total: Money

ChannelCreated

Class

ChannelCreated
Public members
  • channelId: string
  • code: string

CheckoutStarted

Class

CheckoutStarted
Public members
  • cartId: string

CustomerAnonymized

Class

CustomerAnonymized
Public members
  • customerId: string

CustomerRegistered

Class

CustomerRegistered
Public members
  • customerId: string
  • email: string | null

EventBufferLogger

Interface

EventBufferLogger
Public members
  • error: (message: string, context: Readonly<Record<string, unknown>>) => void

EventEmitterPort

Interface

EventEmitterPort
Public members
  • emit: (event: string, payload: unknown) => Promise<unknown> | unknown

OrderCanceled

Class

OrderCanceled
Public members
  • orderId: string
  • context: Readonly<Record<string, unknown>>

OrderCompleted

Class

OrderCompleted
Public members
  • orderId: string
  • context: Readonly<Record<string, unknown>>

OrderConfirmed

Class

OrderConfirmed
Public members
  • orderId: string
  • context: Readonly<Record<string, unknown>>

OrderFulfilled

Class

OrderFulfilled
Public members
  • orderId: string
  • context: Readonly<Record<string, unknown>>

OrderPlaced

Class

OrderPlaced
Public members
  • orderId: string
  • number: string
  • total: Money
  • customerId: string | undefined

PaymentAuthorized

Class

PaymentAuthorized
Public members
  • intentId: string
  • orderId: string | null
  • amount: Money

PaymentCaptured

Class

PaymentCaptured
Public members
  • intentId: string
  • orderId: string | null
  • amount: Money

PaymentExpired

Class

PaymentExpired
Public members
  • intentId: string
  • orderId: string
  • expiredAt: string

PaymentFailed

Class

PaymentFailed
Public members
  • intentId: string
  • orderId: string | null
  • amount: Money

PaymentReviewRequired

Class

PaymentReviewRequired
Public members
  • intentId: string
  • orderId: string
  • reason: string

ProductArchived

Class

ProductArchived
Public members
  • productId: string

ProductCreated

Class

ProductCreated
Public members
  • productId: string

ProductImageCreated

Class

ProductImageCreated
Public members
  • productId: string
  • imageId: string

ProductImageRemoved

Class

ProductImageRemoved
Public members
  • productId: string
  • imageId: string

ProductImagesReordered

Class

ProductImagesReordered
Public members
  • productId: string
  • imageIds: string[]

ProductImageUpdated

Class

ProductImageUpdated
Public members
  • productId: string
  • imageId: string

ProductUpdated

Class

ProductUpdated
Public members
  • productId: string

RefundFailed

Class

RefundFailed
Public members
  • refundId: string
  • paymentId: string
  • amount: Money

RefundSucceeded

Class

RefundSucceeded
Public members
  • refundId: string
  • paymentId: string
  • amount: Money

ShipmentDelivered

Class

ShipmentDelivered
Public members
  • shipmentId: string
  • orderId: string
  • tracking: string | null

ShipmentDeliveryFailed

Class

ShipmentDeliveryFailed
Public members
  • shipmentId: string
  • orderId: string

ShipmentReturned

Class

ShipmentReturned
Public members
  • shipmentId: string
  • orderId: string

ShipmentShipped

Class

ShipmentShipped
Public members
  • shipmentId: string
  • orderId: string
  • tracking: string | null

StockAdjusted

Class

StockAdjusted
Public members
  • itemId: string
  • locationId: string
  • delta: number
  • reason: string

StockLevelLow

Class

StockLevelLow
Public members
  • itemId: string
  • available: number
  • threshold: number

TransactionalEventEmitter

Class

TransactionalEventEmitter
Public members
  • #buffers: WeakMap<TransactionHookClient, BufferState>
  • emitter: EventEmitterPort
  • logger: EventBufferLogger
  • outbox: TransactionalOutboxWriter | undefined
  • buffer: (trx: TransactionHookClient, name: string, payload: unknown) => void
  • linkNestedTransaction: (child: TransactionHookClient, parent: TransactionHookClient) => void
  • emit: (name: string, payload: unknown, trx?: TransactionHookClient) => Promise<void>
  • nested: <R>(parent: TransactionHookClient, callback: (trx: TransactionHookClient) => Promise<R>) => Promise<R>
  • #state: (trx: TransactionHookClient) => BufferState
  • #flush: (events: BufferedEvent[]) => Promise<void>

TransactionalOutboxWriter

Interface

TransactionalOutboxWriter
Public members
  • write: (name: string, payload: unknown, trx: TransactionHookClient) => Promise<void>

TransactionHookClient

Interface

TransactionHookClient
Public members
  • after: (event: "commit" | "rollback", handler: () => void | Promise<void>) => TransactionHookClient
  • transaction: (<R>(callback: (trx: TransactionHookClient) => Promise<R>) => Promise<R>) | undefined

@adocommercekit/core/drivers

adonisDriveProductImages

Function

Store product images on any public disk configured through @adonisjs/drive.

(disk?: string) => DriverFactory<ProductImageStorage>

AdonisQueuePort

Interface

AdonisQueuePort
Public members
  • dispatch: (job: string, payload: JobPayload) => Promise<unknown>
  • schedule: (cron: string, job: string, payload?: JobPayload) => Promise<unknown>
  • shutdown: (() => Promise<unknown>) | undefined

allEnabledShippingEligibility

Function

() => (_app: ApplicationService) => ShippingEligibility

AllEnabledShippingEligibility

Class

AllEnabledShippingEligibility
Public members
  • eligibleMethods: (_cart: CartSnapshot, methods: ShippingMethodConfig[]) => Promise<string[]>

cashOnDelivery

Function

(options?: { expiresAfterDays?: number; }) => DriverFactory<PaymentProvider>

CashOnDeliveryPaymentProvider

Class

CashOnDeliveryPaymentProvider
Public members
  • code: "cod"
  • expiresAfterDays: number
  • capabilities: () => { authorize: boolean; capture: boolean; refund: boolean; void: boolean; clientConfirmation: boolean; flow: "deferred"; cod: boolean; }
  • createIntent: () => Promise<{ providerIntentId: string; state: "pending"; expiresAt: DateTime<true>; }>
  • confirm: () => Promise<{ state: "pending"; }>
  • capture: () => Promise<{ providerChargeId: string; }>
  • refund: () => Promise<{ providerRefundId: string; }>
  • void: () => Promise<void>
  • retrieveIntent: () => Promise<{ state: "pending"; }>
  • verifyWebhook: () => Promise<boolean>
  • normalizeWebhook: () => Promise<{ type: "unhandled"; providerEventId: `${string}-${string}-${string}-${string}-${string}`; }>

DatabasePriceResolver

Class

DatabasePriceResolver
Public members
  • db: Database
  • config: Pick<ResolvedCommerceConfig, "tablePrefix">
  • resolve: (input: { variantId: string; quantity: number; ctx: ChannelContext; trx?: TransactionClientContract; }) => Promise<{ unitPrice: Money; priceListId: string | null; }>

defaultPriceResolver

Function

() => (app: ApplicationService) => Promise<PriceResolver>

flatRateShipping

Function

() => (_app: ApplicationService) => ShippingCalculator

FlatRateShipping

Class

FlatRateShipping
Public members
  • code: "flat"
  • calculate: (input: { cart: CartSnapshot; method: ShippingMethodConfig; }) => Promise<Money>

freeShippingOver

Function

(options?: { threshold?: Money; }) => (_app: ApplicationService) => ShippingCalculator

FreeShippingOver

Class

FreeShippingOver
Public members
  • code: "free_over"
  • threshold: Money | undefined
  • calculate: (input: { cart: CartSnapshot; method: ShippingMethodConfig; }) => Promise<Money>

headerCartToken

Function

(options?: { header?: string; }) => (_app: ApplicationService) => CartTokenStrategy

HeaderCartTokenStrategy

Class

HeaderCartTokenStrategy
Public members
  • header: string
  • read: (ctx: HttpContext) => string | null
  • issue: (_ctx: HttpContext, _token: string) => void

InlineJobDispatcher

Class

InlineJobDispatcher
Public members
  • #handlers: Map<string, InlineJobHandler>
  • #timers: Set<NodeJS.Timeout>
  • register: (job: string, handler: InlineJobHandler) => InlineJobDispatcher
  • dispatch: (job: string, payload: JobPayload) => Promise<void>
  • schedule: (cron: string, job: string, payload?: JobPayload) => Promise<void>
  • shutdown: () => Promise<void>

InlineJobHandler

Type

InlineJobHandler

JobDispatcher

Interface

JobDispatcher
Public members
  • dispatch: (job: string, payload: JobPayload) => Promise<void>
  • schedule: (cron: string, job: string, payload?: JobPayload) => Promise<void>
  • shutdown: () => Promise<void>

JobDispatcherService

Class

JobDispatcherService
Public members
  • #adapter: JobDispatcher | undefined
  • #handlers: Map<string, InlineJobHandler>
  • use: (adapter: JobDispatcher) => void
  • register: (job: string, handler: InlineJobHandler) => () => void
  • jobNames: string[]
  • handle: (job: string, payload?: JobPayload) => Promise<void>
  • adapter: JobDispatcher
  • dispatch: (job: string, payload: JobPayload) => Promise<void>
  • schedule: (cron: string, job: string, payload?: JobPayload) => Promise<void>
  • shutdown: () => Promise<void>

JobPayload

Type

Readonly<Record<string, unknown>>

manualPayment

Function

() => DriverFactory<PaymentProvider>

ManualPaymentProvider

Class

ManualPaymentProvider
Public members
  • code: "manual"
  • capabilities: () => { authorize: boolean; capture: boolean; refund: boolean; void: boolean; clientConfirmation: boolean; flow: "authorize_capture"; }
  • createIntent: () => Promise<{ providerIntentId: string; state: "created"; }>
  • confirm: () => Promise<{ state: "authorized"; }>
  • capture: () => Promise<{ providerChargeId: string; }>
  • refund: () => Promise<{ providerRefundId: string; }>
  • void: () => Promise<void>
  • verifyWebhook: (raw: RawWebhookRequest) => Promise<boolean>
  • normalizeWebhook: (raw: RawWebhookRequest) => Promise<NormalizedPaymentEvent | { type: "unhandled"; providerEventId: string; raw?: unknown; }>

perItemShipping

Function

() => (_app: ApplicationService) => ShippingCalculator

PerItemShipping

Class

PerItemShipping
Public members
  • code: "per_item"
  • calculate: (input: { cart: CartSnapshot; method: ShippingMethodConfig; }) => Promise<Money>

QueueJobDispatcher

Class

The only adapter that is coupled to the experimental queue package API.

QueueJobDispatcher
Public members
  • queue: AdonisQueuePort
  • dispatch: (job: string, payload: JobPayload) => Promise<void>
  • schedule: (cron: string, job: string, payload?: JobPayload) => Promise<void>
  • shutdown: () => Promise<void>

sessionCartToken

Function

(options?: { key?: string; }) => (_app: ApplicationService) => CartTokenStrategy

SessionCartTokenStrategy

Class

SessionCartTokenStrategy
Public members
  • key: string
  • read: (ctx: HttpContext) => string | null
  • issue: (ctx: HttpContext, token: string) => void

singleLocationAllocation

Function

() => DriverFactory<StockAllocationStrategy>

SingleLocationAllocation

Class

SingleLocationAllocation
Public members
  • allocate: (input: Parameters<StockAllocationStrategy["allocate"]>[0]) => Promise<{ levelId: string; quantity: number; }[]>

zoneTaxCalculator

Function

() => (app: ApplicationService) => Promise<TaxCalculator>

ZoneTaxCalculator

Class

ZoneTaxCalculator
Public members
  • db: Database
  • config: Pick<ResolvedCommerceConfig, "tablePrefix">
  • calculate: (input: { lines: TaxableLine[]; address: AddressInput | null; inclusive: boolean; trx?: TransactionClientContract; }) => Promise<TaxLineResult[]>

@adocommercekit/core/transformers

AddressTransformer

Class

AddressTransformer
Public members
  • toObject: () => { id: string; firstName: string; lastName: string; company: string | null; line1: string; line2: string | null; city: string; region: string | null; postalCode: string | null; countryCode: string; phone: string | null; metadata: Record<string, unknown> | undefined; }
  • forStorefront: () => { id: string; firstName: string; lastName: string; company: string | null; line1: string; line2: string | null; city: string; region: string | null; postalCode: string | null; countryCode: string; phone: string | null; metadata: Record<string, unknown> | undefined; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; customerId: string | null; metadata: Record<string, unknown> | null; isDefaultShipping: boolean; isDefaultBilling: boolean; id: string; firstName: string; lastName: string; company: string | null; line1: string; line2: string | null; city: string; region: string | null; postalCode: string | null; countryCode: string; phone: string | null; }
  • resource: Address
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

adminTimestamps

Function

Every forAdmin variant carries record timestamps: admin tables sort and filter on them, and the audit trail reconciles against them.

(resource: { createdAt: DateTime | null; updatedAt: DateTime | null; }) => AdminTimestamps

AdminTimestamps

Interface

AdminTimestamps
Public members
  • createdAt: string | null
  • updatedAt: string | null

CartAdjustmentTransformer

Class

CartAdjustmentTransformer
Public members
  • toObject: () => { id: string; sourceType: string; sourceId: string | null; label: string; amount: SerializedMoney; included: boolean; eligible: boolean; position: number; metadata: Record<string, unknown> | undefined; }
  • forStorefront: () => { id: string; sourceType: string; sourceId: string | null; label: string; amount: SerializedMoney; included: boolean; eligible: boolean; position: number; metadata: Record<string, unknown> | undefined; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; cartId: string; cartLineId: string | null; amount: SerializedAdminMoney; metadata: Record<string, unknown> | null; id: string; sourceType: string; sourceId: string | null; label: string; included: boolean; eligible: boolean; position: number; }
  • resource: CartAdjustment
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

CartLineTransformer

Class

CartLineTransformer
Public members
  • toObject: () => { id: string; variantId: string; quantity: number; unitPrice: SerializedMoney; }
  • forStorefront: () => { total: SerializedMoney; variant: Item<ProductVariantTransformer, 1, "forStorefront"> | undefined; adjustments: Collection<CartAdjustmentTransformer, 1, "forStorefront"> | undefined; id: string; variantId: string; quantity: number; unitPrice: SerializedMoney; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; cartId: string; unitPrice: SerializedAdminMoney; total: SerializedAdminMoney; variant: Item<ProductVariantTransformer, 1, "forAdmin"> | undefined; adjustments: Collection<CartAdjustmentTransformer, 1, "forAdmin"> | undefined; metadata: Record<string, unknown> | null; id: string; variantId: string; quantity: number; }
  • resource: CartLine
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

CartTransformer

Class

CartTransformer
Public members
  • toObject: () => { id: string; token: string; status: CartStatus; currency: string; updatedAt: string | null; }
  • forStorefront: () => { email: string | null; shippingAddress: AddressInput | null; billingAddress: AddressInput | null; shippingMethodId: string | null; lines: Collection<CartLineTransformer, 1, "forStorefront"> | undefined; adjustments: Collection<CartAdjustmentTransformer, 1, "forStorefront"> | undefined; totals: { subtotal: SerializedMoney; shipping: SerializedMoney; tax: SerializedMoney; discount: SerializedMoney; grand: SerializedMoney; }; id: string; token: string; status: CartStatus; currency: string; updatedAt: string | null; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; id: string; status: CartStatus; currency: string; channelId: string; customerId: string | null; completedOrderId: string | null; email: string | null; shippingAddress: AddressInput | null; billingAddress: AddressInput | null; shippingMethodId: string | null; lastActivityAt: string | null; lines: Collection<CartLineTransformer, 1, "forAdmin"> | undefined; adjustments: Collection<CartAdjustmentTransformer, 1, "forAdmin"> | undefined; totals: { subtotal: SerializedAdminMoney; shipping: SerializedAdminMoney; tax: SerializedAdminMoney; discount: SerializedAdminMoney; grand: SerializedAdminMoney; }; metadata: Record<string, unknown> | null; }
  • resource: Cart
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

CategoryTransformer

Class

CategoryTransformer
Public members
  • toObject: () => { id: string; name: string; slug: string; path: string; }
  • forStorefront: () => { id: string; name: string; slug: string; path: string; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; parentId: string | null; position: number; metadata: Record<string, unknown> | null; id: string; name: string; slug: string; path: string; }
  • resource: Category
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

ChannelTransformer

Class

ChannelTransformer
Public members
  • toObject: () => { id: string; code: string; name: string; defaultCurrency: string; }
  • forStorefront: () => { supportedCurrencies: string[]; id: string; code: string; name: string; defaultCurrency: string; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; supportedCurrencies: string[]; isDefault: boolean; metadata: Record<string, unknown> | null; id: string; code: string; name: string; defaultCurrency: string; }
  • resource: Channel
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

CustomerTransformer

Class

CustomerTransformer
Public members
  • toObject: () => { id: string; email: string | null; firstName: string | null; lastName: string | null; }
  • forStorefront: () => { addresses: Collection<AddressTransformer, 1, "forStorefront"> | undefined; id: string; email: string | null; firstName: string | null; lastName: string | null; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; phone: string | null; userId: string | null; groupId: string | null; addresses: Collection<AddressTransformer, 1, "forAdmin"> | undefined; metadata: Record<string, unknown> | null; id: string; email: string | null; firstName: string | null; lastName: string | null; }
  • resource: Customer
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

InventoryItemTransformer

Class

InventoryItemTransformer
Public members
  • toObject: () => { id: string; variantId: string; tracked: boolean; backorderable: boolean; levels: Collection<InventoryLevelTransformer, 1, "toObject"> | undefined; }
  • forStorefront: () => { variantId: string; available: number; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; id: string; variantId: string; tracked: boolean; backorderable: boolean; levels: Collection<InventoryLevelTransformer, 1, "forAdmin"> | undefined; metadata: Record<string, unknown> | null; }
  • resource: InventoryItem
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

InventoryLevelTransformer

Class

InventoryLevelTransformer
Public members
  • toObject: () => { id: string; locationId: string; onHand: number; reserved: number; available: number; }
  • forStorefront: () => { locationId: string; available: number; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; itemId: string; reorderPoint: number | null; metadata: Record<string, unknown> | null; id: string; locationId: string; onHand: number; reserved: number; available: number; }
  • resource: InventoryLevel
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

OrderAdjustmentTransformer

Class

OrderAdjustmentTransformer
Public members
  • toObject: () => { id: string; sourceType: string; sourceId: string | null; label: string; amount: SerializedMoney; included: boolean; eligible: boolean; position: number; metadata: Record<string, unknown> | undefined; }
  • forStorefront: () => { id: string; sourceType: string; sourceId: string | null; label: string; amount: SerializedMoney; included: boolean; eligible: boolean; position: number; metadata: Record<string, unknown> | undefined; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; orderId: string; orderLineId: string | null; amount: SerializedAdminMoney; metadata: Record<string, unknown> | null; id: string; sourceType: string; sourceId: string | null; label: string; included: boolean; eligible: boolean; position: number; }
  • resource: OrderAdjustment
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

OrderLineTransformer

Class

OrderLineTransformer
Public members
  • toObject: () => { id: string; variantId: string | null; productName: string; variantName: string | null; sku: string | null; quantity: number; unitPrice: SerializedMoney; total: SerializedMoney; fulfilledQuantity: number; refundedQuantity: number; }
  • forStorefront: () => { id: string; variantId: string | null; productName: string; variantName: string | null; sku: string | null; quantity: number; unitPrice: SerializedMoney; total: SerializedMoney; fulfilledQuantity: number; refundedQuantity: number; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; orderId: string; cartLineId: string | null; unitPrice: SerializedAdminMoney; total: SerializedAdminMoney; metadata: Record<string, unknown> | null; id: string; variantId: string | null; productName: string; variantName: string | null; sku: string | null; quantity: number; fulfilledQuantity: number; refundedQuantity: number; }
  • resource: OrderLine
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

OrderTransformer

Class

OrderTransformer
Public members
  • toObject: () => { id: string; number: string; state: OrderState; currency: string; placedAt: string | null; }
  • forStorefront: () => { email: string; shippingAddress: AddressInput; billingAddress: AddressInput; lines: Collection<OrderLineTransformer, 1, "forStorefront"> | undefined; adjustments: Collection<OrderAdjustmentTransformer, 1, "forStorefront"> | undefined; payments: Collection<PaymentTransformer, 1, "forStorefront"> | undefined; paymentInstructions: Collection<PaymentInstructionTransformer, 1, "forStorefront"> | undefined; shipments: Collection<ShipmentTransformer, 1, "forStorefront"> | undefined; totals: { subtotal: SerializedMoney; shipping: SerializedMoney; tax: SerializedMoney; discount: SerializedMoney; grand: SerializedMoney; }; accessToken: string | undefined; id: string; number: string; state: OrderState; currency: string; placedAt: string | null; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; channelId: string; customerId: string | null; cartId: string | null; email: string; shippingAddress: AddressInput; billingAddress: AddressInput; lines: Collection<OrderLineTransformer, 1, "forAdmin"> | undefined; adjustments: Collection<OrderAdjustmentTransformer, 1, "forAdmin"> | undefined; payments: Collection<PaymentTransformer, 1, "forAdmin"> | undefined; paymentInstructions: Collection<PaymentInstructionTransformer, 1, "forAdmin"> | undefined; shipments: Collection<ShipmentTransformer, 1, "forAdmin"> | undefined; totals: { subtotal: SerializedAdminMoney; shipping: SerializedAdminMoney; tax: SerializedAdminMoney; discount: SerializedAdminMoney; grand: SerializedAdminMoney; }; metadata: Record<string, unknown> | null; id: string; number: string; state: OrderState; currency: string; placedAt: string | null; }
  • resource: Order
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

PaymentInstructionTransformer

Class

PaymentInstructionTransformer
Public members
  • toObject: () => PaymentInstructionData
  • forStorefront: () => PaymentInstructionData
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; intentId: string; orderId: string; metadata: Record<string, unknown> | null; id: string; expiresAt: string | null; displayName?: string; type: "virtual_account"; bank: string; accountNumber: string; } | { createdAt: string | null; updatedAt: string | null; intentId: string; orderId: string; metadata: Record<string, unknown> | null; id: string; expiresAt: string | null; displayName?: string; type: "qr_code"; payload: string; imageUrl?: string; } | { createdAt: string | null; updatedAt: string | null; intentId: string; orderId: string; metadata: Record<string, unknown> | null; id: string; expiresAt: string | null; displayName?: string; type: "redirect"; url: string; } | { createdAt: string | null; updatedAt: string | null; intentId: string; orderId: string; metadata: Record<string, unknown> | null; id: string; expiresAt: string | null; displayName?: string; type: "retail_outlet"; outlet: string; paymentCode: string; } | { createdAt: string | null; updatedAt: string | null; intentId: string; orderId: string; metadata: Record<string, unknown> | null; id: string; expiresAt: string | null; displayName?: string; type: "bank_transfer"; bankName: string; accountNumber: string; accountName?: string; }
  • resource: PaymentInstruction
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

PaymentIntentTransformer

Class

PaymentIntentTransformer
Public members
  • toObject: () => { id: string; provider: string; state: PaymentIntentState; amount: SerializedMoney; }
  • forStorefront: () => { id: string; provider: string; state: PaymentIntentState; amount: SerializedMoney; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; orderId: string | null; cartId: string | null; flow: "authorize_capture" | "deferred"; inventoryPolicy: "reserve" | "commit" | null; amount: SerializedAdminMoney; providerIntentId: string | null; lastError: Record<string, unknown> | null; expiresAt: string | null; reviewReason: string | null; providerEventTime: string | null; currentProviderStatus: string | null; metadata: Record<string, unknown> | null; id: string; provider: string; state: PaymentIntentState; }
  • resource: PaymentIntent
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

PaymentTransformer

Class

PaymentTransformer
Public members
  • toObject: () => { id: string; state: PaymentState; amount: SerializedMoney; }
  • forStorefront: () => { id: string; state: PaymentState; amount: SerializedMoney; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; intentId: string; orderId: string; amount: SerializedAdminMoney; providerChargeId: string | null; refunds: Collection<RefundTransformer, 1, "forAdmin"> | undefined; metadata: Record<string, unknown> | null; id: string; state: PaymentState; }
  • resource: Payment
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

PriceListTransformer

Class

PriceListTransformer
Public members
  • toObject: () => { id: string; name: string; priority: number; startsAt: string | null; endsAt: string | null; }
  • forStorefront: () => { id: string; name: string; priority: number; startsAt: string | null; endsAt: string | null; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; channelId: string | null; customerGroupId: string | null; isDefault: boolean; id: string; name: string; priority: number; startsAt: string | null; endsAt: string | null; }
  • resource: PriceList
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

PriceTransformer

Class

PriceTransformer
Public members
  • toObject: () => { id: string; variantId: string; unitPrice: SerializedMoney; minQuantity: number; }
  • forStorefront: () => { id: string; variantId: string; unitPrice: SerializedMoney; minQuantity: number; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; priceListId: string; unitPrice: SerializedAdminMoney; id: string; variantId: string; minQuantity: number; }
  • resource: Price
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

ProductImageTransformer

Class

ProductImageTransformer
Public members
  • toObject: () => { id: string; url: string; altText: string | null; position: number; mimeType: string; width: number; height: number; }
  • forStorefront: () => { variantIds: string[] | undefined; id: string; url: string; altText: string | null; position: number; mimeType: string; width: number; height: number; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; productId: string; disk: string | null; key: string | null; sizeBytes: number; variantIds: string[] | undefined; metadata: Record<string, unknown> | null; id: string; url: string; altText: string | null; position: number; mimeType: string; width: number; height: number; }
  • resource: ProductImage
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

ProductOptionTransformer

Class

Product options and their values. Storefronts read option values through variants, so this transformer has no forStorefront variant: it exists for the admin product form, which edits the option axes themselves.

ProductOptionTransformer
Public members
  • toObject: () => { id: string; name: string; position: number; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; productId: string; values: { id: string; value: string; position: number; }[] | undefined; metadata: Record<string, unknown> | null; id: string; name: string; position: number; }
  • resource: ProductOption
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

ProductTransformer

Class

ProductTransformer
Public members
  • toObject: () => { id: string; name: string; slug: string; status: ProductStatus; }
  • forStorefront: () => { description: string | null; variants: Collection<ProductVariantTransformer, 1, "forStorefront"> | undefined; categories: Collection<CategoryTransformer, 1, "forStorefront"> | undefined; images: Collection<ProductImageTransformer, 1, "forStorefront"> | undefined; id: string; name: string; slug: string; status: ProductStatus; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; description: string | null; options: Collection<ProductOptionTransformer, 1, "forAdmin"> | undefined; variants: Collection<ProductVariantTransformer, 1, "forAdmin"> | undefined; categories: Collection<CategoryTransformer, 1, "forAdmin"> | undefined; images: Collection<ProductImageTransformer, 1, "forAdmin"> | undefined; metadata: Record<string, unknown> | null; id: string; name: string; slug: string; status: ProductStatus; }
  • resource: Product
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

ProductVariantTransformer

Class

ProductVariantTransformer
Public members
  • toObject: () => { id: string; sku: string | null; name: string | null; isDefault: boolean; weightGrams: number | null; lengthMm: number | null; widthMm: number | null; heightMm: number | null; }
  • forStorefront: () => { optionValues: { id: string; value: string; }[] | undefined; price: SerializedMoney | undefined; availability: { tracked: boolean; backorderable: boolean; quantity: number | null; available: boolean; } | undefined; id: string; sku: string | null; name: string | null; isDefault: boolean; weightGrams: number | null; lengthMm: number | null; widthMm: number | null; heightMm: number | null; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; productId: string; taxCategoryId: string | null; position: number; optionValues: { id: string; value: string; }[] | undefined; metadata: Record<string, unknown> | null; id: string; sku: string | null; name: string | null; isDefault: boolean; weightGrams: number | null; lengthMm: number | null; widthMm: number | null; heightMm: number | null; }
  • resource: ProductVariant
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

RefundTransformer

Class

RefundTransformer
Public members
  • toObject: () => { id: string; state: RefundState; amount: SerializedMoney; reason: string | null; }
  • forStorefront: () => { id: string; state: RefundState; amount: SerializedMoney; reason: string | null; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; paymentId: string; amount: SerializedAdminMoney; providerRefundId: string | null; metadata: Record<string, unknown> | null; id: string; state: RefundState; reason: string | null; }
  • resource: Refund
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

ReservationTransformer

Class

ReservationTransformer
Public members
  • toObject: () => { id: string; cartId: string; cartLineId: string; quantity: number; state: ReservationState; expiresAt: string | null; }
  • forStorefront: () => { id: string; cartId: string; cartLineId: string; quantity: number; state: ReservationState; expiresAt: string | null; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; levelId: string; returnedQuantity: number; metadata: Record<string, unknown> | null; id: string; cartId: string; cartLineId: string; quantity: number; state: ReservationState; expiresAt: string | null; }
  • resource: Reservation
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

serializeAdminMoney

Function

(money: Money, locale?: string) => SerializedAdminMoney

SerializedAdminMoney

Interface

Admin surfaces receive the storefront money shape plus an explicit minor-unit field so charts and exports never parse a locale-formatted string.

SerializedAdminMoney
Public members
  • amountMinor: string
  • amount: string
  • currency: string
  • formatted: string

SerializedMoney

Interface

SerializedMoney
Public members
  • amount: string
  • currency: string
  • formatted: string

serializeMoney

Function

(money: Money, locale?: string) => SerializedMoney

ShipmentTransformer

Class

ShipmentTransformer
Public members
  • toObject: () => { id: string; state: ShipmentState; carrier: string | null; trackingNumber: string | null; waybill: string | null; handedOffAt: string | null; shippedAt: string | null; deliveredAt: string | null; deliveryFailedAt: string | null; returnedAt: string | null; metadata: Record<string, unknown> | undefined; }
  • forStorefront: () => { id: string; state: ShipmentState; carrier: string | null; trackingNumber: string | null; waybill: string | null; handedOffAt: string | null; shippedAt: string | null; deliveredAt: string | null; deliveryFailedAt: string | null; returnedAt: string | null; metadata: Record<string, unknown> | undefined; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; orderId: string; provider: string | null; providerShipmentId: string | null; inventoryRestockedAt: string | null; metadata: Record<string, unknown> | null; id: string; state: ShipmentState; carrier: string | null; trackingNumber: string | null; waybill: string | null; handedOffAt: string | null; shippedAt: string | null; deliveredAt: string | null; deliveryFailedAt: string | null; returnedAt: string | null; }
  • resource: Shipment
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

ShippingMethodTransformer

Class

ShippingMethodTransformer
Public members
  • toObject: () => { id: string; code: string; name: string; }
  • forStorefront: () => { price: SerializedMoney | undefined; id: string; code: string; name: string; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; calculator: string; calculatorConfig: Record<string, unknown>; channelId: string | null; position: number; enabled: boolean; metadata: Record<string, unknown> | null; id: string; code: string; name: string; }
  • resource: ShippingMethod
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

StockLocationTransformer

Class

StockLocationTransformer
Public members
  • toObject: () => { id: string; code: string; name: string; }
  • forStorefront: () => { id: string; code: string; name: string; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; address: AddressInput | null; isDefault: boolean; metadata: Record<string, unknown> | null; id: string; code: string; name: string; }
  • resource: StockLocation
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

TaxCategoryTransformer

Class

TaxCategoryTransformer
Public members
  • toObject: () => { id: string; code: string; name: string; }
  • forStorefront: () => { id: string; code: string; name: string; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; metadata: Record<string, unknown> | null; id: string; code: string; name: string; }
  • resource: TaxCategory
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

TaxRateTransformer

Class

TaxRateTransformer
Public members
  • toObject: () => { id: string; name: string; rateBp: number; }
  • forStorefront: () => { id: string; name: string; rateBp: number; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; zoneId: string; taxCategoryId: string | null; metadata: Record<string, unknown> | null; id: string; name: string; rateBp: number; }
  • resource: TaxRate
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

TaxZoneTransformer

Class

TaxZoneTransformer
Public members
  • toObject: () => { id: string; name: string; }
  • forStorefront: () => { id: string; name: string; }
  • forAdmin: () => { createdAt: string | null; updatedAt: string | null; countryCodes: string[]; regionPattern: string | null; postalPattern: string | null; metadata: Record<string, unknown> | null; id: string; name: string; }
  • resource: TaxZone
  • whenLoaded: <Value>(value: Value) => Maybe<Value>
  • omit: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Omit<Data, Keys>
  • pick: <Data extends Record<string, any>, Keys extends { [K in keyof Data]: Data[K] extends Function ? never : K; }[keyof Data]>(data: Data, keys: Keys[] | readonly Keys[]) => Pick<Data, Keys>
  • when: <Value, Fallback = undefined>(conditional: boolean, resolver: () => Value, fallback?: Fallback) => Value | Fallback

@adocommercekit/core/types

AddressInput

Interface

AddressInput
Public members
  • firstName: string
  • lastName: string
  • company: string | undefined
  • line1: string
  • line2: string | undefined
  • city: string
  • region: string | undefined
  • postalCode: string | undefined
  • countryCode: string
  • phone: string | undefined
  • metadata: Record<string, unknown> | undefined

AdjustmentDraft

Interface

AdjustmentDraft
Public members
  • cartLineId: string | null | undefined
  • sourceType: string
  • sourceId: string | null | undefined
  • label: string
  • amount: Money
  • included: boolean | undefined
  • eligible: boolean | undefined
  • position: number
  • metadata: Record<string, unknown> | undefined

AdminCursor

Interface

The decoded keyset position: the sort key of the last row of the previous page plus its id, which breaks ties deterministically.

AdminCursor
Public members
  • key: string
  • id: string

AdminKeysetWindow

Interface

AdminKeysetWindow
Public members
  • column: string
  • value: string | number | bigint
  • idColumn: string
  • id: string
  • direction: AdminSortDirection

AdminListPage

Interface

One page of an admin list query (ASPEC §3.3).

nextCursor is null on the last page. total is null whenever the filtered count is not obtainable from a single indexed COUNT(*); the UI renders “1–25 of many” in that case.

AdminListPage<T>
Public members
  • items: T[]
  • nextCursor: string | null
  • total: number | null

AdminSortDirection

Type

AdminSortDirection

CartProcessor

Interface

CartProcessor
Public members
  • name: string
  • position: number
  • process: (cart: Cart, ctx: RecalculationContext) => Promise<AdjustmentDraft[]>

CartSnapshot

Interface

CartSnapshot
Public members
  • id: string
  • currency: string
  • lines: { id: string; variantId: string; quantity: number; unitPrice: Money; metadata: Record<string, unknown> | null; }[]
  • shippingAddress: AddressInput | null
  • shippingMethodId: string | null
  • subtotal: Money

CartTokenStrategy

Interface

CartTokenStrategy
Public members
  • read: (ctx: HttpContext) => string | null
  • issue: (ctx: HttpContext, token: string) => void

CartTotals

Interface

CartTotals
Public members
  • subtotal: Money
  • shippingTotal: Money
  • taxTotal: Money
  • discountTotal: Money
  • grandTotal: Money

ChannelContext

Interface

ChannelContext
Public members
  • channelCode: string
  • currency: string
  • customerId: string | undefined

CheckoutResult

Interface

CheckoutResult
Public members
  • order: Order

CommerceConfigInput

Interface

CommerceConfigInput
Public members
  • tablePrefix: string | undefined
  • channels: { default: string; }
  • currencies: { supported: CurrencyCode[]; default: CurrencyCode; exponents?: Partial<Record<CurrencyCode, 0 | 2 | 3>>; rounding?: Rounding; }
  • customers: { userModel: LazyImport<unknown> | null; userForeignKey?: string; }
  • carts: { tokenStrategy?: DriverFactory; abandonedAfterMinutes?: number; guardMaxLineQuantity?: number; }
  • pricing: { resolver?: DriverFactory; taxInclusivePricing?: boolean; }
  • images: { storage?: DriverFactory<ProductImageStorage>; maxBytes?: number; maxPerProduct?: number; } | undefined
  • inventory: { reservationTtlMinutes?: number; backorderPolicy?: "deny" | "allow" | "per_item"; allocation?: DriverFactory; }
  • payments: { default: string; methods: Record<string, DriverFactory>; captureMode?: "automatic" | "manual"; deferred?: { inventoryPolicy?: "reserve" | "commit"; }; codFee?: { amount: bigint | number | string; currency: string; label?: string; }; }
  • shipping: { calculators: Record<string, DriverFactory>; eligibility?: DriverFactory; quoteProviders?: Record<string, DriverFactory>; selectionSecret?: string; }
  • fulfillment: { providers?: Record<string, DriverFactory>; } | undefined
  • taxes: { calculator?: DriverFactory; addressResolver?: DriverFactory; }
  • orders: { numberGenerator?: DriverFactory; autoConfirm?: boolean; }
  • models: Partial<ModelRegistryOverrides> | undefined
  • events: { outbox?: { enabled: boolean; drainBatchSize?: number; }; } | undefined
  • jobs: { dispatcher?: "queue" | "inline"; } | undefined

CreateProductInput

Interface

CreateProductInput
Public members
  • name: string
  • slug: string
  • description: string | null | undefined
  • status: "draft" | "active" | "archived" | undefined
  • metadata: Record<string, unknown> | undefined
  • channelIds: string[] | undefined

CustomerSnapshot

Interface

CustomerSnapshot
Public members
  • id: string | undefined
  • email: string | null | undefined
  • firstName: string | null | undefined
  • lastName: string | null | undefined

DeferredInventoryPolicy

Type

DeferredInventoryPolicy

DeferredPaymentStatus

Type

DeferredPaymentStatus

DriverFactory

Type

DriverFactory<T>

DynamicShippingQuoteProvider

Interface

DynamicShippingQuoteProvider
Public members
  • code: string
  • quote: (input: ShippingQuoteRequest) => Promise<ShippingQuoteDraft[]>

FulfillmentProvider

Interface

FulfillmentProvider
Public members
  • code: string
  • prepare: (input: { shipmentId: string; order: Order; parcels: Parcel[]; service?: string; cod?: { amount: Money; }; insurance?: { amount: Money; }; idempotencyKey: string; }) => Promise<{ providerShipmentId: string; waybill: string; trackingNumber?: string; carrier?: string; raw?: unknown; }>
  • status: ((providerShipmentId: string) => Promise<{ status: FulfillmentStatus; occurredAt?: DateTime; raw?: unknown; }>) | undefined

FulfillmentStatus

Type

FulfillmentStatus

InventoryLevelSnapshot

Interface

InventoryLevelSnapshot
Public members
  • id: string
  • itemId: string
  • locationId: string
  • onHand: number
  • reserved: number
  • available: number
  • isDefault: boolean

LazyImport

Type

LazyImport<T>

ModelRegistryOverrides

Interface

ModelRegistryOverrides
Public members
  • channel: LazyImport<unknown>
  • product: LazyImport<unknown>
  • productImage: LazyImport<unknown>
  • productOption: LazyImport<unknown>
  • productOptionValue: LazyImport<unknown>
  • productVariant: LazyImport<unknown>
  • category: LazyImport<unknown>
  • priceList: LazyImport<unknown>
  • price: LazyImport<unknown>
  • customerGroup: LazyImport<unknown>
  • customer: LazyImport<unknown>
  • address: LazyImport<unknown>
  • cart: LazyImport<unknown>
  • cartLine: LazyImport<unknown>
  • cartAdjustment: LazyImport<unknown>
  • shippingMethod: LazyImport<unknown>
  • taxZone: LazyImport<unknown>
  • taxRate: LazyImport<unknown>
  • taxCategory: LazyImport<unknown>
  • order: LazyImport<unknown>
  • orderLine: LazyImport<unknown>
  • paymentIntent: LazyImport<unknown>
  • payment: LazyImport<unknown>
  • paymentInstruction: LazyImport<unknown>
  • shipment: LazyImport<unknown>
  • stockLocation: LazyImport<unknown>
  • inventoryItem: LazyImport<unknown>
  • inventoryLevel: LazyImport<unknown>
  • reservation: LazyImport<unknown>
  • orderAdjustment: LazyImport<unknown>
  • shipmentLine: LazyImport<unknown>
  • refund: LazyImport<unknown>
  • webhookEvent: LazyImport<unknown>
  • idempotencyKey: LazyImport<unknown>
  • eventOutbox: LazyImport<unknown>

MutationOptions

Interface

MutationOptions
Public members
  • trx: TransactionClientContract | undefined
  • actor: string | undefined

NormalizedPaymentEvent

Type

NormalizedPaymentEvent

OrderNumberGenerator

Interface

OrderNumberGenerator
Public members
  • next: (order: PendingOrder, trx?: TransactionClientContract) => Promise<string>

Parcel

Interface

Parcel
Public members
  • reference: string
  • quantity: number
  • weightGrams: number
  • declaredValue: Money | undefined
  • lengthMm: number | undefined
  • widthMm: number | undefined
  • heightMm: number | undefined

PaymentFlow

Type

PaymentFlow

PaymentInstructionData

Type

PaymentInstructionData

PaymentInstructionDraft

Type

PaymentInstructionDraft

PaymentInstructionKind

Type

PaymentInstructionKind

PaymentProvider

Interface

PaymentProvider
Public members
  • code: string
  • capabilities: () => PaymentProviderCapabilities
  • createIntent: (input: { amount: Money; currency: string; reference: string; customer?: CustomerSnapshot; idempotencyKey: string; }) => Promise<{ providerIntentId: string; clientSecret?: string; state: "created" | "requires_action" | "authorized" | "pending"; instructions?: PaymentInstructionDraft[]; expiresAt?: DateTime; raw?: unknown; adjustment?: AdjustmentDraft; }>
  • confirm: (input: { providerIntentId: string; token?: string; idempotencyKey: string; }) => Promise<ProviderPaymentState>
  • capture: (input: { providerIntentId: string; amount: Money; idempotencyKey: string; }) => Promise<{ providerChargeId: string; raw?: unknown; }>
  • refund: (input: { providerChargeId: string; amount: Money; reason?: string; idempotencyKey: string; }) => Promise<{ providerRefundId: string; raw?: unknown; }>
  • void: (input: { providerIntentId: string; idempotencyKey: string; trx?: TransactionClientContract; }) => Promise<void>
  • retrieveIntent: ((providerIntentId: string) => Promise<DeferredPaymentStatus>) | undefined
  • healthCheck: (() => Promise<void>) | undefined
  • verifyWebhook: (raw: RawWebhookRequest) => Promise<boolean>
  • normalizeWebhook: (raw: RawWebhookRequest) => Promise<NormalizedPaymentEvent | { type: "unhandled"; providerEventId: string; raw?: unknown; }>

PaymentProviderCapabilities

Interface

PaymentProviderCapabilities
Public members
  • authorize: boolean
  • capture: boolean
  • refund: boolean
  • void: boolean
  • clientConfirmation: boolean
  • flow: PaymentFlow | undefined
  • cod: boolean | undefined

PendingOrder

Interface

PendingOrder
Public members
  • channelId: string
  • currency: string
  • cartId: string

PlaceOrderInput

Interface

PlaceOrderInput
Public members
  • payment: { method: string; token?: string; intentId?: string; }
  • shippingQuoteToken: string | undefined
  • idempotencyKey: string | undefined

PriceResolver

Interface

PriceResolver
Public members
  • resolve: (input: { variantId: string; quantity: number; ctx: ChannelContext; trx?: TransactionClientContract; }) => Promise<{ unitPrice: Money; priceListId: string | null; }>

ProductImageStorage

Interface

ProductImageStorage
Public members
  • disk: string
  • put: (key: string, contents: Uint8Array, options: { contentType: string; contentLength: number; }) => Promise<{ url: string; }>
  • delete: (file: { disk: string; key: string; }) => Promise<void>

ProviderPaymentState

Type

ProviderPaymentState

RawWebhookRequest

Interface

RawWebhookRequest
Public members
  • body: Buffer<ArrayBufferLike>
  • headers: Record<string, string>

RecalculationContext

Interface

RecalculationContext
Public members
  • channel: ChannelContext
  • lines: CartLine[]
  • previousAdjustments: CartAdjustment[]
  • generatedAdjustments: AdjustmentDraft[]
  • trx: TransactionClientContract

ResolvedCommerceConfig

Interface

ResolvedCommerceConfig
Public members
  • tablePrefix: string
  • channels: { default: string; }
  • currencies: { supported: CurrencyCode[]; default: CurrencyCode; exponents: Readonly<Partial<Record<CurrencyCode, 0 | 2 | 3>>>; rounding: Rounding; }
  • customers: { userModel: LazyImport<unknown> | null; userForeignKey: string; }
  • carts: { tokenStrategy: DriverFactory; abandonedAfterMinutes: number; guardMaxLineQuantity: number; }
  • pricing: { resolver: DriverFactory; taxInclusivePricing: boolean; }
  • images: { storage?: DriverFactory<ProductImageStorage>; maxBytes: number; maxPerProduct: number; }
  • inventory: { reservationTtlMinutes: number; backorderPolicy: "deny" | "allow" | "per_item"; allocation?: DriverFactory; }
  • payments: { default: string; methods: Readonly<Record<string, DriverFactory>>; captureMode: "automatic" | "manual"; deferred: { inventoryPolicy: "reserve" | "commit"; }; codFee?: { amount: bigint | number | string; currency: string; label: string; }; }
  • shipping: { calculators: Readonly<Record<string, DriverFactory>>; eligibility?: DriverFactory; quoteProviders: Readonly<Record<string, DriverFactory>>; selectionSecret?: string; }
  • fulfillment: { providers: Readonly<Record<string, DriverFactory>>; }
  • taxes: { calculator: DriverFactory; addressResolver?: DriverFactory; }
  • orders: { numberGenerator?: DriverFactory; autoConfirm: boolean; }
  • models: Readonly<Partial<ModelRegistryOverrides>>
  • events: { outbox: { enabled: boolean; drainBatchSize: number; }; }
  • jobs: { dispatcher: "queue" | "inline"; automatic: boolean; }

ShippingCalculator

Interface

ShippingCalculator
Public members
  • code: string
  • calculate: (input: { cart: CartSnapshot; method: ShippingMethodConfig; }) => Promise<Money>

ShippingEligibility

Interface

ShippingEligibility
Public members
  • eligibleMethods: (cart: CartSnapshot, methods: ShippingMethodConfig[]) => Promise<string[]>

ShippingMethodConfig

Interface

ShippingMethodConfig
Public members
  • id: string
  • code: string
  • name: string
  • calculator: string
  • calculatorConfig: Record<string, unknown>

ShippingQuote

Interface

ShippingQuote
Public members
  • provider: string
  • service: string
  • name: string
  • price: Money
  • expiresAt: DateTime<boolean>
  • selectionToken: string
  • metadata: Record<string, unknown> | undefined

ShippingQuoteDraft

Interface

ShippingQuoteDraft
Public members
  • service: string
  • name: string
  • price: Money
  • expiresAt: DateTime<boolean>
  • metadata: Record<string, unknown> | undefined

ShippingQuoteRequest

Interface

ShippingQuoteRequest
Public members
  • cart: CartSnapshot
  • parcels: Parcel[]
  • cod: { amount: Money; } | undefined
  • insurance: { amount: Money; } | undefined

Stateful

Interface

Stateful<S>
Public members
  • id: string
  • state: S

StateMachineDatabase

Interface

StateMachineDatabase<Trx>
Public members
  • transaction: <R>(callback: (trx: Trx) => Promise<R>) => Promise<R>

StateMachineDefinition

Interface

StateMachineDefinition<S, T>
Public members
  • name: string
  • states: readonly S[]
  • initial: S
  • transitions: Readonly<Record<T, { readonly from: readonly S[]; readonly to: S; }>>

StateMachinePersistence

Interface

StateMachinePersistence<S, T, Trx>
Public members
  • transaction: <R>(callback: (trx: Trx) => Promise<R>) => Promise<R>
  • conditionalUpdate: (subjectId: string, from: S, to: S, trx: Trx) => Promise<boolean>
  • insertAudit: (audit: StateTransitionAudit<S, T>, trx: Trx) => Promise<void>
  • bufferEvent: (name: string, payload: Readonly<Record<string, unknown>>, trx: Trx) => Promise<void> | void

StateMachineQuery

Interface

StateMachineQuery
Public members
  • where: (column: string | Record<string, unknown>, value?: unknown) => StateMachineQuery
  • update: (values: Record<string, unknown>) => PromiseLike<number>

StateMachineTransaction

Interface

StateMachineTransaction
Public members
  • from: (table: string) => StateMachineQuery
  • table: (table: string) => StateMachineInsertQuery

StateTransitionAudit

Interface

StateTransitionAudit<S, T>
Public members
  • machine: string
  • subjectId: string
  • transition: T
  • from: S
  • to: S
  • actor: string | undefined
  • context: TransitionContext
  • createdAt: Date

StockAllocationStrategy

Interface

StockAllocationStrategy
Public members
  • allocate: (input: { itemId: string; quantity: number; levels: InventoryLevelSnapshot[]; backorderable: boolean; }) => Promise<Array<{ levelId: string; quantity: number; }>>

TaxableLine

Interface

TaxableLine
Public members
  • lineId: string
  • amount: Money
  • taxCategoryCode: string | null
  • quantity: number

TaxCalculator

Interface

TaxCalculator
Public members
  • calculate: (input: { lines: TaxableLine[]; address: AddressInput | null; inclusive: boolean; trx?: TransactionClientContract; }) => Promise<TaxLineResult[]>

TaxLineResult

Interface

TaxLineResult
Public members
  • lineId: string
  • rateName: string
  • rateBp: number
  • amount: Money
  • included: boolean
  • sourceId: string | undefined
  • metadata: Record<string, unknown> | undefined

TransitionContext

Interface

TransitionContext
Public members
  • actor: string | undefined

TransitionGuard

Type

TransitionGuard<S, T, Trx>

TransitionHook

Type

TransitionHook<S, T, Trx>

UpdateProductInput

Interface

UpdateProductInput
Public members
  • name: string | undefined
  • slug: string | undefined
  • description: string | null | undefined
  • status: "draft" | "active" | "archived" | undefined
  • metadata: Record<string, unknown> | undefined
  • channelIds: string[] | undefined

WebhookIngestResult

Interface

WebhookIngestResult
Public members
  • status: "processed" | "unhandled" | "duplicate"
  • providerEventId: string

WorkflowLogger

Interface

WorkflowLogger
Public members
  • error: (message: string, context: Readonly<Record<string, unknown>>) => void

WorkflowStep

Interface

WorkflowStep<C>
Public members
  • name: string
  • run: (context: C) => Promise<void>
  • compensate: ((context: C) => Promise<void>) | undefined
  • boundary: "trx" | "external"

WorkflowTransactionRunner

Interface

WorkflowTransactionRunner<C>
Public members
  • transaction: (context: C, callback: (transactionContext: C) => Promise<void>) => Promise<void>

@adocommercekit/core/validators

addCartLineValidator

Value

Validator

addressSchema

Value

SchemaTypes

createChannelValidator

Value

Validator

createCustomerValidator

Value

Validator

createPriceValidator

Value

Validator

createProductOptionValidator

Value

Validator

createProductValidator

Value

Validator

setCartAddressesValidator

Value

Validator

setCartEmailValidator

Value

Validator

updateCartLineValidator

Value

Validator

@adocommercekit/core/errors

CartNotActiveException

Class

CartNotActiveException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CartPricesChangedException

Class

CartPricesChangedException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

COMMERCE_ERROR_STATUSES

Value

Readonly<Partial<Record<CommerceErrorCode, number | "varies">>>

CommerceConfigException

Class

CommerceConfigException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CommerceErrorCode

Type

CommerceErrorCode

CommerceErrorDetails

Type

Readonly<Record<string, unknown>>

CommerceException

Class

CommerceException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CommerceForbiddenException

Class

Raised at the HTTP/Inertia boundary when the actor lacks the ability an admin endpoint declares. The ability name travels in the payload on purpose: it is frozen catalog vocabulary (ASPEC §3.2), not a secret, and the panel needs it to explain the denial.

CommerceForbiddenException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

CompensationError

Interface

CompensationError
Public members
  • step: string
  • error: unknown

CurrencyMismatchException

Class

CurrencyMismatchException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

IdempotencyConflictException

Class

IdempotencyConflictException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

InsufficientStockException

Class

InsufficientStockException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

LineQuantityException

Class

LineQuantityException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

PaymentDeclineCode

Type

PaymentDeclineCode

PaymentDeclinedException

Class

PaymentDeclinedException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

PaymentProviderException

Class

PaymentProviderException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

PriceNotFoundException

Class

PriceNotFoundException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

ProductInUseException

Class

ProductInUseException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

renderCommerceException

Function

(error: CommerceException) => { error: { details?: Readonly<Record<string, unknown>> | undefined; code: CommerceErrorCode; message: string; }; }

ShippingNotEligibleException

Class

ShippingNotEligibleException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

StateTransitionException

Class

StateTransitionException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

WebhookSignatureException

Class

WebhookSignatureException
Public members
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

WorkflowFailedException

Class

WorkflowFailedException
Public members
  • compensationErrors: readonly CompensationError[]
  • code: CommerceErrorCode
  • status: number
  • details: Readonly<Record<string, unknown>>
  • handle: (error: CommerceException, ctx: { response: { status(code: number): { send(body: unknown): unknown; }; }; }) => unknown
  • name: string
  • help: string | undefined
  • toString: () => string
  • message: string
  • stack: string | undefined
  • cause: unknown

@adocommercekit/core/jobs

DrainEventOutbox

Class

DrainEventOutbox
Public members
  • outbox: EventOutboxService
  • handle: () => Promise<{ sent: number; failed: number; }>

ExpireAbandonedCarts

Class

ExpireAbandonedCarts
Public members
  • db: Database
  • registry: ModelRegistry
  • config: ResolvedCommerceConfig
  • events: TransactionalEventEmitter
  • handle: () => Promise<number>

ExpirePendingPayments

Class

ExpirePendingPayments
Public members
  • payments: PaymentService
  • handle: () => Promise<number>

ExpireStaleReservations

Class

ExpireStaleReservations
Public members
  • inventory: InventoryService
  • handle: () => Promise<number>

JOB_NAMES

Value

{ readonly expireStaleReservations: "commerce.expire_stale_reservations"; readonly expirePendingPayments: "commerce.expire_pending_payments"; readonly expireAbandonedCarts: "commerce.expire_abandoned_carts"; readonly reconcileStuckCheckouts: "commerce.reconcile_stuck_checkouts"; readonly drainEventOutbox: "commerce.drain_event_outbox"; readonly purgeExpiredIdempotencyKeys: "commerce.purge_expired_idempotency_keys"; }

PurgeExpiredIdempotencyKeys

Class

PurgeExpiredIdempotencyKeys
Public members
  • idempotency: IdempotencyService
  • handle: () => Promise<number>

ReconcileStuckCheckouts

Class

ReconcileStuckCheckouts
Public members
  • checkout: CheckoutService
  • config: ResolvedCommerceConfig
  • handle: () => Promise<number>

@adocommercekit/core/upgrade

applyUpgradeItem

Function

(root: string, item: UpgradePlanItem) => Promise<void>

inspectUpgrade

Function

(root: string, artifacts: readonly UpgradeArtifact[]) => Promise<UpgradePlanItem[]>

inspectUpgradeArtifact

Function

(root: string, artifact: UpgradeArtifact) => Promise<UpgradePlanItem>

publicationBasePath

Function

(root: string, marker: string) => string

recordPublicationBase

Function

(root: string, artifact: UpgradeArtifact) => Promise<boolean>

sha256

Function

(source: string) => string

UpgradeAction

Type

UpgradeAction

UpgradeArtifact

Interface

UpgradeArtifact
Public members
  • marker: string
  • destination: string
  • source: string

UpgradePlanItem

Interface

UpgradePlanItem
Public members
  • action: UpgradeAction
  • publishedPath: string
  • basePath: string
  • baseSource: string | undefined
  • publishedSource: string | undefined
  • marker: string
  • destination: string
  • source: string

@adocommercekit/storefront-api/contract

STOREFRONT_API_PREFIX

Value

"/api/commerce"

StorefrontEndpoint

Type

{ readonly method: "GET"; readonly path: "/products"; readonly name: "commerce.products.index"; } | { readonly method: "GET"; readonly path: "/products/:slug"; readonly name: "commerce.products.show"; } | { readonly method: "GET"; readonly path: "/cart"; readonly name: "commerce.cart.show"; } | { readonly method: "POST"; readonly path: "/cart/lines"; readonly name: "commerce.cart.lines.store"; } | { readonly method: "PATCH"; readonly path: "/cart/lines/:id"; readonly name: "commerce.cart.lines.update"; } | { readonly method: "DELETE"; readonly path: "/cart/lines/:id"; readonly name: "commerce.cart.lines.destroy"; } | { readonly method: "PUT"; readonly path: "/cart/email"; readonly name: "commerce.cart.email"; } | { readonly method: "PUT"; readonly path: "/cart/addresses"; readonly name: "commerce.cart.addresses"; } | { readonly method: "GET"; readonly path: "/cart/shipping-methods"; readonly name: "commerce.cart.shippingMethods"; } | { readonly method: "PUT"; readonly path: "/cart/shipping-method"; readonly name: "commerce.cart.shippingMethod"; } | { readonly method: "POST"; readonly path: "/checkout"; readonly name: "commerce.checkout.place"; } | { readonly method: "GET"; readonly path: "/orders/:number"; readonly name: "commerce.orders.show"; } | { readonly method: "GET"; readonly path: "/orders/:number/payment-instructions"; readonly name: "commerce.orders.paymentInstructions"; } | { readonly method: "POST"; readonly path: "/webhooks/payments/:provider"; readonly name: "commerce.webhooks.payments"; }

storefrontEndpoints

Value

readonly [{ readonly method: "GET"; readonly path: "/products"; readonly name: "commerce.products.index"; }, { readonly method: "GET"; readonly path: "/products/:slug"; readonly name: "commerce.products.show"; }, { readonly method: "GET"; readonly path: "/cart"; readonly name: "commerce.cart.show"; }, { readonly method: "POST"; readonly path: "/cart/lines"; readonly name: "commerce.cart.lines.store"; }, { readonly method: "PATCH"; readonly path: "/cart/lines/:id"; readonly name: "commerce.cart.lines.update"; }, { readonly method: "DELETE"; readonly path: "/cart/lines/:id"; readonly name: "commerce.cart.lines.destroy"; }, { readonly method: "PUT"; readonly path: "/cart/email"; readonly name: "commerce.cart.email"; }, { readonly method: "PUT"; readonly path: "/cart/addresses"; readonly name: "commerce.cart.addresses"; }, { readonly method: "GET"; readonly path: "/cart/shipping-methods"; readonly name: "commerce.cart.shippingMethods"; }, { readonly method: "PUT"; readonly path: "/cart/shipping-method"; readonly name: "commerce.cart.shippingMethod"; }, { readonly method: "POST"; readonly path: "/checkout"; readonly name: "commerce.checkout.place"; }, { readonly method: "GET"; readonly path: "/orders/:number"; readonly name: "commerce.orders.show"; }, { readonly method: "GET"; readonly path: "/orders/:number/payment-instructions"; readonly name: "commerce.orders.paymentInstructions"; }, { readonly method: "POST"; readonly path: "/webhooks/payments/:provider"; readonly name: "commerce.webhooks.payments"; }]

@adocommercekit/admin-api

ADMIN_API_PREFIX

Value

"/api/commerce/admin"

ADMIN_AUDIT_TABLE

Value

"admin_audit_entries"

ADMIN_RATE_LIMITS

Value

Rate-limit tiers the published routes stub applies (ASPEC §4.2).

{ readonly mutation: { readonly scope: "admin-mutation"; readonly requests: 60; readonly windowSeconds: 60; }; readonly read: { readonly scope: "admin-read"; readonly requests: 240; readonly windowSeconds: 60; }; readonly metrics: { readonly scope: "admin-metrics"; readonly requests: 120; readonly windowSeconds: 60; }; }

ADMIN_SHIPMENT_TRANSITIONS

Value

Readonly<Record<ShipmentState, readonly AdminShipmentTransition[]>>

adminAbilityTarget

Function

(ability: CommerceAbility) => AdminAbilityTarget

AdminAbilityTarget

Interface

Where a frozen ability is enforced: the shipped policy class the host extends and the method on it. Derived from commercePolicyAbilities so the catalog stays the single source of truth — an ability core adds without a policy method makes this module throw at load, not silently allow.

AdminAbilityTarget
Public members
  • policy: string | number | symbol
  • method: string

adminAbilityTargets

Function

The complete ability → policy method map, for host policy scaffolding and docs.

() => ReadonlyMap<CommerceAbility, AdminAbilityTarget>

AdminActor

Interface

The actor an admin request runs as, resolved by the published auth middleware from the host’s own user model. The engine never reads host user tables.

The three fields serve three consumers and are deliberately not collapsed: id is the opaque value recorded verbatim in the audit trail, label is what the trail and the panel header display, and user is the host principal the Bouncer policy methods receive so role mapping works against the host’s own model rather than an engine projection of it.

AdminActor
Public members
  • id: string
  • label: string | null
  • user: unknown

AdminAuditEntry

Type

AdminAuditEntry

AdminAuditEntryInput

Interface

AdminAuditEntryInput
Public members
  • actorId: string
  • actorLabel: string | null | undefined
  • ability: CommerceAbility
  • subjectType: AdminAuditSubjectType
  • subjectId: string
  • summary: Readonly<Record<string, string | number | boolean | null>>
  • idempotencyKey: string | null | undefined
  • requestId: string | null | undefined

AdminAuditFilter

Interface

AdminAuditFilter
Public members
  • actorId: string | undefined
  • ability: CommerceAbility[] | undefined
  • subjectType: AdminAuditSubjectType | undefined
  • subjectId: string | undefined
  • createdAfter: DateTime<boolean> | undefined
  • createdBefore: DateTime<boolean> | undefined
  • cursor: string | undefined
  • limit: number | undefined

AdminAuditService

Class

The append-only admin audit trail (ASPEC §4.3, §5.2).

There is no update or delete path by design; retention is the host’s job and the operations doc carries the pruning recipe. The table is written through the query builder rather than a Lucid model so it needs no model-registry entry and no host-side model file — nothing about it is extensible.

AdminAuditService
Public members
  • db: Database
  • config: { tablePrefix: string; }
  • table: string
  • record: (entry: AdminAuditEntryInput, options?: MutationOptions) => Promise<AdminAuditEntry>
  • list: (filter?: AdminAuditFilter) => Promise<AdminListPage<AdminAuditEntry>>

AdminAuditSubjectType

Type

Subject kinds the audit trail records. Kept as a closed union so the (subject_type, subject_id, created_at) index stays selective and the panel can render a stable filter list.

AdminAuditSubjectType

AdminAuditSummary

Type

Compact before/after summary. Values are scalars only: the summary is the merchant’s operational record of what changed, never a snapshot of the record. The type is enforced at runtime by assertAuditSummary because the callers are host-owned controllers where types can be cast away.

Readonly<Record<string, string | number | boolean | null>>

adminEndpoint

Function

Looks an endpoint up by route name; throws when the name is not in the table.

(name: string) => AdminEndpoint

AdminEndpoint

Type

{ readonly method: "GET"; readonly path: "/products"; readonly name: "commerce.admin.products.index"; readonly ability: "commerce.products.view"; } | { readonly method: "POST"; readonly path: "/products"; readonly name: "commerce.admin.products.store"; readonly ability: "commerce.products.manage"; } | { readonly method: "GET"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.show"; readonly ability: "commerce.products.view"; } | { readonly method: "PATCH"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.update"; readonly ability: "commerce.products.manage"; } | { readonly method: "DELETE"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.destroy"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/archive"; readonly name: "commerce.admin.products.archive"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/options"; readonly name: "commerce.admin.products.options.store"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/variants/generate"; readonly name: "commerce.admin.products.variants.generate"; readonly ability: "commerce.products.manage"; } | { readonly method: "PUT"; readonly path: "/products/:id/categories"; readonly name: "commerce.admin.products.categories"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/images"; readonly name: "commerce.admin.products.images.store"; readonly ability: "commerce.products.manage"; } | { readonly method: "PATCH"; readonly path: "/products/:id/images/:imageId"; readonly name: "commerce.admin.products.images.update"; readonly ability: "com…

AdminEndpointDefinition

Interface

AdminEndpointDefinition
Public members
  • method: "GET" | "POST" | "PATCH" | "DELETE" | "PUT"
  • path: string
  • name: string
  • ability: CommerceAbility

adminEndpoints

Value

The complete admin REST surface (ASPEC §4.1). This table is the single source of truth: the published routes stub, the ability middleware, the reference documentation, and the contract test are all checked against it.

ability is enforced by commerceAdminAbility middleware before the controller body runs, so a row without an ability cannot exist.

readonly [{ readonly method: "GET"; readonly path: "/products"; readonly name: "commerce.admin.products.index"; readonly ability: "commerce.products.view"; }, { readonly method: "POST"; readonly path: "/products"; readonly name: "commerce.admin.products.store"; readonly ability: "commerce.products.manage"; }, { readonly method: "GET"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.show"; readonly ability: "commerce.products.view"; }, { readonly method: "PATCH"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.update"; readonly ability: "commerce.products.manage"; }, { readonly method: "DELETE"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.destroy"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/archive"; readonly name: "commerce.admin.products.archive"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/options"; readonly name: "commerce.admin.products.options.store"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/variants/generate"; readonly name: "commerce.admin.products.variants.generate"; readonly ability: "commerce.products.manage"; }, { readonly method: "PUT"; readonly path: "/products/:id/categories"; readonly name: "commerce.admin.products.categories"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/images"; readonly name: "commerce.admin.products.images.store"; readonly ability: "commerce.products.manage"; }, { readonly method: "PATCH"; readonly path: "/products/:id/images/:imageId"; readonly name: "commerce.admin.products.images.update"; readonly ability: "com…

AdminInvalidTransitionException

Class

A state-machine refusal, restated for the admin wire contract (ASPEC §4.2).

Core raises E_STATE_TRANSITION; the admin surface answers 409 E_COMMERCE_INVALID_TRANSITION with currentState, because that field is what lets the panel refresh a stale action button instead of failing silently.

AdminInvalidTransitionException

AdminRateLimiter

Class

Actor-keyed fixed-window counter behind the admin surface’s rate-limit defaults (ASPEC §4.2).

It is deliberately owned by this package rather than shared with @adocommercekit/storefront-api: ASPEC §2.1 fixes this package’s peers to core + AdonisJS + Lucid, so a headless admin host is never forced to install the storefront REST surface. The storefront limiter keys by client IP; this one keys by resolved actor, because an admin session is the unit an operator can multiply, not an address.

A single static instance in the published middleware is what makes the REST mutations and (from AD-33) the Inertia panel routes share buckets, so driving the UI with a script cannot bypass the API limits.

AdminRateLimiter
Public members
  • #buckets: Map<string, AdminRateLimitBucket>
  • maxKeys: number
  • consume: (scope: string, actorKey: string, limit: number, windowSeconds: number, now?: number) => AdminRateLimitResult
  • #ensureCapacity: (now: number) => void

AdminRateLimitResult

Interface

AdminRateLimitResult
Public members
  • allowed: boolean
  • limit: number
  • remaining: number
  • resetAt: number
  • retryAfter: number

AdminRateLimitTier

Type

"mutation" | "read" | "metrics"

AdminShipmentTransition

Type

The shipment operations the admin surface exposes. Shipments do not run on a declarative state machine like orders and payments do — FulfillmentService enforces its own preconditions — so the legal-transition set is declared here once and consumed by both surfaces: the REST controller rejects an illegal transition with 409 E_COMMERCE_INVALID_TRANSITION before calling the service, and the panel (AD-33) renders action buttons from the same table.

The service remains the authority; this table exists so the boundary answers “what can I do next?” without guessing from an error message.

AdminShipmentTransition

assertAuditSummary

Function

(summary: AdminAuditSummary) => void

canTransitionShipment

Function

(state: ShipmentState, transition: AdminShipmentTransition) => boolean

CommercePolicyName

Type

string | number | symbol

configure

Function

(command: Configure) => Promise<void>

stubsRoot

Value

string

translateAdminError

Function

Maps a service failure onto the admin wire contract, returning the error to throw. Unknown errors are returned untouched so a genuine bug still surfaces as a 500 rather than being laundered into a client error.

Two translations, both required by ASPEC §4.2:

  • E_STATE_TRANSITION becomes E_COMMERCE_INVALID_TRANSITION with the state the caller observed, which is more useful than the state the machine read.
  • A RangeError is a rejected input the validator could not express — an over-refund, an over-fulfilled line, a category moved under its own child — and belongs in the 422 envelope, not in a stack trace.
(error: unknown, currentState?: string) => unknown

@adocommercekit/admin-api/contract

ADMIN_API_PREFIX

Value

"/api/commerce/admin"

ADMIN_RATE_LIMITS

Value

Rate-limit tiers the published routes stub applies (ASPEC §4.2).

{ readonly mutation: { readonly scope: "admin-mutation"; readonly requests: 60; readonly windowSeconds: 60; }; readonly read: { readonly scope: "admin-read"; readonly requests: 240; readonly windowSeconds: 60; }; readonly metrics: { readonly scope: "admin-metrics"; readonly requests: 120; readonly windowSeconds: 60; }; }

adminEndpoint

Function

Looks an endpoint up by route name; throws when the name is not in the table.

(name: string) => AdminEndpoint

AdminEndpoint

Type

{ readonly method: "GET"; readonly path: "/products"; readonly name: "commerce.admin.products.index"; readonly ability: "commerce.products.view"; } | { readonly method: "POST"; readonly path: "/products"; readonly name: "commerce.admin.products.store"; readonly ability: "commerce.products.manage"; } | { readonly method: "GET"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.show"; readonly ability: "commerce.products.view"; } | { readonly method: "PATCH"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.update"; readonly ability: "commerce.products.manage"; } | { readonly method: "DELETE"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.destroy"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/archive"; readonly name: "commerce.admin.products.archive"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/options"; readonly name: "commerce.admin.products.options.store"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/variants/generate"; readonly name: "commerce.admin.products.variants.generate"; readonly ability: "commerce.products.manage"; } | { readonly method: "PUT"; readonly path: "/products/:id/categories"; readonly name: "commerce.admin.products.categories"; readonly ability: "commerce.products.manage"; } | { readonly method: "POST"; readonly path: "/products/:id/images"; readonly name: "commerce.admin.products.images.store"; readonly ability: "commerce.products.manage"; } | { readonly method: "PATCH"; readonly path: "/products/:id/images/:imageId"; readonly name: "commerce.admin.products.images.update"; readonly ability: "com…

AdminEndpointDefinition

Interface

AdminEndpointDefinition
Public members
  • method: "GET" | "POST" | "PATCH" | "DELETE" | "PUT"
  • path: string
  • name: string
  • ability: CommerceAbility

adminEndpoints

Value

The complete admin REST surface (ASPEC §4.1). This table is the single source of truth: the published routes stub, the ability middleware, the reference documentation, and the contract test are all checked against it.

ability is enforced by commerceAdminAbility middleware before the controller body runs, so a row without an ability cannot exist.

readonly [{ readonly method: "GET"; readonly path: "/products"; readonly name: "commerce.admin.products.index"; readonly ability: "commerce.products.view"; }, { readonly method: "POST"; readonly path: "/products"; readonly name: "commerce.admin.products.store"; readonly ability: "commerce.products.manage"; }, { readonly method: "GET"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.show"; readonly ability: "commerce.products.view"; }, { readonly method: "PATCH"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.update"; readonly ability: "commerce.products.manage"; }, { readonly method: "DELETE"; readonly path: "/products/:id"; readonly name: "commerce.admin.products.destroy"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/archive"; readonly name: "commerce.admin.products.archive"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/options"; readonly name: "commerce.admin.products.options.store"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/variants/generate"; readonly name: "commerce.admin.products.variants.generate"; readonly ability: "commerce.products.manage"; }, { readonly method: "PUT"; readonly path: "/products/:id/categories"; readonly name: "commerce.admin.products.categories"; readonly ability: "commerce.products.manage"; }, { readonly method: "POST"; readonly path: "/products/:id/images"; readonly name: "commerce.admin.products.images.store"; readonly ability: "commerce.products.manage"; }, { readonly method: "PATCH"; readonly path: "/products/:id/images/:imageId"; readonly name: "commerce.admin.products.images.update"; readonly ability: "com…

AdminRateLimitTier

Type

"mutation" | "read" | "metrics"

@adocommercekit/admin-api/services

ADMIN_AUDIT_TABLE

Value

"admin_audit_entries"

AdminAuditEntry

Type

AdminAuditEntry

AdminAuditEntryInput

Interface

AdminAuditEntryInput
Public members
  • actorId: string
  • actorLabel: string | null | undefined
  • ability: CommerceAbility
  • subjectType: AdminAuditSubjectType
  • subjectId: string
  • summary: Readonly<Record<string, string | number | boolean | null>>
  • idempotencyKey: string | null | undefined
  • requestId: string | null | undefined

AdminAuditFilter

Interface

AdminAuditFilter
Public members
  • actorId: string | undefined
  • ability: CommerceAbility[] | undefined
  • subjectType: AdminAuditSubjectType | undefined
  • subjectId: string | undefined
  • createdAfter: DateTime<boolean> | undefined
  • createdBefore: DateTime<boolean> | undefined
  • cursor: string | undefined
  • limit: number | undefined

AdminAuditService

Class

The append-only admin audit trail (ASPEC §4.3, §5.2).

There is no update or delete path by design; retention is the host’s job and the operations doc carries the pruning recipe. The table is written through the query builder rather than a Lucid model so it needs no model-registry entry and no host-side model file — nothing about it is extensible.

AdminAuditService
Public members
  • db: Database
  • config: { tablePrefix: string; }
  • table: string
  • record: (entry: AdminAuditEntryInput, options?: MutationOptions) => Promise<AdminAuditEntry>
  • list: (filter?: AdminAuditFilter) => Promise<AdminListPage<AdminAuditEntry>>

AdminAuditSubjectType

Type

Subject kinds the audit trail records. Kept as a closed union so the (subject_type, subject_id, created_at) index stays selective and the panel can render a stable filter list.

AdminAuditSubjectType

AdminAuditSummary

Type

Compact before/after summary. Values are scalars only: the summary is the merchant’s operational record of what changed, never a snapshot of the record. The type is enforced at runtime by assertAuditSummary because the callers are host-owned controllers where types can be cast away.

Readonly<Record<string, string | number | boolean | null>>

assertAuditSummary

Function

(summary: AdminAuditSummary) => void

@adocommercekit/stripe

stripe

Function

(options: StripeOptions) => DriverFactory<PaymentProvider>

StripeOptions

Interface

StripeOptions
Public members
  • apiKey: string
  • webhookSecret: string
  • apiBase: string | undefined
  • webhookToleranceSeconds: number | undefined
  • fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; } | undefined

StripePaymentProvider

Class

StripePaymentProvider
Public members
  • code: "stripe"
  • #fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; }
  • options: StripeOptions
  • capabilities: () => { authorize: boolean; capture: boolean; refund: boolean; void: boolean; clientConfirmation: boolean; }
  • createIntent: (input: Parameters<PaymentProvider["createIntent"]>[0]) => Promise<{ state: "authorized" | "created" | "requires_action"; clientSecret?: string | undefined; providerIntentId: string; }>
  • confirm: (input: Parameters<PaymentProvider["confirm"]>[0]) => Promise<ProviderPaymentState>
  • capture: (input: Parameters<PaymentProvider["capture"]>[0]) => Promise<{ providerChargeId: string; raw: StripeObject; }>
  • refund: (input: Parameters<PaymentProvider["refund"]>[0]) => Promise<{ providerRefundId: string; raw: StripeObject; }>
  • void: (input: Parameters<PaymentProvider["void"]>[0]) => Promise<void>
  • verifyWebhook: (raw: RawWebhookRequest) => Promise<boolean>
  • normalizeWebhook: (raw: RawWebhookRequest) => Promise<NormalizedPaymentEvent | { type: "unhandled"; providerEventId: string; raw?: unknown; }>
  • request: (method: string, path: string, body: Record<string, string>, idempotencyKey: string) => Promise<StripeObject>
  • intentState: (intent: StripeObject) => "created" | "requires_action" | "authorized"
  • normalizeDecline: (code: unknown) => PaymentDeclineCode
  • firstCharge: (intent: StripeObject) => StripeObject | undefined
  • eventMoney: (object: StripeObject, amountField: string) => Money | undefined

@adocommercekit/midtrans

configure

Function

(command: Configure) => Promise<void>

midtrans

Function

(options: MidtransOptions) => DriverFactory<PaymentProvider>

MIDTRANS_API_FAMILY

Value

"Core API v2"

MIDTRANS_REFUND_CAPABILITIES

Value

Readonly<Record<MidtransChannel, RefundCapability>>

MIDTRANS_SOURCE_RECORD

Value

Readonly<{ retrievedAt: "2026-07-24"; notification: "https://docs.midtrans.com/reference/https-notification"; signature: "https://docs.midtrans.com/docs/https-notification-webhooks#signature-key"; status: "https://docs.midtrans.com/reference/get-transaction-status"; qris: "https://docs.midtrans.com/reference/qris"; gopay: "https://docs.midtrans.com/reference/gopay"; refunds: "https://docs.midtrans.com/reference/refund-transaction"; }>

MidtransChannel

Type

MidtransChannel

MidtransManualRefundRequiredError

Class

MidtransManualRefundRequiredError
Public members
  • code: "MIDTRANS_MANUAL_REFUND_REQUIRED"
  • channel: MidtransChannel
  • guidance: string
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

MidtransOptions

Interface

MidtransOptions
Public members
  • serverKey: string
  • clientKey: string
  • environment: "sandbox" | "production"
  • channel: MidtransChannel
  • expiryMinutes: number | undefined
  • callbackUrl: string | undefined
  • apiBase: string | undefined
  • fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; } | undefined

MidtransPaymentProvider

Class

MidtransPaymentProvider
Public members
  • code: "midtrans"
  • #fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; }
  • options: MidtransOptions
  • capabilities: () => { authorize: boolean; capture: boolean; refund: boolean; void: boolean; clientConfirmation: boolean; flow: "deferred"; }
  • refundCapability: () => RefundCapability
  • createIntent: (input: Parameters<PaymentProvider["createIntent"]>[0]) => Promise<{ providerIntentId: string; state: "pending"; instructions: PaymentInstructionDraft[]; expiresAt: DateTime<boolean>; raw: JsonObject; }>
  • confirm: () => Promise<{ state: "pending"; }>
  • capture: () => Promise<{ providerChargeId: string; }>
  • refund: (input: Parameters<PaymentProvider["refund"]>[0]) => Promise<{ providerRefundId: any; raw: JsonObject; }>
  • void: (input: Parameters<PaymentProvider["void"]>[0]) => Promise<void>
  • retrieveIntent: (providerIntentId: string) => Promise<{ state: "settled"; amount: any; occurredAt: DateTime<boolean> | undefined; reference: string; raw: JsonObject; } | { state: "expired" | "failed" | "pending"; occurredAt: DateTime<boolean> | undefined; raw: JsonObject; amount?: undefined; reference?: undefined; }>
  • healthCheck: () => Promise<void>
  • verifyWebhook: (raw: RawWebhookRequest) => Promise<boolean>
  • normalizeWebhook: (raw: RawWebhookRequest) => Promise<NormalizedPaymentEvent | { type: "unhandled"; providerEventId: string; raw?: unknown; }>
  • chargePayload: (input: Parameters<PaymentProvider["createIntent"]>[0]) => JsonObject
  • instructions: (result: JsonObject, expiresAt: DateTime) => PaymentInstructionDraft[]
  • paymentStatus: (payload: JsonObject) => "pending" | "settled" | "expired" | "failed"
  • paymentEventType: (status: string) => "payment.pending" | "payment.authorized" | "payment.captured" | "payment.expired" | "payment.failed" | undefined
  • assertIdr: (amount: Money) => void
  • safeAmount: (amount: Money) => number
  • request: (method: string, path: string, body?: JsonObject, idempotencyKey?: string) => Promise<JsonObject>
  • rawRequest: (method: string, path: string, body?: JsonObject, idempotencyKey?: string) => Promise<Response>
  • apiBase: () => string

midtransWebhookUrl

Function

(appUrl: string) => string

RefundCapability

Interface

RefundCapability
Public members
  • mode: "automatic" | "manual_transfer"
  • guidance: string | undefined

@adocommercekit/xendit

configure

Function

(command: Configure) => Promise<void>

xendit

Function

(options: XenditOptions) => DriverFactory<PaymentProvider>

XENDIT_API_VERSION

Value

"2024-11-11"

XENDIT_SOURCE_RECORD

Value

Readonly<{ retrievedAt: "2026-07-24"; paymentRequests: "https://docs.xendit.co/apidocs/create-payment-request"; status: "https://docs.xendit.co/apidocs/get-payment-request"; webhooks: "https://docs.xendit.co/apidocs/payment-webhook-notification"; authentication: "https://docs.xendit.co/apidocs/quick-setup"; }>

XenditChannel

Type

XenditChannel

XenditOptions

Interface

XenditOptions
Public members
  • secretKey: string
  • webhookToken: string
  • channel: XenditChannel
  • successReturnUrl: string | undefined
  • failureReturnUrl: string | undefined
  • expiryMinutes: number | undefined
  • apiBase: string | undefined
  • fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; } | undefined

XenditPaymentProvider

Class

XenditPaymentProvider
Public members
  • code: "xendit"
  • #fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; }
  • options: XenditOptions
  • capabilities: () => { authorize: boolean; capture: boolean; refund: boolean; void: boolean; clientConfirmation: boolean; flow: "deferred"; }
  • createIntent: (input: Parameters<PaymentProvider["createIntent"]>[0]) => Promise<{ providerIntentId: string; state: "pending"; instructions: PaymentInstructionDraft[]; expiresAt: DateTime<boolean>; raw: JsonObject; }>
  • confirm: () => Promise<{ state: "pending"; }>
  • capture: () => Promise<{ providerChargeId: string; }>
  • refund: (input: Parameters<PaymentProvider["refund"]>[0]) => Promise<{ providerRefundId: any; raw: JsonObject; }>
  • void: (input: Parameters<PaymentProvider["void"]>[0]) => Promise<void>
  • retrieveIntent: (providerIntentId: string) => Promise<{ state: "settled"; amount: any; occurredAt: DateTime<boolean> | undefined; reference: string; raw: JsonObject; } | { state: "expired" | "failed" | "pending"; occurredAt: DateTime<boolean> | undefined; raw: JsonObject; amount?: undefined; reference?: undefined; }>
  • healthCheck: () => Promise<void>
  • verifyWebhook: (raw: RawWebhookRequest) => Promise<boolean>
  • normalizeWebhook: (raw: RawWebhookRequest) => Promise<NormalizedPaymentEvent | { type: "unhandled"; providerEventId: string; raw?: unknown; }>
  • instructions: (result: JsonObject, expiresAt: DateTime) => PaymentInstructionDraft[]
  • deferredStatus: (status: string) => "pending" | "settled" | "expired" | "failed"
  • paymentEventType: (status: string) => "payment.pending" | "payment.authorized" | "payment.captured" | "payment.expired" | "payment.failed" | undefined
  • assertIdr: (amount: Money) => void
  • request: (method: string, path: string, body?: JsonObject, idempotencyKey?: string) => Promise<JsonObject>
  • rawRequest: (method: string, path: string, body?: JsonObject, idempotencyKey?: string) => Promise<Response>

@adocommercekit/id

assertCatalogCoverage

Function

(catalog: Partial<IdRegionalCatalog>) => asserts catalog is IdRegionalCatalog

checksumIndonesiaRegions

Function

(records: Iterable<IndonesiaRegionRecord>) => string

COD_REMITTANCE_SCHEMA

Value

"commerce.cod-remittance.v1"

CodImportIssue

Interface

CodImportIssue
Public members
  • line: number
  • orderNumber: string
  • reference: string
  • reason: string

CodImportResult

Interface

CodImportResult
Public members
  • fileHash: string
  • settled: number
  • duplicates: number
  • unmatched: CodImportIssue[]
  • ambiguous: CodImportIssue[]
  • invalid: CodImportIssue[]

CodRemittanceImporter

Class

CodRemittanceImporter
Public members
  • #importsTable: string
  • db: Database
  • registry: ModelRegistry
  • payments: PaymentService
  • merchantId: string
  • import: (contents: string, actor?: string) => Promise<CodImportResult>

CodRemittanceRow

Interface

CodRemittanceRow
Public members
  • amount: string
  • currency: string
  • schema_version: string
  • merchant_id: string
  • order_number: string
  • reference: string

configure

Function

(command: Configure) => Promise<void>

ConsentAction

Type

ConsentAction

ConsentReceipt

Interface

ConsentReceipt
Public members
  • id: string
  • customerId: string
  • purpose: string
  • noticeVersion: string
  • action: ConsentAction
  • capturedAt: string
  • evidence: Record<string, unknown>

ConsentReceiptService

Class

ConsentReceiptService
Public members
  • #table: string
  • db: Database
  • grant: (input: { customerId: string; purpose: string; noticeVersion: string; evidence?: Record<string, unknown>; capturedAt?: Date; }) => Promise<ConsentReceipt>
  • withdraw: (input: { customerId: string; purpose: string; noticeVersion: string; evidence?: Record<string, unknown>; capturedAt?: Date; }) => Promise<ConsentReceipt>
  • hasValidPurpose: (customerId: string, purpose: string, noticeVersion?: string) => Promise<boolean>
  • list: (customerId: string) => Promise<ConsentReceipt[]>
  • #append: (action: ConsentAction, input: { customerId: string; purpose: string; noticeVersion: string; evidence?: Record<string, unknown>; capturedAt?: Date; }) => Promise<ConsentReceipt>

defineIdConfig

Function

(input?: Partial<Omit<IndonesiaExtensionConfig, "regions" | "pdp">> & { regions?: IndonesiaExtensionConfig["regions"]; pdp?: Partial<IndonesiaExtensionConfig["pdp"]>; }) => IndonesiaExtensionConfig

enRegionalCatalog

Value

IdRegionalCatalog

ID_REGIONAL_MESSAGE_KEYS

Value

readonly ["address.province", "address.city", "address.district", "address.village", "address.postal_code", "address.postal_choice_required", "payment.kode_unik.title", "payment.kode_unik.exact_amount", "payment.expires_at", "payment.review_required", "tax.ppn", "tax.ppn_luxury", "privacy.consent.whatsapp", "privacy.consent.withdrawn", "privacy.request.export", "privacy.request.correction", "privacy.request.deletion", "shipping.delivery_failed", "shipping.returned"]

idIDCatalog

Value

IdRegionalCatalog

IdRegionalCatalog

Type

IdRegionalCatalog

IdRegionalMessageKey

Type

"address.province" | "address.city" | "address.district" | "address.village" | "address.postal_code" | "address.postal_choice_required" | "payment.kode_unik.title" | "payment.kode_unik.exact_amount" | "payment.expires_at" | "payment.review_required" | "tax.ppn" | "tax.ppn_luxury" | "privacy.consent.whatsapp" | "privacy.consent.withdrawn" | "privacy.request.export" | "privacy.request.correction" | "privacy.request.deletion" | "shipping.delivery_failed" | "shipping.returned"

INDONESIA_REGIONS_DELIVERY

Value

{ readonly mode: "importer_only"; readonly cadence: "quarterly"; readonly redistribution: "No administrative-area records are bundled. Hosts must supply a licensed source."; }

IndonesiaAddressInput

Interface

IndonesiaAddressInput
Public members
  • firstName: string
  • lastName: string
  • company: string | undefined
  • line1: string
  • line2: string | undefined
  • phone: string | undefined
  • provinceId: string
  • cityId: string
  • districtId: string
  • villageId: string | undefined
  • postalCode: string | undefined

IndonesiaAddressValidationError

Class

IndonesiaAddressValidationError
Public members
  • code: "INDONESIA_ADDRESS_INVALID"
  • field: keyof IndonesiaAddressInput
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

IndonesiaExtensionConfig

Interface

IndonesiaExtensionConfig
Public members
  • addressMode: boolean
  • merchantId: string
  • regions: { onUnmatched?: (metric: UnmatchedIndonesiaAddressMetric) => void | Promise<void>; }
  • pdp: { authorize: PdpAuthorizer<unknown>; retention?: { cron: string; policyVersion: string; inactiveAfterDays: number; batchSize?: number; }; }

IndonesiaPpnCalculator

Class

IndonesiaPpnCalculator
Public members
  • statutoryRateBp: number
  • regulation: string
  • calculate: (input: Parameters<TaxCalculator["calculate"]>[0]) => Promise<TaxLineResult[]>

IndonesiaRegionImporter

Class

IndonesiaRegionImporter
Public members
  • #versionsTable: string
  • #regionsTable: string
  • #postalTable: string
  • db: Database
  • import: (provenance: IndonesiaRegionProvenance, source: AsyncIterable<IndonesiaRegionRecord> | Iterable<IndonesiaRegionRecord>) => Promise<IndonesiaRegionImportResult>

IndonesiaRegionImportResult

Interface

IndonesiaRegionImportResult
Public members
  • version: string
  • checksum: string
  • regions: number
  • postalMappings: number

IndonesiaRegionLevel

Type

IndonesiaRegionLevel

IndonesiaRegionListInput

Interface

IndonesiaRegionListInput
Public members
  • query: string | undefined
  • level: IndonesiaRegionLevel | undefined
  • cursor: string | undefined
  • limit: number | undefined

IndonesiaRegionListPage

Interface

IndonesiaRegionListPage
Public members
  • items: IndonesiaRegionMatch[]
  • nextCursor: string | null
  • total: number

IndonesiaRegionMatch

Interface

IndonesiaRegionMatch
Public members
  • sourceId: string
  • parentSourceId: string | null
  • level: IndonesiaRegionLevel
  • name: string

IndonesiaRegionProvenance

Interface

IndonesiaRegionProvenance
Public members
  • source: string
  • sourceUrl: string
  • version: string
  • retrievedAt: string
  • license: string
  • licenseUrl: string
  • expectedChecksum: string
  • corrections: string[] | undefined

IndonesiaRegionRecord

Interface

IndonesiaRegionRecord
Public members
  • sourceId: string
  • parentSourceId: string | null
  • level: IndonesiaRegionLevel
  • name: string
  • postalCodes: string[] | undefined

IndonesiaRegionService

Class

IndonesiaRegionService
Public members
  • #versionsTable: string
  • #regionsTable: string
  • #postalTable: string
  • db: Database
  • onUnmatched: ((metric: UnmatchedIndonesiaAddressMetric) => void | Promise<void>) | undefined
  • provenance: () => Promise<Record<string, unknown> | null>
  • list: (input?: IndonesiaRegionListInput) => Promise<IndonesiaRegionListPage>
  • typeahead: (input: { query: string; level?: IndonesiaRegionLevel; parentSourceId?: string; limit?: number; }) => Promise<IndonesiaRegionMatch[]>
  • find: (sourceId: string, level?: IndonesiaRegionLevel) => Promise<IndonesiaRegionMatch | null>
  • postalCodes: (sourceId: string) => Promise<string[]>
  • recordUnmatched: (metric: UnmatchedIndonesiaAddressMetric) => Promise<void>

kodeUnik

Function

(options: Omit<KodeUnikOptions, "database"> & { database?: Database; }) => DriverFactory<PaymentProvider>

KodeUnikAdminAction

Type

KodeUnikAdminAction

KodeUnikAdminService

Class

KodeUnikAdminService<Actor>
Public members
  • db: Database
  • payments: PaymentService
  • provider: KodeUnikPaymentProvider
  • authorize: KodeUnikAuthorizer<Actor>
  • confirm: (input: { actor: Actor; actorId: string; order: Order; intent: PaymentIntent; reference: string; }) => Promise<PaymentIntent>
  • reject: (input: { actor: Actor; actorId: string; order: Order; intent: PaymentIntent; reason: string; }) => Promise<PaymentIntent>
  • lockOwnedLease: (order: Order, intent: PaymentIntent, trx: TransactionClientContract) => Promise<LeaseRow>
  • assertAuthorized: (actor: Actor, action: KodeUnikAdminAction, order: Order) => Promise<void>

KodeUnikAuthorizationError

Class

KodeUnikAuthorizationError
Public members
  • code: "KODE_UNIK_UNAUTHORIZED"
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

KodeUnikAuthorizer

Type

KodeUnikAuthorizer<Actor>

KodeUnikManualRefundRequiredError

Class

KodeUnikManualRefundRequiredError
Public members
  • code: "KODE_UNIK_MANUAL_REFUND_REQUIRED"
  • operatorAction: "record_manual_transfer_reference"
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

KodeUnikOptions

Interface

KodeUnikOptions
Public members
  • receivingAccount: KodeUnikReceivingAccount
  • expiresAfterMinutes: number | undefined
  • tablePrefix: string | undefined
  • database: Database | undefined

KodeUnikPaymentProvider

Class

KodeUnikPaymentProvider
Public members
  • code: "kode_unik"
  • #activeTable: string
  • #archiveTable: string
  • db: Database
  • options: Omit<KodeUnikOptions, "database">
  • activeLeaseTable: () => string
  • capabilities: () => { authorize: boolean; capture: boolean; refund: boolean; void: boolean; clientConfirmation: boolean; flow: "deferred"; }
  • createIntent: (input: Parameters<PaymentProvider["createIntent"]>[0]) => Promise<{ providerIntentId: string; state: "pending"; expiresAt: DateTime<boolean>; adjustment: { sourceType: string; sourceId: string; label: string; amount: any; included: boolean; eligible: boolean; position: number; metadata: { receivingAccount: string; code: number; }; }; instructions: { displayName: string; expiresAt: DateTime<boolean>; metadata: { provider: string; receivingAccount: string; uniqueCode: string; }; accountName?: string | undefined; type: "bank_transfer"; bankName: string; accountNumber: string; }[]; raw: { leaseId: string; }; }>
  • confirm: () => Promise<{ state: "pending"; }>
  • capture: () => Promise<{ providerChargeId: string; }>
  • refund: () => Promise<{ providerRefundId: string; }>
  • void: (input: Parameters<PaymentProvider["void"]>[0]) => Promise<void>
  • retrieveIntent: (providerIntentId: string) => Promise<DeferredPaymentStatus>
  • healthCheck: () => Promise<void>
  • verifyWebhook: (_raw: RawWebhookRequest) => Promise<boolean>
  • normalizeWebhook: () => Promise<{ type: "unhandled"; providerEventId: string; }>
  • archiveLease: (providerIntentId: string, outcome: LeaseOutcome, resolutionReference: string | null, trx?: TransactionClientContract) => Promise<void>
  • allocate: (reference: string, baseAmount: Money) => Promise<LeaseRow>
  • archiveExpired: (trx: TransactionClientContract) => Promise<void>
  • archive: (lease: LeaseRow, outcome: LeaseOutcome, resolutionReference: string | null, client: LeaseClient) => Promise<void>
  • assertIdr: (amount: Money) => void

KodeUnikReceivingAccount

Interface

KodeUnikReceivingAccount
Public members
  • id: string
  • bankName: string
  • accountNumber: string
  • accountName: string | undefined

parseCodRemittanceCsv

Function

(input: string) => CodRemittanceRow[]

PDP_RETENTION_JOB

Value

"commerce.id.pdp-retention.v1"

PdpAuthorizationError

Class

PdpAuthorizationError
Public members
  • code: "PDP_UNAUTHORIZED"
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

PdpAuthorizer

Type

PdpAuthorizer<Actor>

PdpLegalHoldService

Class

PdpLegalHoldService
Public members
  • #table: string
  • db: Database
  • place: (customerId: string, reason: string, actor: string) => Promise<string>
  • release: (id: string, actor: string) => Promise<void>

PdpPortabilityExport

Interface

PdpPortabilityExport
Public members
  • schemaVersion: "commerce.id.pdp-export.v1"
  • core: CustomerPortabilityExport
  • consentReceipts: ConsentReceipt[]
  • rightsRequests: PdpRightsRequest[]

PdpRequestKind

Type

PdpRequestKind

PdpRequestState

Type

PdpRequestState

PdpRetentionPolicy

Interface

PdpRetentionPolicy
Public members
  • version: string
  • inactiveBefore: Date
  • batchSize: number | undefined

PdpRetentionService

Class

PdpRetentionService
Public members
  • #holdsTable: string
  • #actionsTable: string
  • db: Database
  • registry: ModelRegistry
  • customers: CustomerService
  • plan: (policy: PdpRetentionPolicy) => Promise<string[]>
  • execute: (policy: PdpRetentionPolicy, options: { dryRun: boolean; }) => Promise<string[]>

PdpRightsRequest

Interface

PdpRightsRequest
Public members
  • id: string
  • customerId: string
  • kind: PdpRequestKind
  • state: PdpRequestState
  • noticeVersion: string
  • requestedAt: string
  • completedAt: string | null
  • payload: Record<string, unknown>

PdpRightsService

Class

PdpRightsService<Actor>
Public members
  • #requestsTable: string
  • #holdsTable: string
  • db: Database
  • registry: ModelRegistry
  • customers: CustomerService
  • consents: ConsentReceiptService
  • authorize: PdpAuthorizer<Actor>
  • submit: (input: { actor: Actor; customerId: string; kind: PdpRequestKind; noticeVersion: string; payload?: Record<string, unknown>; }) => Promise<PdpRightsRequest>
  • export: (actor: Actor, customerId: string) => Promise<PdpPortabilityExport>
  • list: (actor: Actor, customerId: string) => Promise<PdpRightsRequest[]>
  • completeCorrection: (input: { actor: Actor; requestId: string; correction: Partial<Pick<Customer, "email" | "firstName" | "lastName" | "phone">>; }) => Promise<PdpRightsRequest>
  • completeDeletion: (input: { actor: Actor; requestId: string; }) => Promise<PdpRightsRequest>
  • #request: (id: string) => Promise<PdpRightsRequest>
  • #map: (row: Record<string, any>) => PdpRightsRequest
  • #authorized: (actor: Actor, action: Parameters<PdpAuthorizer<Actor>>[1], customerId: string) => Promise<void>

PPN_REGULATION

Value

"PMK 131/2024"

PPN_STATUTORY_RATE_BP

Value

1200

PpnAuditService

Class

PpnAuditService
Public members
  • db: Database
  • tablePrefix: string
  • generate: (month: string) => Promise<{ csv: string; rows: number; total: bigint; }>

ppnCalculator

Function

(options?: PpnCalculatorOptions) => DriverFactory<TaxCalculator>

PpnCalculatorOptions

Interface

PpnCalculatorOptions
Public members
  • statutoryRateBp: number | undefined
  • regulation: string | undefined

PpnCategory

Type

PpnCategory

RunPdpRetention

Class

RunPdpRetention
Public members
  • retention: PdpRetentionService
  • handle: (payload: JobPayload) => Promise<void>

UnmatchedIndonesiaAddressMetric

Interface

UnmatchedIndonesiaAddressMetric
Public members
  • countryCode: "ID"
  • provinceId: string | undefined
  • cityId: string | undefined
  • districtId: string | undefined
  • villageId: string | undefined
  • reason: "unknown_region" | "ambiguous_postal_code" | "postal_code_mismatch"

validateIndonesiaAddress

Function

(input: IndonesiaAddressInput, regions: IndonesiaRegionService) => Promise<AddressInput>

@adocommercekit/biteship

biteship

Function

(options: BiteshipOptions) => () => Promise<BiteshipProvider>

BITESHIP_API_BASE_URL

Value

"https://api.biteship.com/v1"

BITESHIP_API_VERSION

Value

"v1"

BiteshipOptions

Interface

BiteshipOptions
Public members
  • apiKey: string
  • origin: BiteshipOrigin
  • couriers: string[]
  • baseUrl: string | undefined
  • quoteTtlSeconds: number | undefined
  • cacheTtlSeconds: number | undefined
  • timeoutMs: number | undefined
  • timeoutBehavior: "block" | "fallback" | undefined
  • fallbackQuotes: ((request: ShippingQuoteRequest, error: unknown) => Promise<ShippingQuoteDraft[]>) | undefined
  • resolveArea: ((address: AddressInput) => Promise<string>) | undefined
  • defaultService: string | undefined
  • webhookVerifier: ((body: Buffer, signature: string) => boolean) | undefined
  • fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; } | undefined

BiteshipOrigin

Interface

BiteshipOrigin
Public members
  • areaId: string
  • postalCode: string | undefined
  • address: string
  • contactName: string
  • contactPhone: string
  • contactEmail: string | undefined

BiteshipProvider

Class

BiteshipProvider
Public members
  • code: "biteship"
  • #fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; }
  • #baseUrl: string
  • #cache: Map<string, CachedQuotes>
  • options: BiteshipOptions
  • capabilities: () => { readonly rates: true; readonly waybill: true; readonly tracking: true; readonly insurance: true; readonly cod: true; readonly returnTracking: true; }
  • quote: (input: ShippingQuoteRequest) => Promise<ShippingQuoteDraft[]>
  • prepare: (input: Parameters<FulfillmentProvider["prepare"]>[0]) => Promise<{ providerShipmentId: string; waybill: string; trackingNumber: string; carrier: string | undefined; raw: { id: string; status: any; }; }>
  • status: (providerShipmentId: string) => Promise<{ status: FulfillmentStatus; occurredAt: DateTime<true> | DateTime<false> | undefined; raw: { id: any; status: any; }; }>
  • normalizeTrackingWebhook: (body: Buffer, signature?: string) => { providerShipmentId: string; status: FulfillmentStatus; occurredAt?: DateTime; }
  • #destinationArea: (address: AddressInput | null) => Promise<string>
  • #quoteKey: (input: ShippingQuoteRequest, destination: string) => string
  • #request: (path: string, init: RequestInit) => Promise<Record<string, any>>

BiteshipRequestError

Class

BiteshipRequestError
Public members
  • code: "BITESHIP_REQUEST_FAILED"
  • status: number | undefined
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

configure

Function

(command: Configure) => Promise<void>

enMessages

Value

Record<"biteship.quote.unavailable" | "biteship.tracking.returned", string>

idIDMessages

Value

{ readonly "biteship.quote.unavailable": "Tarif pengiriman Biteship tidak tersedia"; readonly "biteship.tracking.returned": "Paket dikembalikan oleh kurir"; }

@adocommercekit/rajaongkir

configure

Function

(command: Configure) => Promise<void>

enMessages

Value

Record<"rajaongkir.quote.unavailable" | "rajaongkir.fulfillment.unsupported", string>

idIDMessages

Value

{ readonly "rajaongkir.quote.unavailable": "Tarif RajaOngkir tidak tersedia"; readonly "rajaongkir.fulfillment.unsupported": "Pembuatan resi tidak didukung oleh integrasi ini"; }

KOMERCE_RAJAONGKIR_API_VERSION

Value

"v1"

KOMERCE_RAJAONGKIR_BASE_URL

Value

"https://rajaongkir.komerce.id/api/v1"

rajaOngkir

Function

(options: RajaOngkirOptions) => () => Promise<RajaOngkirProvider>

RajaOngkirOptions

Interface

RajaOngkirOptions
Public members
  • apiKey: string
  • originId: string
  • couriers: string[]
  • baseUrl: string | undefined
  • quoteTtlSeconds: number | undefined
  • timeoutMs: number | undefined
  • resolveDestination: ((address: AddressInput) => Promise<string>) | undefined
  • fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; } | undefined

RajaOngkirProvider

Class

RajaOngkirProvider
Public members
  • code: "rajaongkir"
  • #fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; }
  • #baseUrl: string
  • options: RajaOngkirOptions
  • capabilities: () => { readonly rates: true; readonly tracking: true; readonly waybill: false; readonly fulfillment: false; readonly cod: false; readonly insurance: false; }
  • quote: (input: ShippingQuoteRequest) => Promise<ShippingQuoteDraft[]>
  • track: (waybill: string, courier: string) => Promise<{ status: FulfillmentStatus; occurredAt?: DateTime; raw: unknown; }>
  • #destination: (address: AddressInput | null) => Promise<string>
  • #request: (path: string, body: URLSearchParams) => Promise<Record<string, any>>

RajaOngkirRequestError

Class

RajaOngkirRequestError
Public members
  • code: "RAJAONGKIR_REQUEST_FAILED"
  • status: number | undefined
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

@adocommercekit/whatsapp

CommerceWhatsAppConfig

Interface

CommerceWhatsAppConfig
Public members
  • enabled: boolean
  • cloud: WhatsAppCloudOptions
  • noticeVersion: string
  • maxAttempts: number
  • resolver: WhatsAppMessageResolver
  • fallback: WhatsAppFallbackNotifier | undefined
  • logger: WhatsAppLogger | undefined

configure

Function

(command: Configure) => Promise<void>

defineWhatsAppConfig

Function

(input?: Partial<Omit<CommerceWhatsAppConfig, "cloud" | "resolver">> & { cloud?: Partial<WhatsAppCloudOptions>; resolver?: WhatsAppMessageResolver; }) => CommerceWhatsAppConfig

enMessages

Value

Record<"whatsapp.order.placed" | "whatsapp.payment.captured" | "whatsapp.payment.expired" | "whatsapp.shipment.shipped" | "whatsapp.shipment.delivered" | "whatsapp.shipment.returned", string>

idIDMessages

Value

{ readonly "whatsapp.order.placed": "Pesanan Anda telah dibuat"; readonly "whatsapp.payment.captured": "Pembayaran Anda telah diterima"; readonly "whatsapp.payment.expired": "Instruksi pembayaran telah kedaluwarsa"; readonly "whatsapp.shipment.shipped": "Pesanan Anda sedang dikirim"; readonly "whatsapp.shipment.delivered": "Pesanan Anda telah diterima"; readonly "whatsapp.shipment.returned": "Pesanan Anda dikembalikan"; }

WHATSAPP_COMMERCE_EVENTS

Value

ReadonlySet<string>

WHATSAPP_JOB

Value

"commerce.whatsapp.send-template.v1"

WHATSAPP_PURPOSE

Value

"order_updates_whatsapp"

WhatsAppCloudApiError

Class

WhatsAppCloudApiError
Public members
  • code: string
  • providerCode: number | undefined
  • status: number | undefined
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown

WhatsAppCloudClient

Class

WhatsAppCloudClient
Public members
  • #fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; }
  • #baseUrl: string
  • options: WhatsAppCloudOptions
  • sendTemplate: (message: WhatsAppTemplateMessage) => Promise<string>

WhatsAppCloudOptions

Interface

WhatsAppCloudOptions
Public members
  • accessToken: string
  • phoneNumberId: string
  • apiVersion: string
  • baseUrl: string | undefined
  • timeoutMs: number | undefined
  • fetch: { (input: RequestInfo | URL, init?: RequestInit): Promise<Response>; (input: string | URL | Request, init?: RequestInit): Promise<Response>; } | undefined

WhatsAppFallbackNotifier

Interface

WhatsAppFallbackNotifier
Public members
  • notify: (input: { event: string; customerId: string; reference: string; reason: string; }) => Promise<void>

WhatsAppLogger

Interface

WhatsAppLogger
Public members
  • info: (message: string, context: Readonly<Record<string, unknown>>) => void
  • error: (message: string, context: Readonly<Record<string, unknown>>) => void

WhatsAppMessageResolver

Interface

WhatsAppMessageResolver
Public members
  • resolve: (event: string, payload: unknown) => Promise<WhatsAppTemplateMessage | null>

WhatsAppNotificationOptions

Interface

WhatsAppNotificationOptions
Public members
  • noticeVersion: string
  • maxAttempts: number | undefined
  • fallback: WhatsAppFallbackNotifier | undefined
  • logger: WhatsAppLogger | undefined

WhatsAppNotificationService

Class

WhatsAppNotificationService
Public members
  • client: WhatsAppCloudClient
  • dispatcher: JobDispatcher
  • consents: ConsentReceiptService
  • resolver: WhatsAppMessageResolver
  • options: WhatsAppNotificationOptions
  • onEvent: (event: string, payload: unknown) => Promise<"queued" | "suppressed" | "ignored">
  • handle: (payload: JobPayload) => Promise<void>
  • #hasConsent: (customerId: string) => Promise<boolean>

WhatsAppTemplateDefinition

Interface

WhatsAppTemplateDefinition
Public members
  • name: string
  • language: string

WhatsAppTemplateMessage

Interface

WhatsAppTemplateMessage
Public members
  • customerId: string
  • to: string
  • template: WhatsAppTemplateDefinition
  • components: Record<string, unknown>[] | undefined
  • reference: string

WhatsAppTemplateNotApprovedError

Class

WhatsAppTemplateNotApprovedError
Public members
  • code: "WHATSAPP_TEMPLATE_NOT_APPROVED"
  • providerCode: number | undefined
  • status: number | undefined
  • name: string
  • message: string
  • stack: string | undefined
  • cause: unknown
Navigation

Type to search…

↑↓ navigate↵ selectEsc close