@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/shipping/fulfillment-profiles.js

@@ -0,0 +1,104 @@
+import { assertDeleted } from '../catalog/types.js';
+const PROFILE_FIELDS = /* GraphQL */ `
+  id
+  code
+  name
+  enabled
+  stockLocationId
+  defaultHandlerCode
+  shippingMethodId
+  minOrder
+  isDefault
+  createdAt
+  updatedAt
+`;
+const NOTIFICATION_FIELDS = /* GraphQL */ `
+  id
+  handlerCode
+  enabled
+  emails
+  createdAt
+  updatedAt
+`;
+export const FULFILLMENT_PROFILES_QUERY = /* GraphQL */ `
+  query FulfillmentProfiles {
+    fulfillmentProfiles { ${PROFILE_FIELDS} }
+  }
+`;
+export const FULFILLMENT_PROFILE_QUERY = /* GraphQL */ `
+  query FulfillmentProfile($id: ID!) {
+    fulfillmentProfile(id: $id) { ${PROFILE_FIELDS} }
+  }
+`;
+export const CREATE_FULFILLMENT_PROFILE_MUTATION = /* GraphQL */ `
+  mutation CreateFulfillmentProfile($input: CreateFulfillmentProfileInput!) {
+    createFulfillmentProfile(input: $input) { ${PROFILE_FIELDS} }
+  }
+`;
+export const UPDATE_FULFILLMENT_PROFILE_MUTATION = /* GraphQL */ `
+  mutation UpdateFulfillmentProfile($input: UpdateFulfillmentProfileInput!) {
+    updateFulfillmentProfile(input: $input) { ${PROFILE_FIELDS} }
+  }
+`;
+export const DELETE_FULFILLMENT_PROFILE_MUTATION = /* GraphQL */ `
+  mutation DeleteFulfillmentProfile($id: ID!) {
+    deleteFulfillmentProfile(id: $id) { result message }
+  }
+`;
+export const SET_DEFAULT_FULFILLMENT_PROFILE_MUTATION = /* GraphQL */ `
+  mutation SetDefaultFulfillmentProfile($id: ID!) {
+    setDefaultFulfillmentProfile(id: $id) { ${PROFILE_FIELDS} }
+  }
+`;
+export const FULFILLMENT_HANDLER_NOTIFICATIONS_QUERY = /* GraphQL */ `
+  query FulfillmentHandlerNotifications {
+    fulfillmentHandlerNotifications { ${NOTIFICATION_FIELDS} }
+  }
+`;
+export const SET_FULFILLMENT_HANDLER_NOTIFICATION_MUTATION = /* GraphQL */ `
+  mutation SetFulfillmentHandlerNotification($input: SetFulfillmentHandlerNotificationInput!) {
+    setFulfillmentHandlerNotification(input: $input) { ${NOTIFICATION_FIELDS} }
+  }
+`;
+export function createFulfillmentProfilesModule(transport) {
+    const call = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+    return {
+        async list(options) {
+            const data = await call(FULFILLMENT_PROFILES_QUERY, undefined, options);
+            return data.fulfillmentProfiles;
+        },
+        async get(id, options) {
+            const data = await call(FULFILLMENT_PROFILE_QUERY, { id }, options);
+            return data.fulfillmentProfile ?? null;
+        },
+        async create(input, options) {
+            const data = await call(CREATE_FULFILLMENT_PROFILE_MUTATION, { input }, options);
+            return data.createFulfillmentProfile;
+        },
+        async update(id, input, options) {
+            const data = await call(UPDATE_FULFILLMENT_PROFILE_MUTATION, 
+            // The id goes last: an `id` key smuggled into the patch cannot redirect the write.
+            { input: { ...input, id } }, options);
+            return data.updateFulfillmentProfile;
+        },
+        async delete(id, options) {
+            const data = await call(DELETE_FULFILLMENT_PROFILE_MUTATION, { id }, options);
+            // The engine refuses by throwing today; a NOT_DELETED answer must still never pass as done.
+            assertDeleted('FULFILLMENT_PROFILE_NOT_DELETED', [data.deleteFulfillmentProfile]);
+        },
+        async setDefault(id, options) {
+            const data = await call(SET_DEFAULT_FULFILLMENT_PROFILE_MUTATION, { id }, options);
+            return data.setDefaultFulfillmentProfile;
+        },
+        handlerNotifications: {
+            async list(options) {
+                const data = await call(FULFILLMENT_HANDLER_NOTIFICATIONS_QUERY, undefined, options);
+                return data.fulfillmentHandlerNotifications;
+            },
+            async set(input, options) {
+                const data = await call(SET_FULFILLMENT_HANDLER_NOTIFICATION_MUTATION, { input }, options);
+                return data.setFulfillmentHandlerNotification;
+            },
+        },
+    };
+}

