@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/locations/index.d.ts

@@ -94,6 +94,46 @@ export interface UpsertLocationProfileInput {
     openingHours?: OpeningHours | null;
     address?: StockLocationAddressInput | null;
 }
+/** Hold days a ready store pickup may be set to: 1 to 60, 7 when a location never set them (D15). */
+export declare const STORE_PICKUP_HOLD_DAYS: {
+    readonly min: 1;
+    readonly max: 60;
+    readonly default: 7;
+};
+/** The longest store pickup instructions a location may carry, in characters (D15). */
+export declare const STORE_PICKUP_INSTRUCTIONS_MAX_LENGTH = 500;
+/**
+ * A stock location's store pickup settings (C1/33). A location that never set them reads as not
+ * enabled, {@link STORE_PICKUP_HOLD_DAYS} `default` hold days and no instructions.
+ */
+export interface StockLocationPickup {
+    stockLocationId: string;
+    /** Shoppers may choose this location at checkout, and its till hands the order over. */
+    enabled: boolean;
+    /** Days a ready pickup is held before its stock goes back on sale (1 to 60). */
+    holdDays: number;
+    /** Shown to shoppers at checkout and in the ready email; null when none. */
+    instructions: string | null;
+    /**
+     * What ENABLING needs, answered now: the location's address (its location profile) and an
+     * active POS register at the location, because the hand-over happens at a till. Turning on a
+     * location that lacks one is refused; a location already on keeps working.
+     */
+    hasAddress: boolean;
+    hasTill: boolean;
+}
+/**
+ * The WHOLE settings, not a patch: an omitted `instructions` clears them. Instructions are
+ * trimmed, and blank is none.
+ */
+export interface SetStockLocationPickupInput {
+    stockLocationId: string;
+    enabled: boolean;
+    /** A whole number from 1 to 60. */
+    holdDays: number;
+    /** At most 500 characters, no control characters (a line break is fine). */
+    instructions?: string | null;
+}
 /**
  * Location profiles for the active channel (spec §8.7).
  *
@@ -134,9 +174,35 @@ export interface LocationsModule {
     upsert(input: UpsertLocationProfileInput, options?: Call): Promise<LocationProfile>;
     /** True when a profile was removed, false when there was none. The stock location survives. */
     delete(stockLocationId: string, options?: Call): Promise<boolean>;
+    /**
+     * The location's store pickup settings, with what enabling needs (`hasAddress`, `hasTill`).
+     * Needs `ReadStockLocation`. Refused `LOCATION_NOT_FOUND` (`NotFoundError`) for a location that
+     * is not this store's.
+     *
+     * @effect read
+     */
+    pickup(stockLocationId: string, options?: Call): Promise<StockLocationPickup>;
+    /**
+     * Set the location's store pickup settings (C1/33). Needs `UpdateStockLocation`. The store's
+     * first enabled location creates its `store-pickup` shipping method, which then appears among
+     * the store's shipping methods (rename or disable it there). Sending the stored settings back
+     * writes nothing.
+     *
+     * Refused: `STORE_PICKUP_SETTINGS_INVALID` (`ValidationError`) for hold days outside 1-60 or
+     * instructions over 500 characters or with a control character; turning pickup ON at a
+     * location without an address, `STORE_PICKUP_ADDRESS_REQUIRED`, or without an active POS
+     * register, `STORE_PICKUP_TILL_REQUIRED` (both `BusinessRuleError`); `LOCATION_NOT_FOUND`
+     * (`NotFoundError`); and `LOCATION_NOT_ALLOWED` (`PermissionDeniedError`) for a credential
+     * restricted with `locationIds` that does not hold the location.
+     *
+     * @effect write
+     */
+    setPickup(input: SetStockLocationPickupInput, options?: Call): Promise<StockLocationPickup>;
 }
 export declare const LOCATION_PROFILES_QUERY = "\n  query LocationProfiles {\n    locationProfiles { \n  stockLocationId\n  code\n  name\n  timezone\n  phone\n  openingHours\n  address {\n    contactName\n    company\n    streetLine1\n    streetLine2\n    city\n    province\n    postalCode\n    countryCode\n    phoneNumber\n  }\n  stockLocation {\n    id\n    name\n    description\n  }\n }\n  }\n";
 export declare const LOCATION_PROFILE_QUERY = "\n  query LocationProfile($stockLocationId: ID!) {\n    locationProfile(stockLocationId: $stockLocationId) { \n  stockLocationId\n  code\n  name\n  timezone\n  phone\n  openingHours\n  address {\n    contactName\n    company\n    streetLine1\n    streetLine2\n    city\n    province\n    postalCode\n    countryCode\n    phoneNumber\n  }\n  stockLocation {\n    id\n    name\n    description\n  }\n }\n  }\n";
 export declare const UPSERT_LOCATION_PROFILE_MUTATION = "\n  mutation UpsertLocationProfile($input: UpsertLocationProfileInput!) {\n    upsertLocationProfile(input: $input) { \n  stockLocationId\n  code\n  name\n  timezone\n  phone\n  openingHours\n  address {\n    contactName\n    company\n    streetLine1\n    streetLine2\n    city\n    province\n    postalCode\n    countryCode\n    phoneNumber\n  }\n  stockLocation {\n    id\n    name\n    description\n  }\n }\n  }\n";
 export declare const DELETE_LOCATION_PROFILE_MUTATION = "\n  mutation DeleteLocationProfile($stockLocationId: ID!) {\n    deleteLocationProfile(stockLocationId: $stockLocationId)\n  }\n";
