@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/pricing/price-lists.d.ts

@@ -0,0 +1,606 @@
+/**
+ * Price lists (headless spec §9.2 `pricing`: "price lists"; W10-14): a store's B2B price lists,
+ * their entries (what each target costs), who they are assigned to, the order rules they carry,
+ * and enabling, disabling or deleting many at once.
+ *
+ * - **Money** is integer MINOR UNITS of the store's DEFAULT currency, unless an entry's
+ *   `currencyCode` names another; an entry with no `currencyCode` applies in the default
+ *   currency only. Its basis differs per figure:
+ *   - a `fixed_price` / `fixed_amount` entry: the store's price basis (gross on a tax-inclusive
+ *     store, net on a tax-exclusive one);
+ *   - a list's order minimum (`minOrderAmount`): its own `minOrderAmountBasis`, `net` or
+ *     `gross`, and `gross` when omitted, whatever the store's basis;
+ *   - an order rule's money (a `min_order_total` threshold, a `fixed_amount` discount): the
+ *     store's price basis, as the dashboard labels it (USER DECISION N7, 2026-10-13).
+ *   Percentages are basis points (`1000` = 10 %).
+ * - **Order rules apply** (USER DECISION N1). A customer a list reaches gets the single best rule
+ *   their order meets (the most money off), as one line-level discount named "Order discount" in
+ *   the order's language. Only the most specific level of lists with rules decides (contract →
+ *   customer → group → store-wide); lists at that level are compared together. A total threshold
+ *   reads the goods at the customer's own prices before any other discount, in the store's price
+ *   basis, leaving out shipping, fees, gift cards and stated-price lines (imports, accepted
+ *   quotes, till manager prices); a quantity threshold counts the units of those same lines.
+ *   Money converts into the order's currency at the order's rate (no rate: no discount). Drafts,
+ *   storefront carts and till sales with a customer get it; quote, import and subscription
+ *   orders never do. A placed order keeps the rule SET it was placed with: an edit takes the
+ *   discount off below the threshold and gives it above it, and later rule changes never reach
+ *   it. The order minimum is checked before this discount. `orderRulesCombineWithPromotions`
+ *   (off by default): on, the discount and the store's coupons and promotions add up; off, a
+ *   coupon or promotion on the order wins and the list's rules step aside for that order.
+ * - **Times** are ISO-8601 instants in UTC (`startsAt`, `endsAt`).
+ * - **A list locked to an order** (an order's one-time discount, read as `Order.priceList`) is
+ *   never answered here: `get` answers `null`, and every write refuses it
+ *   `PRICE_LIST_LOCKED_TO_ORDER` (`BusinessRuleError`, 422). Change it from its order
+ *   (`orders.setOneTimeDiscounts`).
+ * - **Organizations:** a price list is the store's own row; a workspace's lists price only the
+ *   workspace.
+ *
+ * Permissions: reads need `ReadCatalog`, writes `UpdateCatalog` (deleting too, as the engine's
+ * single door asks). The names behind assignments also need `ReadCustomer` (a customer) or
+ * `ReadCustomer`/`ReadCustomerGroup` (a group); without it the name is `null` and the id stays.
+ */
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+export type PriceListDiscountType = 'fixed_price' | 'percentage' | 'fixed_amount' | 'chain';
+export type PriceListTargetType = 'variant' | 'product' | 'collection' | 'facet_value';
+export type PriceListOrderRuleDiscountType = 'percentage' | 'fixed_amount';
+export type PriceListOrderRuleConditionType = 'min_order_total' | 'min_order_quantity';
+/** Which total `minOrderAmount` is compared in: tax-exclusive (`net`) or tax-inclusive. */
+export type PriceListMinOrderAmountBasis = 'net' | 'gross';
+/**
+ * What a list search matches the term against:
+ * - `all` (the default): every facet below;
+ * - `name`: the list's own name and description;
+ * - `sku`: lists pricing a variant whose SKU STARTS WITH the term;
+ * - `product`: lists pricing a product or variant whose name contains the term;
+ * - `customer`: lists assigned to a matching customer, directly or through a group holding them
+ *   (or a group whose name matches).
+ * `sku` and `product` reach a list through variant, product, collection and facet-value entries
+ * alike. A list that prices everything (a default discount, or assigned to every customer) is
+ * never matched: it would answer every search.
+ */
+export declare const PRICE_LIST_SEARCH_MODES: readonly ["all", "name", "sku", "product", "customer"];
+export type PriceListSearchMode = (typeof PRICE_LIST_SEARCH_MODES)[number];
+/** What an entries search matches: the entry's own label, or (`sku`) every entry pricing the SKU. */
+export declare const PRICE_LIST_ENTRY_SEARCH_MODES: readonly ["all", "sku"];
+export type PriceListEntrySearchMode = (typeof PRICE_LIST_ENTRY_SEARCH_MODES)[number];
+/** The engine's `adminListQueryLimit`: a larger page of lists is refused. */
+export declare const MAX_PRICE_LIST_LIST_TAKE = 1000;
+/** The largest page of entries the engine answers. */
+export declare const MAX_PRICE_LIST_ENTRY_TAKE = 200;
+/** How many entries `entries.export` answers at most; `total` still counts every match. */
+export declare const MAX_PRICE_LIST_ENTRY_EXPORT = 10000;
+/** How many lists one `bulk` call may name. */
+export declare const MAX_BULK_PRICE_LISTS = 100;
+/** A search term shorter than this is ignored by the engine: the whole list answers. */
+export declare const PRICE_LIST_SEARCH_MIN_TERM_LENGTH = 2;
+/** How many entries `forCustomer` answers per list at most (`entriesTake`). */
+export declare const MAX_CUSTOMER_PRICE_LIST_ENTRIES = 100;
+/** One reason a list appeared in a search. */
+export interface PriceListSearchMatch {
+    /** `name`, `variant`, `product`, `collection`, `facet_value`, `customer` or `customer_group`. */
+    kind: string;
+    /** The matched thing, as the merchant would recognise it (SKU, product name, customer name…). */
+    label: string;
+}
+/** A customer group a list is assigned to. */
+export interface PriceListAssignmentGroup {
+    id: string;
+    name: string;
+}
+/** A customer a list is assigned to. */
+export interface PriceListAssignmentCustomer {
+    id: string;
+    firstName: string;
+    lastName: string;
+    emailAddress: string;
+    /**
+     * The company of the default billing address, else of the default shipping address, else of
+     * the first address that names one; `null` when none does.
+     */
+    company: string | null;
+    /**
+     * Set when the caller's customer-data level blanked fields of this customer (an app installation
+     * below `customerData: full`): `""` and `null` then mean "not granted".
+     */
+    redacted?: true;
+}
+/** Who a list applies to: one customer group or one customer, by id. */
+export interface PriceListAssignmentRef {
+    id: string;
+    priceListId: string;
+    /** Exactly one of the two is set. */
+    customerGroupId: string | null;
+    customerId: string | null;
+}
+/** An assignment with the name behind it, as `get`, `create`, `update` and `assign` answer it. */
+export interface PriceListAssignment extends PriceListAssignmentRef {
+    /**
+     * The group, when the assignment names one this store holds and the caller may read customer
+     * groups (`ReadCustomer` or `ReadCustomerGroup`); otherwise `null` (`customerGroupId` still
+     * names it).
+     */
+    customerGroup: PriceListAssignmentGroup | null;
+    /**
+     * The customer, when the assignment names one this store holds (not deleted) and the caller may
+     * read customers (`ReadCustomer`); otherwise `null` (`customerId` still names them).
+     */
+    customer: PriceListAssignmentCustomer | null;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** ISO-8601 UTC. */
+    updatedAt: string;
+}
+/** A list's own fields. */
+export interface PriceListFields {
+    id: string;
+    name: string;
+    description: string | null;
+    /** A contract list outranks every customer, group and channel-wide list. */
+    isContract: boolean;
+    /** Higher first, within the list's rank (contract → customer → group → channel-wide). */
+    priority: number;
+    /** A blanket discount on everything the list does not price otherwise, in basis points. */
+    defaultDiscountBps: number | null;
+    /** ISO-8601 UTC; `null`: from always. */
+    startsAt: string | null;
+    /** ISO-8601 UTC; `null`: for ever. */
+    endsAt: string | null;
+    enabled: boolean;
+    /** The list applies to every customer of the store, signed in or not. */
+    appliesToAllCustomers: boolean;
+    /** Invoice payment terms in days (0-365); `null`: the customer's own. */
+    paymentTermsDays: number | null;
+    /** An ERP payment-condition code instead of days (never both). */
+    paymentTermsCode: string | null;
+    /** The order minimum, in minor units compared in `minOrderAmountBasis`; `null`: none. */
+    minOrderAmount: number | null;
+    minOrderAmountBasis: PriceListMinOrderAmountBasis;
+    /** The fewest items an order may hold; `null`: none. */
+    minOrderQuantity: number | null;
+    /**
+     * May this list's order-rule discount be combined with the store's coupons and other
+     * promotions? Off (the default): a coupon or another promotion on the order wins, and the
+     * order-rule discount is dropped for that order (see **Order rules apply** in the module
+     * header).
+     */
+    orderRulesCombineWithPromotions: boolean;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** ISO-8601 UTC. */
+    updatedAt: string;
+}
+/** A list with its assignments and the names behind them. */
+export interface PriceList extends PriceListFields {
+    assignments: PriceListAssignment[];
+}
+/** One list as `list` answers it: its assignments by id, and why a search matched it. */
+export interface PriceListListItem extends PriceListFields {
+    assignments: PriceListAssignmentRef[];
+    /** Why the list matched the search, capped for display; empty outside a search. */
+    searchMatches: PriceListSearchMatch[];
+    /** How many reasons there were before the cap (`>= searchMatches.length`); 0 outside a search. */
+    searchMatchCount: number;
+    /**
+     * Set when the caller's customer-data level withheld a match label that names a customer (an
+     * app below `customerData: full`).
+     */
+    redacted?: true;
+}
+export interface PriceListListOptions extends ListOptions {
+    /** Lists to skip, 0 when omitted. Not together with `after`. */
+    skip?: number;
+    /** Lists per page, 1 to {@link MAX_PRICE_LIST_LIST_TAKE}; `limit`, else 25, when omitted. */
+    take?: number;
+    /** Find lists by what they contain (see {@link PriceListSearchMode}); trimmed. */
+    search?: string;
+    /** `all` when omitted. */
+    searchMode?: PriceListSearchMode;
+    /** Only the lists assigned to one customer or one customer group (see {@link PriceListAssignedTo}). */
+    assignedTo?: PriceListAssignedTo;
+}
+/**
+ * The lists an assignment names for ONE target: a customer (assigned to them directly, never
+ * through one of their groups) or a customer group; plus, with `includeChannelWide`, the store's
+ * lists for every customer. Assignment state only: a disabled or out-of-window list is listed
+ * too. What applies to a customer now, through their groups as well, is
+ * {@link PricingPriceListsModule.forCustomer}.
+ */
+export type PriceListAssignedTo = {
+    customerId: string;
+    customerGroupId?: never;
+    includeChannelWide?: boolean;
+} | {
+    customerGroupId: string;
+    customerId?: never;
+    includeChannelWide?: boolean;
+};
+/**
+ * How a list reaches a customer, strongest first: assigned to them (`customer`), to one of their
+ * groups (`group`), or to every customer of the store (`channel`).
+ */
+export type CustomerPriceListAssignmentType = 'customer' | 'group' | 'channel';
+/** One list that applies to a customer, as {@link PricingPriceListsModule.forCustomer} answers it. */
+export interface CustomerPriceList {
+    /** The list's own fields (its assignments are read with `get`). */
+    priceList: PriceListFields;
+    /** One of {@link CustomerPriceListAssignmentType}; a later engine may add a kind. */
+    assignmentType: CustomerPriceListAssignmentType | (string & {});
+    /**
+     * The list's first entries (`entriesTake`), ordered and labelled as `entries.list` answers
+     * them; `total` counts every entry, so `items.length < total` says the list was cut.
+     */
+    entries: {
+        items: PriceListEntry[];
+        total: number;
+    };
+    /** Its order rules, lowest condition first. How they apply: **Order rules apply** (module header). */
+    orderRules: PriceListOrderRule[];
+}
+export interface CustomerPriceListsOptions extends Call {
+    /** Entries per list, 1 to {@link MAX_CUSTOMER_PRICE_LIST_ENTRIES}; that maximum when omitted. */
+    entriesTake?: number;
+}
+export interface CreatePriceListInput {
+    name: string;
+    description?: string | null;
+    isContract?: boolean;
+    priority?: number;
+    defaultDiscountBps?: number | null;
+    startsAt?: string | null;
+    endsAt?: string | null;
+    /** On when omitted. */
+    enabled?: boolean;
+    appliesToAllCustomers?: boolean;
+    paymentTermsDays?: number | null;
+    paymentTermsCode?: string | null;
+    minOrderAmount?: number | null;
+    /** `gross` when omitted. */
+    minOrderAmountBasis?: PriceListMinOrderAmountBasis;
+    minOrderQuantity?: number | null;
+    /** Off when omitted on create; an update that omits it keeps it. */
+    orderRulesCombineWithPromotions?: boolean;
+}
+/** A PATCH: an absent field keeps what the list has; `null` clears a field that may be empty. */
+export type UpdatePriceListInput = Partial<CreatePriceListInput>;
+/** Who to assign a list to: exactly one of the two. */
+export type AssignPriceListTarget = {
+    customerGroupId: string;
+} | {
+    customerId: string;
+};
+export interface PriceListEntry {
+    id: string;
+    priceListId: string;
+    discountType: PriceListDiscountType;
+    targetType: PriceListTargetType;
+    variantId: string | null;
+    productId: string | null;
+    collectionId: string | null;
+    facetValueId: string | null;
+    /**
+     * Minor units for `fixed_price` and `fixed_amount`, basis points for `percentage`; `null` for a
+     * `chain` (see `chainValues`).
+     */
+    discountValue: number | null;
+    /** A chain discount's percentages, applied one after another, in basis points. */
+    chainValues: number[] | null;
+    /** The entry applies from this quantity on (a volume tier); 1 by default. */
+    minQuantity: number;
+    /** The currency a money entry is in; `null`: the store's default currency only. */
+    currencyCode: string | null;
+    /** A variant entry's label (product and variant name); `null` for other targets. */
+    variantName: string | null;
+    variantSku: string | null;
+    /** A product, collection or facet value entry's label; `null` for a variant. */
+    targetName: string | null;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** ISO-8601 UTC. */
+    updatedAt: string;
+}
+/** An entry as `entries.bulkSet` answers it: without labels, which would cost a read per row. */
+export type PriceListEntryWrite = Omit<PriceListEntry, 'variantName' | 'variantSku' | 'targetName'>;
+/** What the entries of one list can be narrowed by. Several combine with AND. */
+export interface PriceListEntryFilter {
+    targetType?: PriceListTargetType;
+    /** Free text; trimmed, and ignored below {@link PRICE_LIST_SEARCH_MIN_TERM_LENGTH}. */
+    search?: string;
+    /** `all` when omitted. */
+    searchMode?: PriceListEntrySearchMode;
+    /** Entries pricing one of these collections OR one of `facetValueIds` (one which-target group). */
+    collectionIds?: readonly string[];
+    facetValueIds?: readonly string[];
+}
+export interface PriceListEntryListOptions extends ListOptions, PriceListEntryFilter {
+    /** Entries to skip, 0 when omitted. Not together with `after`. */
+    skip?: number;
+    /** Entries per page, 1 to {@link MAX_PRICE_LIST_ENTRY_TAKE}; `limit`, else 50, when omitted. */
+    take?: number;
+}
+export interface SetPriceListEntryInput {
+    discountType: PriceListDiscountType;
+    targetType: PriceListTargetType;
+    /** The target of a `variant` entry; the other three likewise for their type. */
+    variantId?: string;
+    productId?: string;
+    collectionId?: string;
+    facetValueId?: string;
+    discountValue?: number;
+    chainValues?: number[];
+    /** 1 when omitted. */
+    minQuantity?: number;
+    /** The store's default currency when omitted. */
+    currencyCode?: string;
+}
+/** One filter chip: what it filters by, its label, and how many entries it covers. */
+export interface PriceListEntryFacetCount {
+    id: string;
+    label: string;
+    count: number;
+}
+/** Counts for an entries filter row, scoped to the search term only (never to a chip). */
+export interface PriceListEntryFacets {
+    /** Always the four target types, zero counts included. */
+    targetTypes: PriceListEntryFacetCount[];
+    collections: PriceListEntryFacetCount[];
+    facetValues: PriceListEntryFacetCount[];
+    /** Entries matching the term, before any chip or type filter. */
+    total: number;
+}
+export interface PriceListOrderRule {
+    id: string;
+    priceListId: string;
+    discountType: PriceListOrderRuleDiscountType;
+    conditionType: PriceListOrderRuleConditionType;
+    /** Minor units for `min_order_total`, an item count for `min_order_quantity`. */
+    conditionValue: number;
+    /** Basis points for `percentage`, minor units for `fixed_amount`. */
+    discountValue: number;
+    /** ISO-8601 UTC. */
+    createdAt: string;
+    /** ISO-8601 UTC. */
+    updatedAt: string;
+}
+export interface SetPriceListOrderRuleInput {
+    discountType: PriceListOrderRuleDiscountType;
+    conditionType: PriceListOrderRuleConditionType;
+    conditionValue: number;
+    discountValue: number;
+}
+export type PriceListBulkAction = 'ENABLE' | 'DISABLE' | 'DELETE';
+export declare const PRICE_LIST_BULK_ACTIONS: readonly PriceListBulkAction[];
+export interface PriceListBulkInput {
+    action: PriceListBulkAction;
+    /** 1 to {@link MAX_BULK_PRICE_LISTS} lists of the store, each named once. */
+    priceListIds: readonly string[];
+}
+/** One list's outcome in a `bulk` call. */
+export interface PriceListBulkOutcome {
+    id: string;
+    /** `OK`, or `FAILED` (a string on the wire: read anything else as not done). */
+    status: 'OK' | 'FAILED' | (string & {});
+    /**
+     * When FAILED: the single door's own code: `ENTITY_NOT_FOUND` (no such list in this store),
+     * `PRICE_LIST_LOCKED_TO_ORDER`, …; `INTERNAL_SERVER_ERROR` for a fault the engine logged.
+     */
+    code: string | null;
+    /** When FAILED: the door's sentence. */
+    message: string | null;
+}
+export interface PricingPriceListEntriesModule {
+    /**
+     * One page of a list's entries, as the engine orders them (target type, then label), each with
+     * its label. `total` counts every match. A list the store does not hold, or one locked to an
+     * order, answers an empty page.
+     *
+     * @effect read
+     * @permission ReadCatalog
+     */
+    list(priceListId: string, options?: PriceListEntryListOptions): Promise<Page<PriceListEntry>>;
+    /**
+     * Every entry matching `filter`, up to {@link MAX_PRICE_LIST_ENTRY_EXPORT}, in one call (for a
+     * file export). `total` counts every match, so `items.length < total` says the export was cut.
+     *
+     * @effect read
+     * @permission ReadCatalog
+     */
+    export(priceListId: string, filter?: PriceListEntryFilter, options?: Call): Promise<{
+        items: PriceListEntry[];
+        total: number;
+    }>;
+    /**
+     * The counts for a filter row, for the search term only (a chip never narrows its own count).
+     * A list the store does not hold answers zero counts.
+     *
+     * @effect read
+     * @permission ReadCatalog
+     */
+    facets(priceListId: string, search?: {
+        search?: string;
+        searchMode?: PriceListEntrySearchMode;
+    }, options?: Call): Promise<PriceListEntryFacets>;
+    /**
+     * Add an entry, or change the one with the same target, minimum quantity and currency, and
+     * answer it with its label. The target must be the store's (`ENTITY_NOT_FOUND` otherwise, the
+     * same as an unknown id); an entry naming no target of its type, or an unknown type, is refused
+     * `PRICE_LIST_ENTRY_INVALID` (400) with `details` naming the field.
+     *
+     * @effect write
+     * @permission UpdateCatalog
+     */
+    set(priceListId: string, input: SetPriceListEntryInput, options?: Call): Promise<PriceListEntry>;
+    /**
+     * {@link set} for many entries in ONE transaction: one refused entry writes none of them.
+     * Answers the entries without labels (see {@link PriceListEntryWrite}).
+     *
+     * @effect write
+     * @permission UpdateCatalog
+     */
+    bulkSet(priceListId: string, entries: readonly SetPriceListEntryInput[], options?: Call): Promise<PriceListEntryWrite[]>;
+    /**
+     * Delete one entry: the price it gave goes back to the next list or the catalogue price.
+     * `ENTITY_NOT_FOUND` for an entry the store does not hold.
+     *
+     * @effect destructive
+     * @permission UpdateCatalog
+     */
+    remove(entryId: string, options?: Call): Promise<void>;
+}
+export interface PricingPriceListOrderRulesModule {
+    /**
+     * A list's order rules (an order-level discount from a total or a quantity), lowest condition
+     * first. `[]` for a list the store does not hold. How they apply: **Order rules apply** in the
+     * module header.
+     *
+     * @effect read
+     * @permission ReadCatalog
+     */
+    list(priceListId: string, options?: Call): Promise<PriceListOrderRule[]>;
+    /**
+     * ADD an order rule to a list and answer it (a list may hold several; remove one with
+     * {@link remove}). From then on it discounts the qualifying orders of the list's customers
+     * (module header); a placed order keeps the rules it was placed with.
+     * Refused `PRICE_LIST_ORDER_RULE_INVALID` (400), `details` naming every offending field: a
+     * `discountType` or `conditionType` the engine does not know, a value that is not a whole
+     * number, a negative `conditionValue` or one past its bound (1,000,000.00 for a total, 1,000,000
+     * items for a quantity), a `discountValue` below 1, a percentage above 10,000 basis points
+     * (100 %), or a fixed amount past 1,000,000.00. Nothing is saved. A value that is not a whole
+     * number or does not fit 32 bits (which GraphQL's `Int` would refuse uncoded) is refused the same
+     * way before anything is sent. Also `ENTITY_NOT_FOUND` and `PRICE_LIST_LOCKED_TO_ORDER`.
+     *
+     * @effect write
+     * @permission UpdateCatalog
+     */
+    set(priceListId: string, input: SetPriceListOrderRuleInput, options?: Call): Promise<PriceListOrderRule>;
+    /**
+     * Delete one order rule. `ENTITY_NOT_FOUND` for a rule the store does not hold.
+     *
+     * @effect destructive
+     * @permission UpdateCatalog
+     */
+    remove(ruleId: string, options?: Call): Promise<void>;
+}
+export interface PricingPriceListsModule {
+    /**
+     * One page of the store's lists, highest priority first (newest first within one priority),
+     * each with its assignments by id. With `search`, the lists matching it (see
+     * {@link PriceListSearchMode}) and why (`searchMatches`); with `assignedTo`, only the lists
+     * assigned to that customer or group (see {@link PriceListAssignedTo}).
+     *
+     * Refused before anything is sent: `INVALID_PRICE_LIST_LIST_OPTIONS` (`ValidationError`, 400)
+     * for a `take` outside 1 to {@link MAX_PRICE_LIST_LIST_TAKE}, a negative `skip`, or an
+     * `assignedTo` naming not exactly one of `customerId` and `customerGroupId`. The engine refuses
+     * the same with the same code. `assignedTo` needs an engine with `PriceListListOptions.filter`.
+     *
+     * @effect read
+     * @permission ReadCatalog
+     */
+    list(options?: PriceListListOptions): Promise<Page<PriceListListItem>>;
+    /**
+     * The lists that apply to a customer of the store NOW, IN THE ORDER the price-list pricing
+     * tries them for each line: contracts first, then assigned to the customer, through one of
+     * their groups, to every customer; then higher priority first. Lists of one standing (same
+     * contract flag, assignment and priority) are tried together and the lower price wins per line,
+     * an equal price going to the lower list id; they are listed by id. Only enabled lists inside their
+     * date window, every list of the store considered; never an order's one-time discount (read
+     * that as `Order.priceList`). Each comes with its first entries and its order rules. The
+     * engine ranks them with the function its pricing uses, so a client never re-derives it.
+     *
+     * Refused: `ENTITY_NOT_FOUND` (`NotFoundError`, 404) for a customer the store does not hold
+     * (another store's, a deleted one, an unknown id: one answer); `FORBIDDEN` without
+     * `ReadCustomer`; `INVALID_PRICE_LIST_LIST_OPTIONS` (400) for an `entriesTake` outside 1 to
+     * {@link MAX_CUSTOMER_PRICE_LIST_ENTRIES}, before anything is sent. Needs an engine with
+     * `customerPriceLists`.
+     *
+     * @effect read
+     * @permission ReadCatalog
+     * @permission ReadCustomer
+     */
+    forCustomer(customerId: string, options?: CustomerPriceListsOptions): Promise<CustomerPriceList[]>;
+    /**
+     * One list with its assignments and the names behind them, read in one call; `null` for a list
+     * the store does not hold or one locked to an order.
+     *
+     * @effect read
+     * @permission ReadCatalog
+     */
+    get(id: string, options?: Call): Promise<PriceList | null>;
+    /**
+     * Create a list. Refused: payment terms the engine does not accept (`PAYMENT_TERMS_INVALID`,
+     * 400, `details` naming the field) and an order minimum it does not accept
+     * (`ORDER_MINIMUM_INVALID`, 400).
+     *
+     * @effect write
+     * @permission UpdateCatalog
+     */
+    create(input: CreatePriceListInput, options?: Call): Promise<PriceList>;
+    /**
+     * Change a list (a PATCH). Refused as {@link create}, plus `ENTITY_NOT_FOUND` for a list the
+     * store does not hold and `PRICE_LIST_LOCKED_TO_ORDER`.
+     *
+     * @effect write
+     * @permission UpdateCatalog
+     */
+    update(id: string, input: UpdatePriceListInput, options?: Call): Promise<PriceList>;
+    /**
+     * Delete a list with its assignments, entries and order rules: its customers pay what the next
+     * list or the catalogue says. `ENTITY_NOT_FOUND`, `PRICE_LIST_LOCKED_TO_ORDER`.
+     *
+     * @effect destructive
+     * @permission UpdateCatalog
+     */
+    delete(id: string, options?: Call): Promise<void>;
+    /**
+     * Assign a list to a customer group or a customer of the store, and answer the assignment with
+     * the name behind it. Refused: another store's (or an unknown) customer or group
+     * (`ENTITY_NOT_FOUND`), the same target twice (`USER_INPUT_ERROR`, naming the list),
+     * `PRICE_LIST_LOCKED_TO_ORDER`.
+     *
+     * @effect write
+     * @permission UpdateCatalog
+     */
+    assign(priceListId: string, target: AssignPriceListTarget, options?: Call): Promise<PriceListAssignment>;
+    /**
+     * Remove an assignment: its customers stop getting the list's prices.
+     * `ENTITY_NOT_FOUND` for an assignment the store does not hold.
+     *
+     * @effect destructive
+     * @permission UpdateCatalog
+     */
+    unassign(assignmentId: string, options?: Call): Promise<void>;
+    /**
+     * Enable, disable or delete many lists in one call. Each list goes through its single door's
+     * rules in a transaction of its own and is reported on its own, in the order named: a refused
+     * list (`ENTITY_NOT_FOUND`, `PRICE_LIST_LOCKED_TO_ORDER`) changes nothing, and the others still
+     * go through. A selection of no list, more than {@link MAX_BULK_PRICE_LISTS} or a list named
+     * twice is refused `BULK_ACTION_INPUT_INVALID` (400) before anything is sent. Not keyed: a
+     * repeat enables or disables again, and deletes nothing twice (`ENTITY_NOT_FOUND`).
+     *
+     * @effect destructive
+     * @permission UpdateCatalog
+     */
+    bulk(input: PriceListBulkInput, options?: Call): Promise<PriceListBulkOutcome[]>;
+    entries: PricingPriceListEntriesModule;
+    orderRules: PricingPriceListOrderRulesModule;
+}
+/** A list as `get`, `create` and `update` read it: with its assignments' names. */
+export declare const PRICE_LIST_FIELDS = "\n  \n  id\n  name\n  description\n  isContract\n  priority\n  defaultDiscountBps\n  startsAt\n  endsAt\n  enabled\n  appliesToAllCustomers\n  paymentTermsDays\n  paymentTermsCode\n  minOrderAmount\n  minOrderAmountBasis\n  minOrderQuantity\n  orderRulesCombineWithPromotions\n  createdAt\n  updatedAt\n\n  assignments { \n  id\n  priceListId\n  customerGroupId\n  customerId\n  customerGroup {\n    id\n    name\n  }\n  customer {\n    id\n    firstName\n    lastName\n    emailAddress\n    company\n  }\n  createdAt\n  updatedAt\n }\n";
+export declare const PRICE_LISTS_QUERY = "\n  query PriceLists($options: PriceListListOptions) {\n    priceLists(options: $options) {\n      items {\n        \n  id\n  name\n  description\n  isContract\n  priority\n  defaultDiscountBps\n  startsAt\n  endsAt\n  enabled\n  appliesToAllCustomers\n  paymentTermsDays\n  paymentTermsCode\n  minOrderAmount\n  minOrderAmountBasis\n  minOrderQuantity\n  orderRulesCombineWithPromotions\n  createdAt\n  updatedAt\n\n        assignments {\n          id\n          priceListId\n          customerGroupId\n          customerId\n        }\n        searchMatches {\n          kind\n          label\n        }\n        searchMatchCount\n      }\n      totalItems\n    }\n  }\n";
+export declare const PRICE_LIST_QUERY = "\n  query PriceList($id: ID!) {\n    priceList(id: $id) { \n  \n  id\n  name\n  description\n  isContract\n  priority\n  defaultDiscountBps\n  startsAt\n  endsAt\n  enabled\n  appliesToAllCustomers\n  paymentTermsDays\n  paymentTermsCode\n  minOrderAmount\n  minOrderAmountBasis\n  minOrderQuantity\n  orderRulesCombineWithPromotions\n  createdAt\n  updatedAt\n\n  assignments { \n  id\n  priceListId\n  customerGroupId\n  customerId\n  customerGroup {\n    id\n    name\n  }\n  customer {\n    id\n    firstName\n    lastName\n    emailAddress\n    company\n  }\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const CREATE_PRICE_LIST_MUTATION = "\n  mutation CreatePriceList($input: CreatePriceListInput!) {\n    createPriceList(input: $input) { \n  \n  id\n  name\n  description\n  isContract\n  priority\n  defaultDiscountBps\n  startsAt\n  endsAt\n  enabled\n  appliesToAllCustomers\n  paymentTermsDays\n  paymentTermsCode\n  minOrderAmount\n  minOrderAmountBasis\n  minOrderQuantity\n  orderRulesCombineWithPromotions\n  createdAt\n  updatedAt\n\n  assignments { \n  id\n  priceListId\n  customerGroupId\n  customerId\n  customerGroup {\n    id\n    name\n  }\n  customer {\n    id\n    firstName\n    lastName\n    emailAddress\n    company\n  }\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const UPDATE_PRICE_LIST_MUTATION = "\n  mutation UpdatePriceList($id: ID!, $input: UpdatePriceListInput!) {\n    updatePriceList(id: $id, input: $input) { \n  \n  id\n  name\n  description\n  isContract\n  priority\n  defaultDiscountBps\n  startsAt\n  endsAt\n  enabled\n  appliesToAllCustomers\n  paymentTermsDays\n  paymentTermsCode\n  minOrderAmount\n  minOrderAmountBasis\n  minOrderQuantity\n  orderRulesCombineWithPromotions\n  createdAt\n  updatedAt\n\n  assignments { \n  id\n  priceListId\n  customerGroupId\n  customerId\n  customerGroup {\n    id\n    name\n  }\n  customer {\n    id\n    firstName\n    lastName\n    emailAddress\n    company\n  }\n  createdAt\n  updatedAt\n }\n }\n  }\n";
+export declare const DELETE_PRICE_LIST_MUTATION = "\n  mutation DeletePriceList($id: ID!) {\n    deletePriceList(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const ASSIGN_PRICE_LIST_MUTATION = "\n  mutation AssignPriceList($priceListId: ID!, $input: AssignPriceListInput!) {\n    assignPriceList(priceListId: $priceListId, input: $input) { \n  id\n  priceListId\n  customerGroupId\n  customerId\n  customerGroup {\n    id\n    name\n  }\n  customer {\n    id\n    firstName\n    lastName\n    emailAddress\n    company\n  }\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const UNASSIGN_PRICE_LIST_MUTATION = "\n  mutation UnassignPriceList($assignmentId: ID!) {\n    unassignPriceList(assignmentId: $assignmentId) { \n  result\n  message\n }\n  }\n";
+export declare const BULK_PRICE_LIST_ACTION_MUTATION = "\n  mutation BulkPriceListAction($input: BulkPriceListActionInput!) {\n    bulkPriceListAction(input: $input) {\n      items {\n        id\n        status\n        code\n        message\n      }\n    }\n  }\n";
+export declare const PRICE_LIST_ENTRIES_QUERY = "\n  query PriceListEntries($priceListId: ID!, $options: PriceListEntryListOptions) {\n    priceListEntries(priceListId: $priceListId, options: $options) {\n      items { \n  \n  id\n  priceListId\n  discountType\n  targetType\n  variantId\n  productId\n  collectionId\n  facetValueId\n  discountValue\n  chainValues\n  minQuantity\n  currencyCode\n  createdAt\n  updatedAt\n\n  variantName\n  variantSku\n  targetName\n }\n      totalItems\n    }\n  }\n";
+export declare const PRICE_LIST_ENTRY_FACETS_QUERY = "\n  query PriceListEntryFacets($priceListId: ID!, $search: String, $searchMode: String) {\n    priceListEntryFacets(priceListId: $priceListId, search: $search, searchMode: $searchMode) {\n      targetTypes { id label count }\n      collections { id label count }\n      facetValues { id label count }\n      total\n    }\n  }\n";
+export declare const SET_PRICE_LIST_ENTRY_MUTATION = "\n  mutation SetPriceListEntry($priceListId: ID!, $input: SetPriceListEntryInput!) {\n    setPriceListEntry(priceListId: $priceListId, input: $input) { \n  \n  id\n  priceListId\n  discountType\n  targetType\n  variantId\n  productId\n  collectionId\n  facetValueId\n  discountValue\n  chainValues\n  minQuantity\n  currencyCode\n  createdAt\n  updatedAt\n\n  variantName\n  variantSku\n  targetName\n }\n  }\n";
+export declare const BULK_SET_PRICE_LIST_ENTRIES_MUTATION = "\n  mutation BulkSetPriceListEntries($priceListId: ID!, $entries: [SetPriceListEntryInput!]!) {\n    bulkSetPriceListEntries(priceListId: $priceListId, entries: $entries) {\n      \n  id\n  priceListId\n  discountType\n  targetType\n  variantId\n  productId\n  collectionId\n  facetValueId\n  discountValue\n  chainValues\n  minQuantity\n  currencyCode\n  createdAt\n  updatedAt\n\n    }\n  }\n";
+export declare const REMOVE_PRICE_LIST_ENTRY_MUTATION = "\n  mutation RemovePriceListEntry($id: ID!) {\n    removePriceListEntry(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const PRICE_LIST_ORDER_RULES_QUERY = "\n  query PriceListOrderRules($priceListId: ID!) {\n    priceListOrderRules(priceListId: $priceListId) { \n  id\n  priceListId\n  discountType\n  conditionType\n  conditionValue\n  discountValue\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const SET_PRICE_LIST_ORDER_RULE_MUTATION = "\n  mutation SetPriceListOrderRule($priceListId: ID!, $input: SetPriceListOrderRuleInput!) {\n    setPriceListOrderRule(priceListId: $priceListId, input: $input) { \n  id\n  priceListId\n  discountType\n  conditionType\n  conditionValue\n  discountValue\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const REMOVE_PRICE_LIST_ORDER_RULE_MUTATION = "\n  mutation RemovePriceListOrderRule($id: ID!) {\n    removePriceListOrderRule(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const CUSTOMER_PRICE_LISTS_QUERY = "\n  query CustomerPriceLists($customerId: ID!, $options: CustomerPriceListsOptions) {\n    customerPriceLists(customerId: $customerId, options: $options) {\n      priceList { \n  id\n  name\n  description\n  isContract\n  priority\n  defaultDiscountBps\n  startsAt\n  endsAt\n  enabled\n  appliesToAllCustomers\n  paymentTermsDays\n  paymentTermsCode\n  minOrderAmount\n  minOrderAmountBasis\n  minOrderQuantity\n  orderRulesCombineWithPromotions\n  createdAt\n  updatedAt\n }\n      assignmentType\n      entries {\n        items { \n  \n  id\n  priceListId\n  discountType\n  targetType\n  variantId\n  productId\n  collectionId\n  facetValueId\n  discountValue\n  chainValues\n  minQuantity\n  currencyCode\n  createdAt\n  updatedAt\n\n  variantName\n  variantSku\n  targetName\n }\n        totalItems\n      }\n      orderRules { \n  id\n  priceListId\n  discountType\n  conditionType\n  conditionValue\n  discountValue\n  createdAt\n  updatedAt\n }\n    }\n  }\n";
+export declare function createPricingPriceListsModule(transport: Transport): PricingPriceListsModule;