package/dist/shipping/hendriks.d.ts

@@ -0,0 +1,97 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/** How the order reference sent to C.J. Hendriks is prefixed. */
+export type HendriksWirePrefixMode = 'year' | 'custom';
+/** A store's C.J. Hendriks 3PL settings: one record per store. */
+export interface HendriksConfig {
+    id: string;
+    channelId: string;
+    /** Gates every Hendriks export of the store. */
+    enabled: boolean;
+    /** The plugins-service export pipeline that sends the orders; `null` is not linked. */
+    pipelineId: string | null;
+    /** `year` prefixes the current UTC year; `custom` prefixes {@link wirePrefixDigits}. */
+    wirePrefixMode: HendriksWirePrefixMode;
+    /** 1 to 4 digits without a leading zero. Only read in `custom` mode; `null` in `year` mode. */
+    wirePrefixDigits: string | null;
+    /**
+     * Refuse to export an order the source platform already sent to its own fulfillment
+     * provider. On by default: while a migrated shop is still live both systems feed the same
+     * warehouse, and neither can spot the other's reference, so the goods would ship twice.
+     */
+    blockSourceFulfilledOrders: boolean;
+    /** ISO-8601, UTC. */
+    createdAt: string;
+    /** ISO-8601, UTC. */
+    updatedAt: string;
+}
+/**
+ * A PATCH: a key left out keeps the stored value. The custom-prefix rule is judged on the
+ * RESULTING settings, so switching to `custom` needs `wirePrefixDigits` in the same call unless
+ * valid digits are already stored.
+ */
+export interface UpdateHendriksConfigInput {
+    enabled?: boolean;
+    /** `null` unlinks the pipeline. */
+    pipelineId?: string | null;
+    wirePrefixMode?: HendriksWirePrefixMode;
+    /** Cleared by the engine whenever the resulting mode is `year`. */
+    wirePrefixDigits?: string | null;
+    blockSourceFulfilledOrders?: boolean;
+}
+/**
+ * The C.J. Hendriks 3PL settings of the store the client is scoped to
+ * (`admin.shipping.hendriks.config`). There is no channel argument: a SuperAdmin head configures
+ * ANOTHER store with `admin.withTenant({ scope: { kind: 'channel', code } })`, or a per-call
+ * `tenant`.
+ */
+export interface HendriksConfigModule {
+    /**
+     * The store's settings, or `null` when it never saved any. Needs `ReadSettings`, and is
+     * answered for a store without the Hendriks plugin too (a head reads it to decide whether to
+     * show the integration).
+     *
+     * @effect read
+     * @permission ReadSettings
+     */
+    get(options?: Call): Promise<HendriksConfig | null>;
+    /**
+     * Save the settings; the first call creates the record (`enabled` off, `year` prefix,
+     * `blockSourceFulfilledOrders` on, unless given). Needs `UpdateSettings`.
+     *
+     * Refused, with nothing saved:
+     * - `HENDRIKS_CONFIG_INVALID` (`ValidationError`, 400): `custom` mode without 1 to 4 digits not
+     *   starting with 0. `details[]` names each field (`wirePrefixDigits`, `wirePrefixMode`), so a
+     *   form can put the reason on it;
+     * - `PLUGIN_ACCESS_DENIED` (`PermissionDeniedError`, 403): the store does not hold the
+     *   Hendriks plugin. An ordinary caller only: the engine never refuses a SuperAdmin on this
+     *   ground, so a SuperAdmin head that must know reads `tenant.entitlements()` on that store;
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` (`BusinessRuleError`, 422): switching the export on,
+     *   or linking a pipeline, in an organization's workspace.
+     *
+     * `pipelineId` is not checked against the store's pipelines; an export through a pipeline
+     * that does not exist fails when it runs.
+     *
+     * @effect write
+     * @permission UpdateSettings
+     */
+    update(input: UpdateHendriksConfigInput, options?: Call): Promise<HendriksConfig>;
+    /**
+     * Delete the store's settings record. Every Hendriks export of the store is refused until
+     * settings are saved again, and the prefix and pipeline link are gone with it. `true` when a
+     * record was deleted, `false` when the store had none. Needs `UpdateSettings`; allowed for a
+     * store that no longer holds the plugin, so it can always remove its connection.
+     *
+     * @effect destructive
+     * @permission UpdateSettings
+     */
+    delete(options?: Call): Promise<boolean>;
+}
+/** `admin.shipping.hendriks`: the C.J. Hendriks 3PL integration of the store. */
+export interface HendriksModule {
+    config: HendriksConfigModule;
+}
+export declare const HENDRIKS_CONFIG_QUERY = "\n  query HendriksConfig {\n    hendriksConfig { \n  id\n  channelId\n  enabled\n  pipelineId\n  wirePrefixMode\n  wirePrefixDigits\n  blockSourceFulfilledOrders\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const UPDATE_HENDRIKS_CONFIG_MUTATION = "\n  mutation UpdateHendriksConfig($input: UpdateHendriksConfigInput!) {\n    updateHendriksConfig(input: $input) { \n  id\n  channelId\n  enabled\n  pipelineId\n  wirePrefixMode\n  wirePrefixDigits\n  blockSourceFulfilledOrders\n  createdAt\n  updatedAt\n }\n  }\n";
+export declare const DELETE_HENDRIKS_CONFIG_MUTATION = "\n  mutation DeleteHendriksConfig {\n    deleteHendriksConfig\n  }\n";
+export declare function createHendriksModule(transport: Transport): HendriksModule;