+export declare const STOCK_LOCATION_PICKUP_QUERY = "\n  query StockLocationPickup($stockLocationId: ID!) {\n    stockLocationPickup(stockLocationId: $stockLocationId) { \n  stockLocationId\n  enabled\n  holdDays\n  instructions\n  hasAddress\n  hasTill\n }\n  }\n";
+export declare const SET_STOCK_LOCATION_PICKUP_MUTATION = "\n  mutation SetStockLocationPickup($input: SetStockLocationPickupInput!) {\n    setStockLocationPickup(input: $input) { \n  stockLocationId\n  enabled\n  holdDays\n  instructions\n  hasAddress\n  hasTill\n }\n  }\n";
 export declare function createLocationsModule(transport: Transport): LocationsModule;

package/dist/locations/index.js

@@ -1,6 +1,11 @@
 import { createPage } from '@sixtyninecommerce/core';
 /** `openingHours` keys: lowercase, three letters, Monday first. */
 export const OPENING_HOURS_DAYS = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+// ── Store pickup (POS C1/33) ──
+/** Hold days a ready store pickup may be set to: 1 to 60, 7 when a location never set them (D15). */
+export const STORE_PICKUP_HOLD_DAYS = { min: 1, max: 60, default: 7 };
+/** The longest store pickup instructions a location may carry, in characters (D15). */
+export const STORE_PICKUP_INSTRUCTIONS_MAX_LENGTH = 500;
 const LOCATION_PROFILE_FIELDS = /* GraphQL */ `
   stockLocationId
   code
@@ -45,6 +50,24 @@ export const DELETE_LOCATION_PROFILE_MUTATION = /* GraphQL */ `
     deleteLocationProfile(stockLocationId: $stockLocationId)
   }
 `;
+const STOCK_LOCATION_PICKUP_FIELDS = /* GraphQL */ `
+  stockLocationId
+  enabled
+  holdDays
+  instructions
+  hasAddress
+  hasTill
+`;
+export const STOCK_LOCATION_PICKUP_QUERY = /* GraphQL */ `
+  query StockLocationPickup($stockLocationId: ID!) {
+    stockLocationPickup(stockLocationId: $stockLocationId) { ${STOCK_LOCATION_PICKUP_FIELDS} }
+  }
+`;
+export const SET_STOCK_LOCATION_PICKUP_MUTATION = /* GraphQL */ `
+  mutation SetStockLocationPickup($input: SetStockLocationPickupInput!) {
+    setStockLocationPickup(input: $input) { ${STOCK_LOCATION_PICKUP_FIELDS} }
+  }
+`;
 export function createLocationsModule(transport) {
     return {
         async list(options) {
@@ -68,5 +91,13 @@ export function createLocationsModule(transport) {
             const data = await transport.graphql({ api: 'admin', query: DELETE_LOCATION_PROFILE_MUTATION, variables: { stockLocationId } }, options);
             return data.deleteLocationProfile;
         },
+        async pickup(stockLocationId, options) {
+            const data = await transport.graphql({ api: 'admin', query: STOCK_LOCATION_PICKUP_QUERY, variables: { stockLocationId } }, options);
+            return data.stockLocationPickup;
+        },
+        async setPickup(input, options) {
+            const data = await transport.graphql({ api: 'admin', query: SET_STOCK_LOCATION_PICKUP_MUTATION, variables: { input } }, options);
+            return data.setStockLocationPickup;
+        },
     };
 }

package/dist/meta/index.d.ts

@@ -39,6 +39,11 @@ export interface MetaCatalogLabels {
     auditCallOutcome: LabelMap;
     /** Who sends a notification event's email: `platform` or `none` (`admin.tenant.notifications`). */
     notificationSender: LabelMap;
+    /**
+     * A supplier purchase order's status (`admin.purchasing.purchaseOrders`). Served by a platform
+     * with purchase orders; absent before.
+     */
+    purchaseOrderStatus?: LabelMap;
     /**
      * A vocabulary added after this SDK release arrives camelised, with its map
      * untouched.
@@ -54,6 +59,12 @@ export interface MetaCatalogTransitions {
      * UNRANKED, so it is absent — treat "no rank" as "no forward move", never 0.
      */
     fulfillmentRank: Record<string, number>;
+    /**
+     * A supplier purchase order's lifecycle (`admin.purchasing.purchaseOrders`): `cancelled` is
+     * terminal, `closed` moves only back to `sent`. Served by a platform with purchase orders;
+     * absent before.
+     */
+    purchaseOrder?: TransitionMap;
     [extra: string]: unknown;
 }
 export interface PermissionGroup {
@@ -108,6 +119,12 @@ export interface MetaCatalogPermissions {
 export interface PluginCatalogEntry {
     key: string;
     name: string;
+    /**
+     * One sentence on what the plugin does, in merchant English: the words the
+     * platform's own dashboard shows beside the name. Served by a platform from
+     * this release on.
+     */
+    description: string;
     group: string;
     /** `system` plugins are always on; `external` ones need an entitlement. */
     kind: string;
@@ -117,6 +134,142 @@ export interface MetaCatalogPlugins {
     groupLabels: Record<string, string>;
     [extra: string]: unknown;
 }
+/** Which API a plugin settings input is written through. */
+export type PluginConfigWriteApi = 'admin-graphql' | 'plugins-rest';
+/**
+ * How a secret property of a plugin settings schema behaves on READ, carried
+ * as the schema property's `x-secret` keyword beside `writeOnly: true`:
+ *
+ * - `masked-roundtrip`: the config read returns a masked preview (named in
+ *   {@link PluginConfigRead.fields}); sending that preview back unchanged, or
+ *   leaving the property out, keeps the stored secret. A BLANK is not the same
+ *   everywhere: it keeps the Tikkie credentials but REMOVES the till's Mollie
+ *   key, so read the property's `description` before sending one;
+ * - `write-only`: no value the read returns may be sent back. A masked preview
+ *   may exist for display, but the platform would store it AS the secret, so
+ *   never pre-fill the field;
+ * - `server-generated`: the platform mints it; a head shows it, never asks for it.
+ */
+export type PluginConfigSecret = 'masked-roundtrip' | 'write-only' | 'server-generated';
+/** The operation that writes a settings input. */
+export interface PluginConfigWrite {
+    api: PluginConfigWriteApi;
+    /** The Admin API mutation (`admin-graphql`), or `METHOD /path` on the plugins service. */
+    operation: string;
+    /**
+     * The mutation argument that takes the input type named by
+     * {@link PluginConfigInput.name}, e.g. `input`. Absent when the mutation takes
+     * its settings as INLINE arguments (then `name` is the operation itself and the
+     * schema's properties are the argument names), and absent for a REST body.
+     */
+    argument?: string;
+    /**
+     * The field of the argument's input object that takes the schema's
+     * properties, when they are only PART of a wider input: the SEO plugin's
+     * Channel defaults go in `updateChannel(input: { id, customFields: { … } })`
+     * under `customFields`. That schema lists only its own fields and stays open
+     * to the rest (other forms' fields), and {@link key} is then a field of the
+     * argument object (`input.id`). Absent: the argument IS the input. Served by a
+     * platform from this release on.
+     */
+    field?: string;
+    /**
+     * For a plugin whose settings are a COLLECTION of records (email gateways,
+     * product feeds): what names the record this input changes. The mutation
+     * argument sent beside {@link argument} (`updateEmailGateway(id:, input:)`);
+     * with {@link field}, a field of the argument object; for a REST write, the
+     * path parameter of `operation` (`PATCH /feeds/configs/:id` → `id`). Absent
+     * for a create and for settings that are one record per store, and for an
+     * input that names its record by a property of its own (`paymentMethodCode`,
+     * which {@link PluginConfigRead.fields} pre-fills). Served by a platform from
+     * this release on.
+     */
+    key?: string;
+}
+/** The read that pre-fills a form for this input. */
+export interface PluginConfigRead {
+    /** The Admin API query (or `GET /path`) that returns the stored config. */
+    operation: string;
+    /**
+     * The field of the read's answer that holds {@link fields}, when they are
+     * nested: `activeChannel { customFields { … } }` → `customFields`. Absent: the
+     * answer itself holds them. Served by a platform from this release on.
+     */
+    field?: string;
+    /** The permission the read needs; not always the write's. */
+    permission: string;
+    /**
+     * EVERY permission that allows the read, {@link permission} first, when there
+     * is more than one: holding any one of them is enough. Absent when
+     * `permission` is the only one, so read `permissions ?? [permission]`. Served
+     * by a platform from this release on.
+     */
+    permissions?: string[];
+    /**
+     * For a collection: the query argument (for a REST read, the path parameter
+     * of {@link operation}) that names the record to read, e.g. `id`. Served by a
+     * platform from this release on.
+     */
+    key?: string;
+    /**
+     * For a collection: the query that lists every record. Each item reads like
+     * {@link operation}'s answer, and its field named like {@link key} is the
+     * value {@link key} takes (`id`; `paymentMethodCode` for a payment provider).
+     * A REST list is `GET /path` answering a cursor page: the items in `data`, the
+     * next page through `pagination.next_cursor`. Served by a platform from this
+     * release on.
+     */
+    list?: string;
+    /**
+     * Schema property → the field of the read that pre-fills it, keyed by DATA
+     * (the schema's own property names). A property absent here has nothing to
+     * pre-fill: a write-only secret, or a value the read does not return. A read
+     * field that is null pre-fills nothing either: leave the property out, which
+     * keeps the stored value. Projected that way, a read validates against the
+     * schema once any required write-only secret is typed in. For a
+     * `plugins-rest` input both sides are the route's WIRE names
+     * (`language_code`); this SDK's typed modules over those routes
+     * (`admin.feeds.get`) camelise top-level keys, so map them back, or call the
+     * route in wire form.
+     */
+    fields: Record<string, string>;
+}
+/** One settings input of a plugin: what to send, where, and who may send it. */
+export interface PluginConfigInput {
+    /**
+     * The GraphQL input type (or REST DTO) the schema describes, e.g.
+     * `UpdateHendriksConfigInput`; for a mutation that takes inline arguments
+     * (`write.argument` absent), the operation itself, e.g. `setMyparcelEnabled`.
+     */
+    name: string;
+    write: PluginConfigWrite;
+    /** `null` when no read returns this input's values. */
+    read: PluginConfigRead | null;
+    /** The permission the write needs on the active store. */
+    permission: string;
+    /**
+     * EVERY permission that allows the write, {@link permission} first, when there
+     * is more than one: holding any one of them is enough (POS receipt numbering
+     * takes `UpdateSettings` or `ManagePosDevices`). Absent when `permission` is
+     * the only one, so read `permissions ?? [permission]`. Served by a platform
+     * from this release on.
+     */
+    permissions?: string[];
+    /**
+     * Draft 2020-12 JSON Schema of the input. It states only what the platform
+     * enforces on write: schema-valid means "worth sending", not "certain to be
+     * accepted" (a refusal can depend on stored state, e.g. enabling before a
+     * credential exists). Property names are the API's own and are never
+     * camelised. A secret carries `writeOnly: true` and `x-secret`. A write the
+     * platform deprecates (the legacy Mollie/Stripe key door) carries the
+     * standard `deprecated: true`.
+     */
+    schema: JsonSchema;
+}
+/** Every settings input one plugin takes. */
+export interface PluginConfigSchemas {
+    inputs: PluginConfigInput[];
+}
 export interface MetaCatalog {
     /**
      * A short hash of everything else. It changes only when the catalog's content
@@ -138,6 +291,15 @@ export interface MetaCatalog {
      * shape.
      */
     settingsSchemas: Record<string, JsonSchema>;
+    /**
+     * JSON Schema of each plugin's settings inputs, keyed by PLUGIN KEY
+     * (`payment-links`, `external-tracking`, …, as in `plugins.catalog`), so a
+     * head can render a plugin's settings form from data. Everything below the
+     * plugin key, the schemas included, arrives exactly as the platform spells
+     * it. A plugin with no entry has no per-store settings at all (search,
+     * warehouse, stored value). Served by a platform from this release on.
+     */
+    pluginConfigSchemas: Record<string, PluginConfigSchemas>;
     /**
      * A member added after this SDK release arrives with its NAME camelised and
      * its contents untouched — the half that matters, since a member this build

package/dist/orders/bulk.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `admin.orders.bulk`, `admin.orders.bulkRun` and `admin.orders.delete` (headless spec §7
+ * `orders.bulk`, plan W9-43; rulings G19, G28, G29).
+ */
+import { type Transport } from '@sixtyninecommerce/core';
+import { type BulkActionItem, type BulkActionRun } from '../jobs/bulk-action-run.js';
+import type { JobHandle } from '../jobs/index.js';
+import type { Call } from '../types.js';
+/** What each order of one bulk run gets. */
+export type OrderBulkAction = 'TRANSITION' | 'CANCEL' | 'DELETE' | 'MARK_PAID';
+export declare const ORDER_BULK_ACTIONS: readonly OrderBulkAction[];
+/** The engine's bound on one bulk run (`MAX_BULK_ACTION_ITEMS`). Split a larger selection. */
+export declare const MAX_BULK_ORDERS = 50;
+/**
+ * The states a TRANSITION never names, each with its own action or door: `Cancelled` (CANCEL),
+ * `PaymentSettled` (MARK_PAID), `Modifying` (the order edit) and `AddingItems`.
+ */
+export declare const ORDER_BULK_TRANSITION_REFUSED: readonly string[];
+export interface OrderBulkInput {
+    action: OrderBulkAction;
+    /** 1 to {@link MAX_BULK_ORDERS} orders of the store, each named once. */
+    orderIds: readonly string[];
+    /** TRANSITION only, and required there: the state each order moves to. */
+    toState?: string;
+    /** CANCEL only: the reason recorded on each cancelled order. */
+    reason?: string;
+}
+/** One payment a MARK_PAID item acted on. */
+export interface OrderBulkCapture {
+    paymentId: string;
+    /** The payment's state after the capture: `Settled`, or what a decline left. */
+    state: string;
+    /**
+     * Why it was not captured, null when it was: `SETTLE_PAYMENT_ERROR` (declined; `message`
+     * quotes the provider), `PAYMENT_NOT_AUTHORIZED` (captured by someone else meanwhile),
+     * `PAYMENT_METHOD_UNAVAILABLE` (its method is switched off, not on this store, or no longer installed; nothing asked),
+     * `IDEMPOTENCY_IN_PROGRESS` (a capture under the same request may still run: check the order
+     * before trying again), `IDEMPOTENCY_OUTCOME_UNKNOWN` (the provider was asked and its answer
+     * was lost: reconcile with the provider, never retry blind), or a fault's code.
+     */
+    code: string | null;
+    message: string | null;
+}
+/** One order's outcome. */
+export interface OrderBulkItem extends BulkActionItem {
+    /**
+     * When `code` is `ORDER_ACTION_UNAVAILABLE`: why the order's own status (`orders.status`) did
+     * not offer the action, in that read's vocabulary (`STATE`, `INVOICE_LOCKED`, `SHOPPER_CART`,
+     * `HAS_RECORDS`, `UNITS_SHIPPED`, `ACTIVE_FULFILLMENT`, `NOTHING_TO_CANCEL`, …). Null otherwise.
+     */
+    reasonCode: string | null;
+    /** MARK_PAID: each payment the order's item acted on, in order. Null for other actions. */
+    captured: OrderBulkCapture[] | null;
+}
+/** A bulk order run, as `wait()` and `bulkRun()` answer it. */
+export type OrderBulkRun = Omit<BulkActionRun<OrderBulkAction>, 'items'> & {
+    items: OrderBulkItem[];
+};
+export declare const BULK_ORDER_ACTION_MUTATION = "\n  mutation BulkOrderAction($input: BulkOrderActionInput!, $idempotencyKey: String) {\n    bulkOrderAction(input: $input, idempotencyKey: $idempotencyKey) {\n      runId\n    }\n  }\n";
+/**
+ * The run read with the order fields. Its own document, so `catalog.products.bulkRun` keeps
+ * selecting only what an engine without the orders kind has.
+ */
+export declare const ORDER_BULK_RUN_QUERY = "\n  query OrderBulkRun($runId: ID!) {\n    bulkActionRun(runId: $runId) {\n      id\n      kind\n      action\n      status\n      total\n      done\n      items {\n        id\n        status\n        code\n        message\n        newId\n        reasonCode\n        captured {\n          paymentId\n          state\n          code\n          message\n        }\n      }\n      failure {\n        code\n        message\n      }\n    }\n  }\n";
+export declare const DELETE_ORDER_MUTATION = "\n  mutation DeleteOrder($orderId: ID!) {\n    deleteOrder(orderId: $orderId) {\n      result\n      message\n    }\n  }\n";
+/** One read of a bulk order run. A run of another store, or a missing one, is `NotFoundError`. */
+export declare function readOrderBulkRun(transport: Transport, runId: string, options?: Call): Promise<OrderBulkRun>;
+/** `orders.bulk`; see `OrdersModule.bulk`. */
+export declare function bulkOrders(transport: Transport, input: OrderBulkInput, options?: Call): Promise<JobHandle<OrderBulkRun>>;
+/**
+ * `orders.delete`; see `OrdersModule.delete`. The engine's `NOT_DELETED` is raised as every other
+ * `*_NOT_DELETED` refusal of this SDK is (`assertDeleted`): a `ConflictError` with the engine's own
+ * reason.
+ */
+export declare function deleteOrder(transport: Transport, orderId: string, options?: Call): Promise<void>;

package/dist/orders/bulk.js

@@ -0,0 +1,150 @@
+/**
+ * `admin.orders.bulk`, `admin.orders.bulkRun` and `admin.orders.delete` (headless spec §7
+ * `orders.bulk`, plan W9-43; rulings G19, G28, G29).
+ */
+import { idempotencyKey, ValidationError } from '@sixtyninecommerce/core';
+import { assertDeleted, fieldOf } from '../catalog/types.js';
+import { bulkActionHandle, } from '../jobs/bulk-action-run.js';
+export const ORDER_BULK_ACTIONS = [
+    'TRANSITION',
+    'CANCEL',
+    'DELETE',
+    'MARK_PAID',
+];
+/** The engine's bound on one bulk run (`MAX_BULK_ACTION_ITEMS`). Split a larger selection. */
+export const MAX_BULK_ORDERS = 50;
+/**
+ * The states a TRANSITION never names, each with its own action or door: `Cancelled` (CANCEL),
+ * `PaymentSettled` (MARK_PAID), `Modifying` (the order edit) and `AddingItems`.
+ */
+export const ORDER_BULK_TRANSITION_REFUSED = [
+    'Cancelled',
+    'PaymentSettled',
+    'Modifying',
+    'AddingItems',
+];
+export const BULK_ORDER_ACTION_MUTATION = /* GraphQL */ `
+  mutation BulkOrderAction($input: BulkOrderActionInput!, $idempotencyKey: String) {
+    bulkOrderAction(input: $input, idempotencyKey: $idempotencyKey) {
+      runId
+    }
+  }
+`;
+/**
+ * The run read with the order fields. Its own document, so `catalog.products.bulkRun` keeps
+ * selecting only what an engine without the orders kind has.
+ */
+export const ORDER_BULK_RUN_QUERY = /* GraphQL */ `
+  query OrderBulkRun($runId: ID!) {
+    bulkActionRun(runId: $runId) {
+      id
+      kind
+      action
+      status
+      total
+      done
+      items {
+        id
+        status
+        code
+        message
+        newId
+        reasonCode
+        captured {
+          paymentId
+          state
+          code
+          message
+        }
+      }
+      failure {
+        code
+        message
+      }
+    }
+  }
+`;
+export const DELETE_ORDER_MUTATION = /* GraphQL */ `
+  mutation DeleteOrder($orderId: ID!) {
+    deleteOrder(orderId: $orderId) {
+      result
+      message
+    }
+  }
+`;
+function refuse(message) {
+    return new ValidationError({
+        code: 'BULK_ACTION_INPUT_INVALID',
+        message,
+        status: 400,
+        service: 'vendure',
+    });
+}
+/** The engine's own checks of a submit (`BULK_ACTION_INPUT_INVALID`), before sending. */
+function assertBulkInput(input) {
+    if (!ORDER_BULK_ACTIONS.includes(input?.action)) {
+        throw refuse(`"${String(input?.action)}" is not a bulk order action: ${ORDER_BULK_ACTIONS.join(', ')}. Nothing was sent.`);
+    }
+    const ids = input.orderIds;
+    if (!Array.isArray(ids) || ids.length === 0) {
+        throw refuse('Name at least one order. Nothing was sent.');
+    }
+    if (ids.length > MAX_BULK_ORDERS) {
+        throw refuse(`Name at most ${String(MAX_BULK_ORDERS)} orders in one bulk action; this one named ${String(ids.length)}. Split the selection into several actions. Nothing was sent.`);
+    }
+    if (new Set(ids.map((id) => String(id).toLowerCase())).size !== ids.length) {
+        throw refuse('The selection names an order more than once. Name each order once. Nothing was sent.');
+    }
+    const toState = input.toState?.trim() ?? '';
+    if (input.action === 'TRANSITION') {
+        if (toState === '')
+            throw refuse('Name the status to move the orders to. Nothing was sent.');
+        if (ORDER_BULK_TRANSITION_REFUSED.includes(toState)) {
+            throw refuse(`Orders are not moved to "${toState}" by a status change${toState === 'Cancelled'
+                ? ': use CANCEL'
+                : toState === 'PaymentSettled'
+                    ? ': use MARK_PAID'
+                    : ''}. Nothing was sent.`);
+        }
+    }
+    else if (toState !== '') {
+        throw refuse(`toState is only for TRANSITION, not ${input.action}. Nothing was sent.`);
+    }
+    if ((input.reason?.trim() ?? '') !== '' && input.action !== 'CANCEL') {
+        throw refuse(`reason is only for CANCEL, not ${input.action}. Nothing was sent.`);
+    }
+}
+/** One read of a bulk order run. A run of another store, or a missing one, is `NotFoundError`. */
+export function readOrderBulkRun(transport, runId, options) {
+    return fieldOf(transport, ORDER_BULK_RUN_QUERY, 'bulkActionRun', { runId }, options);
+}
+/** `orders.bulk`; see `OrdersModule.bulk`. */
+export async function bulkOrders(transport, input, options) {
+    assertBulkInput(input);
+    // Minted when the caller gave none, so a retry of THIS call answers the same run instead of
+    // starting a second one (and capturing nothing twice).
+    const key = options?.idempotencyKey ?? idempotencyKey();
+    const toState = input.toState?.trim();
+    const reason = input.reason?.trim();
+    const { runId } = await fieldOf(transport, BULK_ORDER_ACTION_MUTATION, 'bulkOrderAction', {
+        input: {
+            action: input.action,
+            orderIds: [...input.orderIds],
+            // Omitted, never null, when not given: an absent option stays off the wire.
+            ...(toState ? { toState } : {}),
+            ...(reason ? { reason } : {}),
+        },
+        idempotencyKey: key,
+    }, { ...options, idempotencyKey: key });
+    return bulkActionHandle(transport, runId, options, (id, call) => readOrderBulkRun(transport, id, call));
+}
+/**
+ * `orders.delete`; see `OrdersModule.delete`. The engine's `NOT_DELETED` is raised as every other
+ * `*_NOT_DELETED` refusal of this SDK is (`assertDeleted`): a `ConflictError` with the engine's own
+ * reason.
+ */
+export async function deleteOrder(transport, orderId, options) {
+    assertDeleted('ORDER_NOT_DELETED', [
+        await fieldOf(transport, DELETE_ORDER_MUTATION, 'deleteOrder', { orderId }, options),
+    ]);
+}