@sixtyninecommerce/admin 0.11.0 → 0.13.0

package/dist/content/menus.d.ts

@@ -0,0 +1,254 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/**
+ * The item types the CMS accepts on a new menu item (`CreateMenuItemDto.item_type`), pinned
+ * against the CMS's published `openapi.json` by `content-coverage.spec.ts`. A read types
+ * `itemType` as a plain string on purpose: a type the CMS adds later must not turn a read into a
+ * type error.
+ */
+export type MenuItemType = 'internal' | 'external' | 'collection_item' | 'collection_page' | 'heading' | 'product' | 'product_collection';
+/** One language's label of a menu item. */
+export interface MenuItemTranslation {
+    id: string;
+    menuItemId: string;
+    /** e.g. `en`, `nl`, `de`. */
+    languageCode: string;
+    label: string;
+    /** The link's title attribute. */
+    title: string | null;
+    createdAt: string;
+    updatedAt: string;
+    [extra: string]: unknown;
+}
+/**
+ * One entry of a menu, as the CMS stores it.
+ *
+ * `metadata` is stored VERBATIM (its keys are the writer's own): this SDK never case-converts
+ * it, in either direction, so a fetched `metadata` can be written back unchanged.
+ */
+export interface MenuItem {
+    id: string;
+    menuId: string;
+    /** The item this one is nested under, or null for a top-level item. */
+    parentId: string | null;
+    /** One of {@link MenuItemType}, typed open so a newer CMS's type still reads. */
+    itemType: string;
+    /** The link of an `internal` or `external` item. */
+    url: string | null;
+    /** The linked entity: a CMS item or content type id, or a product / collection id. */
+    targetId: string | null;
+    /** Order among the item's siblings. */
+    position: number;
+    openInNewTab: boolean;
+    metadata: Record<string, unknown> | null;
+    /**
+     * The item's labels, one per language. Every item of `menus.get`'s flat `items` list has them,
+     * and so do the answers of `items.create` and `items.update`; an item's `children` do not (nor
+     * does `items.create`'s answer from a CMS before 2026-10-14).
+     */
+    translations?: MenuItemTranslation[];
+    /** The item's direct children (on `menus.get` only), without their translations. */
+    children?: MenuItem[];
+    /**
+     * The storefront path a `collection_item` or `collection_page` item links to, when its target
+     * resolves in this store (on `menus.get` only); absent otherwise.
+     */
+    resolvedPath?: string;
+    createdAt: string;
+    updatedAt: string;
+    [extra: string]: unknown;
+}
+/** A navigation menu (a header, a footer column), as the CMS stores it. */
+export interface Menu {
+    id: string;
+    channelId: string;
+    name: string;
+    /** Unique within the store: what a storefront reads the menu by. */
+    slug: string;
+    description: string | null;
+    /** Free-form presentation data for the menu as a whole, stored verbatim. */
+    metadata: Record<string, unknown> | null;
+    /** Live items of the menu, nested ones included. On `menus.list` only. */
+    itemCount?: number;
+    /**
+     * Every live item of the menu, nested ones included, as a FLAT list: build the tree from each
+     * item's `parentId`. On `menus.get` and `menus.getBySlug` only.
+     */
+    items?: MenuItem[];
+    createdAt: string;
+    updatedAt: string;
+    [extra: string]: unknown;
+}
+export interface MenuListOptions extends ListOptions {
+    /** Menus whose name contains this, ignoring case. */
+    search?: string;
+    /**
+     * `name`, `created_at` or `updated_at`, with a leading `-` for descending. Anything else (and
+     * no sort) is newest first.
+     */
+    sort?: string;
+}
+/** Exactly what `CreateMenuDto` whitelists. */
+export interface CreateMenuInput {
+    name: string;
+    /** Lowercase letters, digits and hyphens. */
+    slug: string;
+    description?: string | null;
+    /** Stored verbatim. */
+    metadata?: Record<string, unknown> | null;
+}
+/**
+ * What `UpdateMenuDto` whitelists. An absent key leaves the stored value alone; `null` clears
+ * `description` and `metadata`. `metadata` is replaced whole, never merged.
+ */
+export interface UpdateMenuInput {
+    name?: string;
+    slug?: string;
+    description?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+/** One language's label, as `MenuItemTranslationDto` takes it. */
+export interface MenuItemTranslationInput {
+    languageCode: string;
+    label: string;
+    /** `null` clears the title; an absent key leaves it alone. */
+    title?: string | null;
+}
+/**
+ * Exactly what `CreateMenuItemDto` whitelists — not `Partial<MenuItem>`: the CMS runs
+ * `forbidNonWhitelisted`, so handing a fetched item back (with its `id` and timestamps) is a 400.
+ */
+export interface CreateMenuItemInput {
+    itemType: MenuItemType;
+    url?: string | null;
+    targetId?: string | null;
+    /** Nests the item under another item of the SAME menu. */
+    parentId?: string | null;
+    /** Defaults to after the last of its siblings. */
+    position?: number;
+    openInNewTab?: boolean;
+    /** Stored verbatim. */
+    metadata?: Record<string, unknown> | null;
+    /** Each language given is written; the others are left alone. */
+    translations?: MenuItemTranslationInput[];
+}
+/**
+ * The members `items.update` acts on. An absent key leaves the stored value alone; `null` clears
+ * `url`, `targetId`, `metadata`, and `parentId` (back to the top level). A changed `position`
+ * moves the item among its siblings and shifts the ones in between.
+ *
+ * A move to another parent is NOT renumbered correctly. With a new `position`, the shift above
+ * runs on the NEW parent's children between the item's old and new numbers, as if both numbers
+ * belonged to one list, so two of those children can end up sharing a number; with no new
+ * `position` (or the same number) nothing shifts and the item can share a number with one of
+ * them. Either way the old parent's children keep the gap the item left. After such a move, read
+ * the menu again and set each sibling's `position`.
+ */
+export interface UpdateMenuItemInput {
+    itemType?: MenuItemType;
+    url?: string | null;
+    targetId?: string | null;
+    parentId?: string | null;
+    position?: number;
+    openInNewTab?: boolean;
+    metadata?: Record<string, unknown> | null;
+    translations?: MenuItemTranslationInput[];
+}
+/**
+ * A menu's items. Every method takes the menu's id first; an item of another menu, or of another
+ * store's menu, is `NotFoundError` (404). Refusals as on {@link ContentMenusModule}; a `parentId`
+ * that is not a live item of the same menu (or would put the item under itself or one of its own
+ * children) is `ValidationError` with code `MENU_ITEM_PARENT_INVALID`.
+ */
+export interface ContentMenuItemsModule {
+    /**
+     * Adds an item. Answers the item as stored, with its translations (a CMS before 2026-10-14
+     * answers it without them, and with `parentId: null` for a nested item).
+     *
+     * @effect write
+     * @permission CreateCmsMenu
+     */
+    create(menuId: string, input: CreateMenuItemInput, options?: Call): Promise<MenuItem>;
+    /**
+     * Writes what the input names in one transaction. Answers the item with its translations. A
+     * move to another parent leaves both parents' numbering to repair (see
+     * {@link UpdateMenuItemInput}).
+     *
+     * @effect write
+     * @permission UpdateCmsMenu
+     */
+    update(menuId: string, itemId: string, input: UpdateMenuItemInput, options?: Call): Promise<MenuItem>;
+    /**
+     * Removes the item from the menu: storefronts stop rendering it, and nothing in the SDK brings
+     * it back. Its children are NOT removed: they stay in the menu's `items`, their `parentId`
+     * still naming the removed item, so move or delete them first.
+     *
+     * @effect destructive
+     * @permission DeleteCmsMenu
+     */
+    delete(menuId: string, itemId: string, options?: Call): Promise<void>;
+}
+/**
+ * The store's navigation menus, read and written through the CMS.
+ *
+ * Reads need no permission: storefronts read the same routes, and every caller gets the same
+ * answer. Writes need the permission each method names (`@permission`).
+ *
+ * Refusals are the CMS's problem+json, mapped by status:
+ * - `NotFoundError` (404, `NOT_FOUND`): no such menu or item in this store.
+ * - `ConflictError` (409, `CONFLICT`): the slug is taken in this store.
+ * - `ValidationError` (400): `VALIDATION_FAILED` with one `details[]` entry per refused input
+ *   member (a slug that is not lowercase-and-hyphens, an unknown `itemType`, an id that is not a
+ *   UUID), or a code of its own (`MENU_ITEM_PARENT_INVALID`).
+ * - `PermissionDeniedError` (403): the credential lacks the write's permission.
+ *
+ * Every write records the platform event a storefront revalidates on (`content.site_content_changed`
+ * with kind `menu`); nothing here emits one. No write is deduplicated: an `idempotencyKey` is
+ * sent and acts on nothing, so a repeated `items.create` is a second item.
+ */
+export interface ContentMenusModule {
+    /**
+     * The store's menus, a page at a time, newest first unless `sort` says otherwise; each with
+     * its `itemCount`, none with its items. Pages are offset-based (`Page.total` counts the
+     * matches), so `after: offsetCursor((n - 1) * size)` opens page `n`.
+     *
+     * @effect read
+     */
+    list(options?: MenuListOptions): Promise<Page<Menu>>;
+    /**
+     * One menu with every live item (`items`, a flat list).
+     *
+     * @effect read
+     */
+    get(id: string, options?: Call): Promise<Menu>;
+    /**
+     * One menu by its slug, with every live item: what a storefront renders.
+     *
+     * @effect read
+     */
+    getBySlug(slug: string, options?: Call): Promise<Menu>;
+    /**
+     * Adds an empty menu. Answers it without items.
+     *
+     * @effect write
+     * @permission CreateCmsMenu
+     */
+    create(input: CreateMenuInput, options?: Call): Promise<Menu>;
+    /**
+     * Writes what the input names. A new `slug` changes what storefronts read the menu by.
+     *
+     * @effect write
+     * @permission UpdateCmsMenu
+     */
+    update(id: string, input: UpdateMenuInput, options?: Call): Promise<Menu>;
+    /**
+     * Removes the menu with its items: storefronts reading it by slug get `NotFoundError`, its
+     * slug is free again, and nothing in the SDK brings it back.
+     *
+     * @effect destructive
+     * @permission DeleteCmsMenu
+     */
+    delete(id: string, options?: Call): Promise<void>;
+    items: ContentMenuItemsModule;
+}
+export declare function createContentMenusModule(transport: Transport): ContentMenusModule;

package/dist/content/menus.js

@@ -0,0 +1,70 @@
+import { createPage, offsetCursor, PLATFORM_PASSTHROUGH_KEYS, readOffsetCursor, } from '@sixtyninecommerce/core';
+const MENUS = '/menus';
+const DEFAULT_PAGE_SIZE = 50;
+function menuPath(id) {
+    return `${MENUS}/${encodeURIComponent(id)}`;
+}
+function itemPath(menuId, itemId) {
+    return `${menuPath(menuId)}/items/${encodeURIComponent(itemId)}`;
+}
+export function createContentMenusModule(transport) {
+    async function listPage(offset, limit, options) {
+        const body = await transport.rest('cms', {
+            method: 'GET',
+            path: MENUS,
+            // `offset` is always sent: it keeps the CMS out of its keyset mode, which cannot resume
+            // a `sort` (400 `CURSOR_ORDERING_CONFLICT`) and cannot open page n. Without `limit` an
+            // offset read answers the WHOLE list.
+            query: { limit, offset, search: options?.search, sort: options?.sort },
+        }, { ...options, preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+        const items = body.data ?? [];
+        // An offset read echoes neither the offset nor a cursor, so the page is built from what
+        // THIS call asked for.
+        const total = body.pagination?.total ?? items.length;
+        const advanced = offset + (items.length > 0 ? items.length : limit);
+        const hasNext = advanced < total;
+        return createPage(items, { nextCursor: hasNext ? offsetCursor(advanced) : null, hasNext, total }, (cursor) => listPage(readOffsetCursor(cursor), limit, options));
+    }
+    async function readMenu(path, options) {
+        const body = await transport.rest('cms', { method: 'GET', path }, { ...options, preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+        return body.data;
+    }
+    const items = {
+        async create(menuId, input, options) {
+            const body = await transport.rest('cms', { method: 'POST', path: `${menuPath(menuId)}/items`, body: input }, { ...options, preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+            return body.data;
+        },
+        async update(menuId, itemId, input, options) {
+            const body = await transport.rest('cms', { method: 'PATCH', path: itemPath(menuId, itemId), body: input }, { ...options, preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+            return body.data;
+        },
+        async delete(menuId, itemId, options) {
+            await transport.rest('cms', { method: 'DELETE', path: itemPath(menuId, itemId), expect: 'void' }, options);
+        },
+    };
+    return {
+        list(options) {
+            const limit = options?.limit ?? DEFAULT_PAGE_SIZE;
+            const offset = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+            return listPage(offset, limit, options);
+        },
+        get(id, options) {
+            return readMenu(menuPath(id), options);
+        },
+        getBySlug(slug, options) {
+            return readMenu(`${MENUS}/by-slug/${encodeURIComponent(slug)}`, options);
+        },
+        async create(input, options) {
+            const body = await transport.rest('cms', { method: 'POST', path: MENUS, body: input }, { ...options, preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+            return body.data;
+        },
+        async update(id, input, options) {
+            const body = await transport.rest('cms', { method: 'PATCH', path: menuPath(id), body: input }, { ...options, preserveKeys: PLATFORM_PASSTHROUGH_KEYS });
+            return body.data;
+        },
+        async delete(id, options) {
+            await transport.rest('cms', { method: 'DELETE', path: menuPath(id), expect: 'void' }, options);
+        },
+        items,
+    };
+}

package/dist/content/strings.d.ts

@@ -0,0 +1,137 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/** One language's value of a content string. */
+export interface ContentStringValue {
+    id: string;
+    contentStringId: string;
+    /** e.g. `en`, `nl`, `de`. */
+    languageCode: string;
+    value: string;
+    createdAt: string;
+    updatedAt: string;
+    [extra: string]: unknown;
+}
+/**
+ * A content string: one translatable piece of storefront copy (a button label, a footer line),
+ * read by its `key`.
+ */
+export interface ContentString {
+    id: string;
+    channelId: string;
+    /** Unique within the store; dot-separated by convention (`footer.copyright`). */
+    key: string;
+    /** A note for translators. */
+    description: string | null;
+    /** One value per language, in no guaranteed order. */
+    values: ContentStringValue[];
+    createdAt: string;
+    updatedAt: string;
+    [extra: string]: unknown;
+}
+export interface ContentStringListOptions extends ListOptions {
+    /**
+     * A full-text search over keys, descriptions and values, answered in key order; its
+     * `Page.total` is the search engine's estimate. Without one the list is every string of the
+     * store, in key order.
+     */
+    search?: string;
+}
+/** One language's value, as `ContentStringValueDto` takes it. */
+export interface ContentStringValueInput {
+    languageCode: string;
+    value: string;
+}
+/** Exactly what `CreateContentStringDto` whitelists. */
+export interface CreateContentStringInput {
+    key: string;
+    description?: string | null;
+    values?: ContentStringValueInput[];
+}
+/**
+ * What `UpdateContentStringDto` whitelists. An absent key leaves the stored value alone; `null`
+ * clears `description`. `values` writes each language it names and leaves every other language's
+ * value as stored: there is no way to remove one language's value here.
+ */
+export interface UpdateContentStringInput {
+    key?: string;
+    description?: string | null;
+    values?: ContentStringValueInput[];
+}
+/** One string of a bulk import: its key and the values to write. */
+export interface ContentStringImportItem {
+    key: string;
+    values: ContentStringValueInput[];
+}
+/** Every string of the store: `key → language code → value`. */
+export type ContentStringsExport = Record<string, Record<string, string>>;
+/**
+ * The store's content strings, read and written through the CMS.
+ *
+ * Reads need no permission: storefronts read the same routes, and every caller gets the same
+ * answer. Writes need the permission each method names (`@permission`).
+ *
+ * Refusals are the CMS's problem+json, mapped by status:
+ * - `NotFoundError` (404, `NOT_FOUND`): no such string in this store.
+ * - `ConflictError` (409, `CONFLICT`): the key is taken in this store.
+ * - `ValidationError` (400): `VALIDATION_FAILED` with one `details[]` entry per refused input
+ *   member (a key over 500 characters, a value that is not a string, an id that is not a UUID).
+ * - `PermissionDeniedError` (403): the credential lacks the write's permission.
+ *
+ * No write here is deduplicated: an `idempotencyKey` is sent and acts on nothing, so a repeated
+ * `create` is refused `CONFLICT` on the same key. `import` is safe to repeat: it upserts.
+ */
+export interface ContentStringsModule {
+    /**
+     * The store's strings with their values, a page at a time, in key order. Pages are
+     * offset-based (`Page.total` counts the matches), so `after: offsetCursor((n - 1) * size)`
+     * opens page `n`.
+     *
+     * @effect read
+     */
+    list(options?: ContentStringListOptions): Promise<Page<ContentString>>;
+    /**
+     * One string with its values.
+     *
+     * @effect read
+     */
+    get(id: string, options?: Call): Promise<ContentString>;
+    /**
+     * @effect write
+     * @permission CreateCmsContent
+     */
+    create(input: CreateContentStringInput, options?: Call): Promise<ContentString>;
+    /**
+     * Writes what the input names in one transaction. Answers the string with all its values.
+     *
+     * @effect write
+     * @permission UpdateCmsContent
+     */
+    update(id: string, input: UpdateContentStringInput, options?: Call): Promise<ContentString>;
+    /**
+     * Removes the string with its values: a storefront reading its key falls back to its own
+     * default, the key is free again, and nothing in the SDK brings it back.
+     *
+     * @effect destructive
+     * @permission DeleteCmsContent
+     */
+    delete(id: string, options?: Call): Promise<void>;
+    /**
+     * Writes many strings in one transaction: a key the store lacks is created, and each value
+     * named is written over the stored one; values of languages not named are left alone.
+     * Answers how many strings it wrote. All or nothing: one refused item writes none.
+     *
+     * @effect write
+     * @permission CreateCmsContent
+     */
+    import(items: readonly ContentStringImportItem[], options?: Call): Promise<{
+        imported: number;
+    }>;
+    /**
+     * Every string of the store as one map, `key → language code → value`, keys exactly as
+     * stored.
+     *
+     * @effect read
+     */
+    export(options?: Call): Promise<ContentStringsExport>;
+}
+export declare function createContentStringsModule(transport: Transport): ContentStringsModule;

package/dist/content/strings.js

@@ -0,0 +1,82 @@
+import { createPage, offsetCursor, readOffsetCursor, ValidationError, } from '@sixtyninecommerce/core';
+const STRINGS = '/content-strings';
+const DEFAULT_PAGE_SIZE = 100;
+function stringPath(id) {
+    return `${STRINGS}/${encodeURIComponent(id)}`;
+}
+/** A plain object whose every value passes `entryIs` (a string, by default). */
+function isStringMap(value, entryIs = (entry) => typeof entry === 'string') {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.values(value).every((entry) => entryIs(entry)));
+}
+export function createContentStringsModule(transport) {
+    async function listPage(offset, limit, options) {
+        const body = await transport.rest('cms', {
+            method: 'GET',
+            path: STRINGS,
+            // Never `after`: that switches the CMS to its keyset mode, which orders newest first
+            // instead of by key and refuses a search. Without `limit` an offset read answers the
+            // WHOLE list.
+            query: { limit, offset, search: options?.search },
+        }, options);
+        const items = body.data ?? [];
+        // An offset read echoes neither the offset nor a cursor, so the page is built from what
+        // THIS call asked for.
+        const total = body.pagination?.total ?? items.length;
+        const advanced = offset + (items.length > 0 ? items.length : limit);
+        const hasNext = advanced < total;
+        return createPage(items, { nextCursor: hasNext ? offsetCursor(advanced) : null, hasNext, total }, (cursor) => listPage(readOffsetCursor(cursor), limit, options));
+    }
+    return {
+        list(options) {
+            const limit = options?.limit ?? DEFAULT_PAGE_SIZE;
+            const offset = options?.after === undefined ? 0 : readOffsetCursor(options.after);
+            return listPage(offset, limit, options);
+        },
+        async get(id, options) {
+            const body = await transport.rest('cms', { method: 'GET', path: stringPath(id) }, options);
+            return body.data;
+        },
+        async create(input, options) {
+            const body = await transport.rest('cms', { method: 'POST', path: STRINGS, body: input }, options);
+            return body.data;
+        },
+        async update(id, input, options) {
+            const body = await transport.rest('cms', { method: 'PATCH', path: stringPath(id), body: input }, options);
+            return body.data;
+        },
+        async delete(id, options) {
+            await transport.rest('cms', { method: 'DELETE', path: stringPath(id), expect: 'void' }, options);
+        },
+        async import(items, options) {
+            const body = await transport.rest('cms', { method: 'POST', path: `${STRINGS}/import`, body: { items } }, options);
+            return body.data;
+        },
+        async export(options) {
+            // The answer is a bare map keyed by the merchant's own keys (`footer.copyright_notice`),
+            // not an envelope: every key is data, and the JSON reader would camelise all of them
+            // (`footer.copyrightNotice`), which `preserveKeys` cannot stop at the top level. So the
+            // body is taken as bytes and parsed here, untouched.
+            const answer = await transport.rest('cms', { method: 'GET', path: `${STRINGS}/export`, expect: 'blob' }, options);
+            const text = await answer.blob.text();
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = undefined;
+            }
+            if (!isStringMap(parsed, (entry) => isStringMap(entry))) {
+                throw new ValidationError({
+                    code: 'MALFORMED_EXPORT_RESPONSE',
+                    message: 'The content-string export was not a map of key to language to value.',
+                    status: 400,
+                    service: 'cms',
+                });
+            }
+            return parsed;
+        },
+    };
+}

package/dist/customers/delivery-terms.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A customer's resolved delivery terms (`admin.customers.deliveryTerms`, W10-57): the shipping
+ * method, Incoterm, lead time and delivery advice that govern the customer's orders, whichever
+ * source decides them (an ERP such as Exact Online, or nothing).
+ */
+import type { Transport } from '@sixtyninecommerce/core';
+import type { OrderDeliveryAdvice, OrderDeliveryTermsStatus } from '../orders/get.js';
+import type { Call } from '../types.js';
+/** One customer's delivery terms, as an order placed now would take them. */
+export interface CustomerDeliveryTerms {
+    customerId: string | null;
+    /** Where the terms come from (`exact-online`, …). */
+    source: string;
+    /** An ERP governs the terms: staff cannot change them here. */
+    managedExternally: boolean;
+    status: OrderDeliveryTermsStatus;
+    shippingMethodStatus: OrderDeliveryTermsStatus;
+    policyStatus: OrderDeliveryTermsStatus;
+    /** The terms in a sentence. */
+    summary: string;
+    /** The store's shipping method the customer's orders default to. */
+    preferredShippingMethodId: string | null;
+    preferredShippingMethodCode: string | null;
+    preferredShippingMethodName: string | null;
+    /** The preferred method is offered to the customer right now. */
+    preferredShippingMethodAvailable: boolean;
+    /** The store's shipping methods the customer may choose. */
+    eligibleShippingMethodIds: string[];
+    incotermStatus: OrderDeliveryTermsStatus;
+    incotermCode: string | null;
+    incotermVersion: number | null;
+    /** The Incoterm's named place. */
+    incotermAddress: string | null;
+    incotermDescription: string | null;
+    /** Days between the order and its dispatch. */
+    shippingLeadDays: number | null;
+    deliveryAdvice: OrderDeliveryAdvice;
+    stale: boolean;
+    /** ISO-8601, UTC: when the source last changed them. */
+    syncedAt: string | null;
+    warning: string | null;
+}
+export declare const CUSTOMER_DELIVERY_TERMS_QUERY = "\n  query CustomerDeliveryTerms($customerId: ID!) {\n    customerDeliveryTerms(customerId: $customerId) {\n      customerId\n      source\n      managedExternally\n      status\n      shippingMethodStatus\n      policyStatus\n      summary\n      preferredShippingMethodId\n      preferredShippingMethodCode\n      preferredShippingMethodName\n      preferredShippingMethodAvailable\n      eligibleShippingMethodIds\n      incotermStatus\n      incotermCode\n      incotermVersion\n      incotermAddress\n      incotermDescription\n      shippingLeadDays\n      deliveryAdvice\n      stale\n      syncedAt\n      warning\n    }\n  }\n";
+export declare function readCustomerDeliveryTerms(transport: Transport, customerId: string, options: Call | undefined): Promise<CustomerDeliveryTerms | null>;

package/dist/customers/delivery-terms.js

@@ -0,0 +1,32 @@
+import { fieldOf } from '../catalog/types.js';
+export const CUSTOMER_DELIVERY_TERMS_QUERY = /* GraphQL */ `
+  query CustomerDeliveryTerms($customerId: ID!) {
+    customerDeliveryTerms(customerId: $customerId) {
+      customerId
+      source
+      managedExternally
+      status
+      shippingMethodStatus
+      policyStatus
+      summary
+      preferredShippingMethodId
+      preferredShippingMethodCode
+      preferredShippingMethodName
+      preferredShippingMethodAvailable
+      eligibleShippingMethodIds
+      incotermStatus
+      incotermCode
+      incotermVersion
+      incotermAddress
+      incotermDescription
+      shippingLeadDays
+      deliveryAdvice
+      stale
+      syncedAt
+      warning
+    }
+  }
+`;
+export async function readCustomerDeliveryTerms(transport, customerId, options) {
+    return ((await fieldOf(transport, CUSTOMER_DELIVERY_TERMS_QUERY, 'customerDeliveryTerms', { customerId }, options)) ?? null);
+}