package/dist/shipping/hendriks.js

@@ -0,0 +1,50 @@
+const CONFIG_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  enabled
+  pipelineId
+  wirePrefixMode
+  wirePrefixDigits
+  blockSourceFulfilledOrders
+  createdAt
+  updatedAt
+`;
+export const HENDRIKS_CONFIG_QUERY = /* GraphQL */ `
+  query HendriksConfig {
+    hendriksConfig { ${CONFIG_FIELDS} }
+  }
+`;
+export const UPDATE_HENDRIKS_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdateHendriksConfig($input: UpdateHendriksConfigInput!) {
+    updateHendriksConfig(input: $input) { ${CONFIG_FIELDS} }
+  }
+`;
+export const DELETE_HENDRIKS_CONFIG_MUTATION = /* GraphQL */ `
+  mutation DeleteHendriksConfig {
+    deleteHendriksConfig
+  }
+`;
+export function createHendriksModule(transport) {
+    return {
+        config: {
+            async get(options) {
+                const data = await transport.graphql({ api: 'admin', query: HENDRIKS_CONFIG_QUERY }, options);
+                return data.hendriksConfig ?? null;
+            },
+            async update(input, options) {
+                const data = await transport.graphql({
+                    api: 'admin',
+                    query: UPDATE_HENDRIKS_CONFIG_MUTATION,
+                    // Sent as given: a key left out stays off the wire (the engine reads an absent
+                    // key as "keep"), and the engine names anything it refuses.
+                    variables: { input },
+                }, options);
+                return data.updateHendriksConfig;
+            },
+            async delete(options) {
+                const data = await transport.graphql({ api: 'admin', query: DELETE_HENDRIKS_CONFIG_MUTATION }, options);
+                return data.deleteHendriksConfig === true;
+            },
+        },
+    };
+}

package/dist/shipping/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Shipping (headless spec §9.2 `shipping`): everything about getting a store's orders to its
+ * customers. Each member lives in a file of its own and is only assembled here, so a branch
+ * that adds one (shipping methods, rate tables, a carrier) adds a file and one line.
+ */
+import type { Transport } from '@sixtyninecommerce/core';
+import { type ShippingDefinitionsModule } from './definitions.js';
+import { type FulfillmentProfilesModule } from './fulfillment-profiles.js';
+import { type HendriksModule } from './hendriks.js';
+import { type ShippingMethodsModule } from './methods.js';
+import { type MyparcelModule } from './myparcel.js';
+import { type ParcelCountSuggestionMethod } from './parcel-count-suggestion.js';
+import { type ParcelRuleModule } from './parcel-rule.js';
+import { type RateTablesModule } from './rate-tables.js';
+import { type ShipToCountriesModule } from './ship-to-countries.js';
+/** `admin.shipping` (spec §9.2 `shipping`). Always the store the client is scoped to. */
+export interface ShippingModule {
+    /** The store's shipping methods: what checkout offers and what each charges. */
+    methods: ShippingMethodsModule;
+    /** What a shipping method's calculator, checker and fulfillment handler may be. */
+    definitions: ShippingDefinitionsModule;
+    /**
+     * The weight-zone rate tables a `weight-zone-calculator` method prices with: per table its
+     * zones (postal-code ranges or countries) and per zone its weight tiers' prices.
+     */
+    rateTables: RateTablesModule;
+    /** How the store counts parcels for extra-parcel shipping charges. */
+    parcelRule: ParcelRuleModule;
+    /**
+     * How many parcels the store's rule gives a set of variant + quantity items.
+     *
+     * @effect read
+     */
+    parcelCountSuggestion: ParcelCountSuggestionMethod;
+    /** The C.J. Hendriks 3PL integration: its settings (`config`). */
+    hendriks: HendriksModule;
+    /**
+     * The MyParcel integration: its set-up (`config`: the API key, label format, on/off and webhook
+     * secret, both secrets read back masked), the carriers MyParcel offers, and the store's stock
+     * locations as parcel senders (`senders`).
+     */
+    myparcel: MyparcelModule;
+    /**
+     * The store's fulfillment profiles (warehouse + handler + shipping method + minimum), its
+     * default profile, and who is emailed per handler when a fulfilment is created.
+     */
+    fulfillmentProfiles: FulfillmentProfilesModule;
+    /**
+     * The countries the store ships to, as checkout applies them: which ones its storefront offers,
+     * which selected ones no shopper can choose, saved or previewed.
+     */
+    shipToCountries: ShipToCountriesModule;
+}
+export declare function createShippingModule(transport: Transport): ShippingModule;

package/dist/shipping/index.js

@@ -0,0 +1,27 @@
+/**
+ * Shipping (headless spec §9.2 `shipping`): everything about getting a store's orders to its
+ * customers. Each member lives in a file of its own and is only assembled here, so a branch
+ * that adds one (shipping methods, rate tables, a carrier) adds a file and one line.
+ */
+import { createShippingDefinitionsModule } from './definitions.js';
+import { createFulfillmentProfilesModule, } from './fulfillment-profiles.js';
+import { createHendriksModule } from './hendriks.js';
+import { createShippingMethodsModule } from './methods.js';
+import { createMyparcelModule } from './myparcel.js';
+import { createParcelCountSuggestion, } from './parcel-count-suggestion.js';
+import { createParcelRuleModule } from './parcel-rule.js';
+import { createRateTablesModule } from './rate-tables.js';
+import { createShipToCountriesModule } from './ship-to-countries.js';
+export function createShippingModule(transport) {
+    return {
+        methods: createShippingMethodsModule(transport),
+        definitions: createShippingDefinitionsModule(transport),
+        rateTables: createRateTablesModule(transport),
+        parcelRule: createParcelRuleModule(transport),
+        parcelCountSuggestion: createParcelCountSuggestion(transport),
+        hendriks: createHendriksModule(transport),
+        myparcel: createMyparcelModule(transport),
+        fulfillmentProfiles: createFulfillmentProfilesModule(transport),
+        shipToCountries: createShipToCountriesModule(transport),
+    };
+}

package/dist/shipping/methods.d.ts

@@ -0,0 +1,205 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import { type ConfigurableOperation, type ConfigurableOperationInput, type LanguageCode } from '../catalog/types.js';
+import type { Call, ListOptions } from '../types.js';
+/** A shipping method's name and description in one language. */
+export interface ShippingMethodTranslation {
+    id: string;
+    /** As the engine spells it: `en`, `nl`, `pt_BR`. */
+    languageCode: string;
+    name: string;
+    description: string;
+}
+/** One shipping method of the store, as its list reads it. */
+export interface ShippingMethodSummary {
+    id: string;
+    /** What checkout and a fulfillment profile name the method by. */
+    code: string;
+    /** In the language the client is set to (`tenant.language`), else the store's default. */
+    name: string;
+    /**
+     * The fulfillment handler of an order fulfilled WITHOUT a fulfillment profile (the profiles
+     * route every other one). `manual-fulfillment` unless a carrier's was picked.
+     */
+    fulfillmentHandlerCode: string;
+    /** What the method charges, with its stored arguments (every value a string). */
+    calculator: ConfigurableOperation;
+    /**
+     * The master switch: a disabled method is offered nowhere (webshop, staff, till) and a cart on
+     * it re-quotes. On unless it was switched off (a method stored before the switch existed).
+     */
+    enabled: boolean;
+    /**
+     * Offered at webshop checkout; staff orders and the till do not read it. On unless it was
+     * switched off. Only meaningful while {@link enabled}.
+     */
+    enabledInStorefront: boolean;
+    /** ISO-8601, UTC. */
+    createdAt: string;
+    /** ISO-8601, UTC. */
+    updatedAt: string;
+}
+/** One shipping method of the store, as its settings read it. */
+export interface ShippingMethod extends ShippingMethodSummary {
+    /** In the same language as {@link name}; empty when the method has none. */
+    description: string;
+    /** Which orders the method is offered for, with its stored arguments. Every method has one. */
+    checker: ConfigurableOperation;
+    /** Every language the method is named in. */
+    translations: ShippingMethodTranslation[];
+    /**
+     * The Exact Online integration created the method from one of its own shipping definitions:
+     * Exact's sync owns its code and calculator (the name is the store's). Written by that sync
+     * only; neither write here takes it.
+     */
+    exactManaged: boolean;
+    /**
+     * Added once per parcel after the first, in minor units and the calculator's own tax basis;
+     * null charges nothing, 0 is a price. Only the two flat-rate calculators
+     * (`default-shipping-calculator`, `flat-threshold-calculator`) charge it, and the store's
+     * parcel rule decides how many parcels an order is; on any other calculator a stored value is
+     * kept but charges nothing.
+     */
+    extraParcelPrice: number | null;
+}
+/**
+ * A method's name and description in one language, as a create or an update writes them. The
+ * engine keeps one row per language: writing a language the method has replaces that row's
+ * name and description, and any other language is added beside the ones it has.
+ */
+export interface ShippingMethodTranslationInput {
+    /** As the engine spells it: `en`, `nl`, `pt_BR`. */
+    languageCode: LanguageCode;
+    name: string;
+    /** Empty when left out. */
+    description?: string;
+}
+/** A new shipping method, as {@link ShippingMethodsModule.create} takes it. */
+export interface CreateShippingMethodInput {
+    code: string;
+    /**
+     * One of `shipping.definitions.get()`'s `fulfillmentHandlers`. The engine requires one; a
+     * store that routes by fulfillment profiles names `manual-fulfillment`.
+     */
+    fulfillmentHandler: string;
+    /**
+     * One of `eligibilityCheckers`, with every argument it needs (a value is always a string; lists
+     * and booleans JSON-encoded). The engine requires one; "everyone" is
+     * `default-shipping-eligibility-checker` with `orderMinimum: '0'`.
+     */
+    checker: ConfigurableOperationInput;
+    /** One of `calculators`, with its arguments. */
+    calculator: ConfigurableOperationInput;
+    /** At least the store's default language: it is the name shoppers and staff are shown. */
+    translations: ShippingMethodTranslationInput[];
+    /** On when left out. See {@link ShippingMethodSummary.enabled}. */
+    enabled?: boolean;
+    /** On when left out. */
+    enabledInStorefront?: boolean;
+    /** Minor units, or null for no charge (left out: none). See {@link ShippingMethod.extraParcelPrice}. */
+    extraParcelPrice?: number | null;
+}
+/**
+ * A change to a shipping method, as {@link ShippingMethodsModule.update} takes it. A field left
+ * out keeps what the method has. The checker can be replaced, never taken away: every method has
+ * one.
+ */
+export interface UpdateShippingMethodInput {
+    code?: string;
+    fulfillmentHandler?: string;
+    checker?: ConfigurableOperationInput;
+    calculator?: ConfigurableOperationInput;
+    translations?: ShippingMethodTranslationInput[];
+    enabled?: boolean;
+    enabledInStorefront?: boolean;
+    /** `null` clears it (no charge); left out, the stored price stays. */
+    extraParcelPrice?: number | null;
+}
+/**
+ * The store's shipping methods (`admin.shipping.methods`): what checkout offers, what a
+ * fulfillment profile and the till's delivery setting name, and what the store's shipping
+ * settings show.
+ *
+ * Every read needs `ReadSettings` or `ReadShippingMethod` (either one, so no `@permission` tag:
+ * the tag can only say "all of these"). Scoped to the channel the client is on: another store's
+ * methods are not listed, and not answered by id.
+ */
+export interface ShippingMethodsModule {
+    /**
+     * Every method of the store, enabled or not, in id order. Paged (`options.limit`, default 100,
+     * at most 1,000 or `INVALID_PAGE_SIZE`; and `options.after` from a previous page);
+     * `for await (const method of page)` walks them all.
+     *
+     * @effect read
+     */
+    list(options?: ListOptions): Promise<Page<ShippingMethodSummary>>;
+    /**
+     * One method by id, or `null` when the store the client is on has no such method: an id that
+     * does not exist, a deleted method and the id of a method only ANOTHER store holds read the
+     * same.
+     *
+     * @effect read
+     */
+    get(id: string, options?: Call): Promise<ShippingMethod | null>;
+    /**
+     * Add a shipping method to the store the client is on, and answer it as {@link get} reads it.
+     * Needs `CreateSettings` or `CreateShippingMethod` (either one). Nothing is saved when it is
+     * refused:
+     *
+     * - `INVALID_SHIPPING_METHOD_INPUT` (`ValidationError`, 400): the input's shape, checked here
+     *   before anything is sent.
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` (`BusinessRuleError`, 422): an organization's
+     *   workspace ships nothing; create the method in one of its stores.
+     * - `PLUGIN_ACCESS_DENIED` (`PermissionDeniedError`, 403): the fulfillment handler, checker or
+     *   calculator belongs to a plugin the store does not hold (a carrier, Exact Online).
+     * - The engine's own input refusal (`ValidationError`, 400): a handler, checker or calculator
+     *   code it has not registered, a missing argument, or an `extraParcelPrice` outside
+     *   0–10,000,000.
+     * - `SHIPPING_ZONE_CONFIG_NOT_FOUND` (`NotFoundError`, 404): the `weight-zone-shipping-calculator`
+     *   names no rate table of the store (`admin.shipping.rateTables`): its `shippingZoneConfigId` is
+     *   empty or left out (detail code `required`), or is not one of the store's table ids (`enum`;
+     *   another store's, a deleted one and a malformed one read alike). Such a method would quote no
+     *   price. `details[0].field` points at the argument (`/input/calculator/arguments/<i>/value`).
+     *
+     * @effect write
+     */
+    create(input: CreateShippingMethodInput, options?: Call): Promise<ShippingMethod>;
+    /**
+     * Change a shipping method of the store the client is on, and answer it as {@link get} reads
+     * it. A field left out keeps what the method has. Needs `UpdateSettings` or
+     * `UpdateShippingMethod` (either one).
+     *
+     * One method may be held by several stores, and a change reaches every one of them. Refused,
+     * with nothing saved, as {@link create} is (`PLUGIN_ACCESS_DENIED` only for a handler, checker
+     * or calculator the patch CHANGES: one the method already has is no new pick;
+     * `SHIPPING_ZONE_CONFIG_NOT_FOUND` whenever the patch sends a weight-zone calculator, judged in
+     * the store the client is on, and never when it sends none), and:
+     *
+     * - `ENTITY_NOT_FOUND` (`NotFoundError`, 404): the store has no such method (another store's
+     *   reads the same).
+     * - `SHARED_SHIPPING_METHOD_NOT_ALLOWED` (`PermissionDeniedError`, 403): the method is shared
+     *   with another store where the caller lacks `UpdateSettings` or `UpdateShippingMethod`.
+     *
+     * @effect write
+     */
+    update(id: string, patch: UpdateShippingMethodInput, options?: Call): Promise<ShippingMethod>;
+    /**
+     * Delete a shipping method. The method is withdrawn from checkout in EVERY store that holds
+     * it, not only the one the client is on; orders already shipped with it keep their shipping
+     * line. Needs `DeleteSettings` or `DeleteShippingMethod` (either one), and the same in every
+     * other store holding the method, else `SHARED_SHIPPING_METHOD_NOT_ALLOWED`
+     * (`PermissionDeniedError`, 403) and nothing is deleted.
+     *
+     * `ENTITY_NOT_FOUND` (`NotFoundError`, 404): the store has no such method, or it is already
+     * deleted. A refusal the engine answers as a result rather than an error is
+     * `SHIPPING_METHOD_NOT_DELETED` (`ConflictError`, 409) with the engine's reason.
+     *
+     * @effect destructive
+     */
+    delete(id: string, options?: Call): Promise<void>;
+}
+export declare const SHIPPING_METHODS_QUERY = "\n  query StoreShippingMethods($options: ShippingMethodListOptions) {\n    shippingMethods(options: $options) {\n      items { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  customFields {\n    enabled\n    enabledInStorefront\n  }\n }\n      totalItems\n    }\n  }\n";
+export declare const SHIPPING_METHOD_QUERY = "\n  query StoreShippingMethod($id: ID!) {\n    shippingMethod(id: $id) { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  description\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  checker { \n  code\n  args {\n    name\n    value\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n    description\n  }\n  customFields {\n    enabled\n    enabledInStorefront\n    exactManaged\n    extraParcelPrice\n  }\n }\n  }\n";
+export declare const CREATE_SHIPPING_METHOD_MUTATION = "\n  mutation CreateStoreShippingMethod($input: CreateShippingMethodInput!) {\n    createShippingMethod(input: $input) { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  description\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  checker { \n  code\n  args {\n    name\n    value\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n    description\n  }\n  customFields {\n    enabled\n    enabledInStorefront\n    exactManaged\n    extraParcelPrice\n  }\n }\n  }\n";
+export declare const UPDATE_SHIPPING_METHOD_MUTATION = "\n  mutation UpdateStoreShippingMethod($input: UpdateShippingMethodInput!) {\n    updateShippingMethod(input: $input) { \n  id\n  createdAt\n  updatedAt\n  code\n  name\n  description\n  fulfillmentHandlerCode\n  calculator { \n  code\n  args {\n    name\n    value\n  }\n }\n  checker { \n  code\n  args {\n    name\n    value\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n    description\n  }\n  customFields {\n    enabled\n    enabledInStorefront\n    exactManaged\n    extraParcelPrice\n  }\n }\n  }\n";
+export declare const DELETE_SHIPPING_METHOD_MUTATION = "\n  mutation DeleteStoreShippingMethod($id: ID!) {\n    deleteShippingMethod(id: $id) {\n      result\n      message\n    }\n  }\n";
+export declare function createShippingMethodsModule(transport: Transport): ShippingMethodsModule;