@sixtyninecommerce/admin 0.10.0 → 0.12.0

package/dist/shipping/myparcel.js

@@ -0,0 +1,466 @@
+import { errorForStatus, errorFromErrorResult, isErrorResult, ValidationError, } from '@sixtyninecommerce/core';
+import { decodeBase64, MYPARCEL_LABEL_TIMEOUT_MS, } from '../fulfillments/index.js';
+const CONFIG_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  hasApiKey
+  maskedApiKey
+  maskedWebhookSecret
+  defaultLabelFormat
+  enabled
+`;
+/** The union answer of every config write: the set-up, or a refusal. */
+const CONFIG_RESULT = /* GraphQL */ `
+  __typename
+  ... on MyparcelConfig { ${CONFIG_FIELDS} }
+  ... on ErrorResult { errorCode message }
+`;
+export const MYPARCEL_CONFIG_QUERY = /* GraphQL */ `
+  query MyparcelConfig {
+    myparcelConfig { ${CONFIG_FIELDS} }
+  }
+`;
+export const UPDATE_MYPARCEL_CONFIG_MUTATION = /* GraphQL */ `
+  mutation UpdateMyparcelConfig($input: MyparcelConfigInput!) {
+    updateMyparcelConfig(input: $input) {
+      ${CONFIG_RESULT}
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+export const UPDATE_MYPARCEL_LABEL_FORMAT_MUTATION = /* GraphQL */ `
+  mutation UpdateMyparcelLabelFormat($input: MyparcelLabelFormatInput!) {
+    updateMyparcelLabelFormat(input: $input) { ${CONFIG_RESULT} }
+  }
+`;
+export const SET_MYPARCEL_ENABLED_MUTATION = /* GraphQL */ `
+  mutation SetMyparcelEnabled($enabled: Boolean!) {
+    setMyparcelEnabled(enabled: $enabled) {
+      ${CONFIG_RESULT}
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+export const REGENERATE_MYPARCEL_WEBHOOK_SECRET_MUTATION = /* GraphQL */ `
+  mutation RegenerateMyparcelWebhookSecret {
+    regenerateMyparcelWebhookSecret { ${CONFIG_RESULT} }
+  }
+`;
+export const MYPARCEL_CARRIERS_QUERY = /* GraphQL */ `
+  query MyparcelCarriers {
+    myparcelCarriers {
+      id
+      name
+      human
+      meta { logoSvg logoPng }
+    }
+  }
+`;
+const SENDER_FIELDS = /* GraphQL */ `
+  id
+  name
+  address {
+    streetLine1
+    streetLine2
+    city
+    postalCode
+    province
+    countryCode
+    phoneNumber
+    contactName
+    company
+  }
+  isDefaultSender
+  isResolvable
+`;
+export const MYPARCEL_SENDERS_QUERY = /* GraphQL */ `
+  query MyparcelSenderStockLocations {
+    myparcelSenderStockLocations { ${SENDER_FIELDS} }
+  }
+`;
+export const SET_MYPARCEL_SENDER_MUTATION = /* GraphQL */ `
+  mutation SetStockLocationSender($input: MyparcelSetStockLocationSenderInput!) {
+    setStockLocationSender(input: $input) {
+      __typename
+      ... on MyparcelSenderStockLocationSummary { ${SENDER_FIELDS} }
+      ... on ErrorResult { errorCode message }
+      ... on MyparcelInvalidSenderError { fields }
+    }
+  }
+`;
+export const MYPARCEL_SHIPMENT_QUERY = /* GraphQL */ `
+  query MyparcelShipment($shipmentId: Int!) {
+    myparcelShipment(shipmentId: $shipmentId) {
+      id
+      referenceIdentifier
+      barcode
+      status
+      carrierId
+      created
+      modified
+      linkConsumerPortal
+    }
+  }
+`;
+/** Readiness only: the engine answers no link (it would outlive every check made on it). */
+export const MYPARCEL_LABEL_STATUS_QUERY = /* GraphQL */ `
+  query MyparcelLabelStatus($shipmentIds: [Int!]!, $format: MyparcelLabelFormatEnum!) {
+    myparcelShipmentLabelUrl(shipmentIds: $shipmentIds, format: $format) {
+      status
+    }
+  }
+`;
+export const MYPARCEL_SHIPMENT_LABEL_MUTATION = /* GraphQL */ `
+  mutation MyparcelShipmentLabel($shipmentId: Int!, $format: MyparcelLabelFormatEnum!) {
+    getMyparcelLabel(shipmentId: $shipmentId, format: $format) {
+      format
+      base64
+      contentType
+      filename
+    }
+  }
+`;
+export const REQUEST_MYPARCEL_LABEL_MUTATION = /* GraphQL */ `
+  mutation RequestMyparcelLabel($input: MyparcelRequestLabelInput!) {
+    requestMyparcelLabel(input: $input) {
+      __typename
+      ... on MyparcelLabelResult { status }
+      ... on ErrorResult { errorCode message }
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+export const MYPARCEL_CARRIER_CAPABILITIES_QUERY = /* GraphQL */ `
+  query MyparcelCarrierCapabilities {
+    myparcelCarrierCapabilities {
+      carrierId
+      name
+      packageTypes
+      deliveryTypes
+      countries
+      supportedOptions
+      supportsPickup
+      constraints
+    }
+  }
+`;
+export const MYPARCEL_DELIVERY_OPTIONS_QUERY = /* GraphQL */ `
+  query MyparcelAdminDeliveryOptions($input: MyparcelAdminDeliveryOptionsInput!) {
+    myparcelAdminDeliveryOptions(input: $input) {
+      __typename
+      ... on MyparcelAdminDeliveryOptions {
+        deliveryOptions {
+          deliveryType
+          date
+          startTime
+          endTime
+          price { amount currency }
+        }
+        pickupOptions {
+          locationCode
+          locationName
+          street
+          number
+          numberSuffix
+          postalCode
+          city
+          countryCode
+          carrierId
+          distance
+        }
+      }
+      ... on ErrorResult { errorCode message }
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+/**
+ * Every member that names fields carries them here, so `myparcelRefusal` can put each in
+ * `details[]`. Two members share the `fields` name with one type, which GraphQL allows.
+ */
+const SHIPMENT_REFUSAL_FIELDS = /* GraphQL */ `
+  ... on ErrorResult { errorCode message }
+  ... on MyparcelValidationError { errors }
+  ... on MyparcelInvalidRecipientError { missingFields }
+  ... on MyparcelInvalidSenderError { fields }
+  ... on MyparcelPickupLocationInvalidError { fields }
+`;
+export const RECREATE_MYPARCEL_SHIPMENT_MUTATION = /* GraphQL */ `
+  mutation RecreateMyparcelShipment($input: MyparcelRecreateShipmentInput!) {
+    recreateMyparcelShipment(input: $input) {
+      __typename
+      ... on MyparcelShipmentMutationResult { shipmentId labelFormat }
+      ${SHIPMENT_REFUSAL_FIELDS}
+    }
+  }
+`;
+export const IMPORT_MYPARCEL_SHIPMENT_MUTATION = /* GraphQL */ `
+  mutation ImportMyparcelShipment($input: MyparcelImportShipmentInput!) {
+    importMyparcelShipment(input: $input) {
+      __typename
+      ... on MyparcelShipmentMutationResult { shipmentId labelFormat }
+      ... on ErrorResult { errorCode message }
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+export const CREATE_MYPARCEL_RETURN_MUTATION = /* GraphQL */ `
+  mutation CreateMyparcelReturnShipment($input: MyparcelReturnShipmentInput!) {
+    createMyparcelReturnShipment(input: $input) {
+      __typename
+      ... on MyparcelReturnShipmentResult { shipmentId }
+      ... on ErrorResult { errorCode message }
+      ... on MyparcelValidationError { errors }
+    }
+  }
+`;
+/** `updateMyparcelConfig` with an empty key answers this member: the set-up is gone. */
+const NOT_CONFIGURED = 'MYPARCEL_NOT_CONFIGURED_ERROR';
+/**
+ * A refusal member as its error class, by core's `errorFromErrorResult`. The field names a member
+ * carries (`MyparcelInvalidSenderError.fields`, `MyparcelPickupLocationInvalidError.fields`,
+ * `MyparcelValidationError.errors`, `MyparcelInvalidRecipientError.missingFields`) ride
+ * `details[]`, one per field, so a form can mark each without matching the sentence.
+ */
+export function myparcelRefusal(result) {
+    const base = errorFromErrorResult(result);
+    const named = Array.isArray(result.fields)
+        ? result.fields
+        : Array.isArray(result.errors)
+            ? result.errors
+            : Array.isArray(result.missingFields)
+                ? result.missingFields
+                : [];
+    const details = named
+        .filter((field) => typeof field === 'string' && field.trim() !== '')
+        .map((field) => ({ field, code: base.code, message: base.message }));
+    if (details.length === 0)
+        return base;
+    return errorForStatus(base.status, {
+        code: base.code,
+        message: base.message,
+        service: 'vendure',
+        details,
+    });
+}
+function settled(answer) {
+    if (isErrorResult(answer))
+        throw myparcelRefusal(answer);
+    const { __typename: _typename, ...rest } = answer;
+    return rest;
+}
+const LABEL_FORMATS = new Set(['A4', 'A6']);
+function invalidInput(code, field, message) {
+    return new ValidationError({
+        code,
+        message,
+        status: 400,
+        service: 'vendure',
+        details: [{ field, code, message }],
+    });
+}
+const LABEL_INPUT_INVALID = 'MYPARCEL_LABEL_INPUT_INVALID';
+/** MyParcel's ids are GraphQL `Int`s: anything else would fail the document, uncoded. */
+function isShipmentId(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 && value <= 2 ** 31 - 1;
+}
+function assertShipmentId(id, field, code) {
+    if (!isShipmentId(id)) {
+        throw invalidInput(code, field, `A MyParcel shipment id is a positive whole number; got ${JSON.stringify(id)}.`);
+    }
+}
+/** Refused before any request: the engine's enum would refuse it, uncoded. */
+function assertLabelFormat(format) {
+    if (!LABEL_FORMATS.has(format)) {
+        throw invalidInput(LABEL_INPUT_INVALID, 'format', `format must be 'A4' or 'A6'; got ${JSON.stringify(format)}.`);
+    }
+}
+const INVALID_INPUT = 'INVALID_INPUT';
+function assertFulfillmentId(id) {
+    if (typeof id !== 'string' || id.trim() === '') {
+        throw invalidInput(INVALID_INPUT, 'fulfillmentId', 'A fulfillment id is required.');
+    }
+}
+/** A non-blank string, trimmed; refused before any request otherwise. */
+function requiredText(value, field) {
+    const text = typeof value === 'string' ? value.trim() : '';
+    if (text === '')
+        throw invalidInput(INVALID_INPUT, field, `${field} is required.`);
+    return text;
+}
+/** The handler arguments as the wire takes them; anything else would fail the document uncoded. */
+function handlerArgumentsOf(raw) {
+    if (!Array.isArray(raw)) {
+        throw invalidInput(INVALID_INPUT, 'handlerArguments', 'handlerArguments must be a list of { name, value } strings.');
+    }
+    return raw.map((entry, index) => {
+        const { name, value } = (entry ?? {});
+        if (typeof name !== 'string' || name.trim() === '' || typeof value !== 'string') {
+            throw invalidInput(INVALID_INPUT, `handlerArguments[${String(index)}]`, 'Each handler argument is a { name, value } pair of strings, with a name.');
+        }
+        return { name, value };
+    });
+}
+/** `ready` only when the engine says so: any other answer is a label still being made. */
+function readiness(status) {
+    return { status: status === 'ready' ? 'ready' : 'pending' };
+}
+export function createMyparcelModule(transport) {
+    const gql = (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
+    return {
+        config: {
+            async get(options) {
+                const data = await gql(MYPARCEL_CONFIG_QUERY, {}, options);
+                return data.myparcelConfig ?? null;
+            },
+            async update(input, options) {
+                const apiKey = typeof input?.apiKey === 'string' ? input.apiKey.trim() : '';
+                if (apiKey === '') {
+                    // Never quotes the argument: a key padded with whitespace must not reach a log.
+                    throw new TypeError('config.update needs a MyParcel API key; remove the stored one with config.remove().');
+                }
+                const data = await gql(UPDATE_MYPARCEL_CONFIG_MUTATION, { input: { apiKey } }, options);
+                return settled(data.updateMyparcelConfig);
+            },
+            async remove(options) {
+                // The wire's removal is an empty key, answered by the not-configured member.
+                const data = await gql(UPDATE_MYPARCEL_CONFIG_MUTATION, { input: { apiKey: '' } }, options);
+                const answer = data.updateMyparcelConfig;
+                if (isErrorResult(answer) && answer.errorCode === NOT_CONFIGURED)
+                    return;
+                if (isErrorResult(answer))
+                    throw myparcelRefusal(answer);
+                // An engine that answered a set-up kept it: never report that as removed.
+                throw new Error('MyParcel answered the set-up instead of removing it; nothing was removed.');
+            },
+            async setLabelFormat(format, options) {
+                const data = await gql(UPDATE_MYPARCEL_LABEL_FORMAT_MUTATION, { input: { format } }, options);
+                return settled(data.updateMyparcelLabelFormat);
+            },
+            async setEnabled(enabled, options) {
+                const data = await gql(SET_MYPARCEL_ENABLED_MUTATION, { enabled }, options);
+                return settled(data.setMyparcelEnabled);
+            },
+            async regenerateWebhookSecret(options) {
+                const data = await gql(REGENERATE_MYPARCEL_WEBHOOK_SECRET_MUTATION, {}, options);
+                return settled(data.regenerateMyparcelWebhookSecret);
+            },
+        },
+        async carriers(options) {
+            const data = await gql(MYPARCEL_CARRIERS_QUERY, {}, options);
+            return data.myparcelCarriers;
+        },
+        async carrierCapabilities(options) {
+            const data = await gql(MYPARCEL_CARRIER_CAPABILITIES_QUERY, {}, options);
+            return data.myparcelCarrierCapabilities;
+        },
+        async deliveryOptions(input, options) {
+            const postalCode = requiredText(input?.postalCode, 'postalCode');
+            const data = await gql(MYPARCEL_DELIVERY_OPTIONS_QUERY, { input: { ...input, postalCode } }, options);
+            const { deliveryOptions, pickupOptions } = settled(data.myparcelAdminDeliveryOptions);
+            return { deliveryOptions, pickupOptions };
+        },
+        senders: {
+            async list(options) {
+                const data = await gql(MYPARCEL_SENDERS_QUERY, {}, options);
+                return data.myparcelSenderStockLocations;
+            },
+            async set(input, options) {
+                const data = await gql(SET_MYPARCEL_SENDER_MUTATION, { input }, options);
+                return settled(data.setStockLocationSender);
+            },
+        },
+        shipments: {
+            async get(shipmentId, options) {
+                assertShipmentId(shipmentId, 'shipmentId', 'INVALID_INPUT');
+                const data = await gql(MYPARCEL_SHIPMENT_QUERY, { shipmentId }, options);
+                const shipment = data.myparcelShipment;
+                if (!shipment)
+                    return null;
+                return {
+                    id: shipment.id,
+                    referenceIdentifier: shipment.referenceIdentifier ?? null,
+                    barcode: shipment.barcode ?? null,
+                    status: shipment.status,
+                    carrierId: shipment.carrierId,
+                    created: shipment.created,
+                    modified: shipment.modified,
+                    linkConsumerPortal: shipment.linkConsumerPortal ?? null,
+                };
+            },
+            async recreate(input, options) {
+                assertFulfillmentId(input?.fulfillmentId);
+                const handlerArguments = handlerArgumentsOf(input.handlerArguments);
+                const data = await gql(RECREATE_MYPARCEL_SHIPMENT_MUTATION, { input: { fulfillmentId: input.fulfillmentId, handlerArguments } }, options);
+                const { shipmentId, labelFormat } = settled(data.recreateMyparcelShipment);
+                return { shipmentId, labelFormat };
+            },
+            async import(input, options) {
+                assertFulfillmentId(input?.fulfillmentId);
+                assertShipmentId(input.shipmentId, 'shipmentId', INVALID_INPUT);
+                const data = await gql(IMPORT_MYPARCEL_SHIPMENT_MUTATION, { input: { fulfillmentId: input.fulfillmentId, shipmentId: input.shipmentId } }, options);
+                const { shipmentId, labelFormat } = settled(data.importMyparcelShipment);
+                return { shipmentId, labelFormat };
+            },
+        },
+        returns: {
+            async create(input, options) {
+                assertShipmentId(input?.parentShipmentId, 'parentShipmentId', INVALID_INPUT);
+                if (!isShipmentId(input.carrier)) {
+                    throw invalidInput(INVALID_INPUT, 'carrier', `A MyParcel carrier id is a positive whole number; got ${JSON.stringify(input.carrier)}.`);
+                }
+                const name = requiredText(input.name, 'name');
+                const email = requiredText(input.email, 'email');
+                const data = await gql(CREATE_MYPARCEL_RETURN_MUTATION, {
+                    input: {
+                        parentShipmentId: input.parentShipmentId,
+                        carrier: input.carrier,
+                        name,
+                        email,
+                    },
+                }, options);
+                return { shipmentId: settled(data.createMyparcelReturnShipment).shipmentId };
+            },
+        },
+        labels: {
+            async status(shipmentIds, format, options) {
+                const ids = Array.isArray(shipmentIds) ? [...shipmentIds] : [];
+                if (ids.length === 0) {
+                    throw invalidInput(LABEL_INPUT_INVALID, 'shipmentIds', 'Name at least one shipment.');
+                }
+                for (const [index, id] of ids.entries()) {
+                    assertShipmentId(id, `shipmentIds[${String(index)}]`, LABEL_INPUT_INVALID);
+                }
+                assertLabelFormat(format);
+                const data = await gql(MYPARCEL_LABEL_STATUS_QUERY, { shipmentIds: ids, format }, 
+                // The engine retries a slow MyParcel on this read as on the download.
+                { timeoutMs: MYPARCEL_LABEL_TIMEOUT_MS, ...options });
+                return readiness(data.myparcelShipmentLabelUrl?.status);
+            },
+            async download(shipmentId, format, options) {
+                assertShipmentId(shipmentId, 'shipmentId', LABEL_INPUT_INVALID);
+                assertLabelFormat(format);
+                const data = await gql(MYPARCEL_SHIPMENT_LABEL_MUTATION, { shipmentId, format }, { timeoutMs: MYPARCEL_LABEL_TIMEOUT_MS, ...options });
+                const { base64, ...document } = data.getMyparcelLabel;
+                return {
+                    format: document.format,
+                    contentType: document.contentType,
+                    filename: document.filename,
+                    bytes: decodeBase64(base64),
+                };
+            },
+            async request(input, options) {
+                const fulfillmentId = input?.fulfillmentId;
+                if (typeof fulfillmentId !== 'string' || fulfillmentId.trim() === '') {
+                    throw invalidInput(LABEL_INPUT_INVALID, 'fulfillmentId', 'A fulfillment id is required.');
+                }
+                assertShipmentId(input.shipmentId, 'shipmentId', LABEL_INPUT_INVALID);
+                assertLabelFormat(input.format);
+                const data = await gql(REQUEST_MYPARCEL_LABEL_MUTATION, {
+                    input: { fulfillmentId, shipmentId: input.shipmentId, format: input.format },
+                }, options);
+                return readiness(settled(data.requestMyparcelLabel).status);
+            },
+        },
+    };
+}

package/dist/shipping/parcel-count-suggestion.d.ts

@@ -46,6 +46,8 @@ export interface ParcelCountSuggestion {
  * or `ReadFulfillment`. A malformed input is refused before any request with
  * `PARCEL_COUNT_INPUT_INVALID` ({@link ValidationError}); an unknown variant,
  * or another store's, is `PARCEL_COUNT_VARIANT_NOT_FOUND` (`NotFoundError`).
+ *
+ * @effect read
  */
 export type ParcelCountSuggestionMethod = (input: ParcelCountSuggestionInput, options?: Call) => Promise<ParcelCountSuggestion>;
 export declare const PARCEL_COUNT_SUGGESTION_QUERY = "\n  query ParcelCountSuggestion($input: ParcelCountSuggestionInput!) {\n    parcelCountSuggestion(input: $input) {\n      count\n      raw\n      resolvable\n      exact\n      capped\n      capacity\n      maxWeightGrams\n      unratedLines\n      unweighedLines\n      reason\n      warnings\n      destinationRequiresCustoms\n    }\n  }\n";

package/dist/shipping/parcel-rule.d.ts

@@ -36,13 +36,14 @@ export interface SetParcelRuleInput {
  * change reaches another process after that cache refreshes.
  */
 export interface ParcelRuleModule {
+    /** @effect read */
     get(options?: Call): Promise<ParcelRule>;
+    /**
+     * @effect write
+     * @permission UpdateChannel
+     */
     set(input: SetParcelRuleInput, options?: Call): Promise<ParcelRule>;
 }
-/** `admin.shipping` (spec §9.2 `shipping`). */
-export interface ShippingModule {
-    parcelRule: ParcelRuleModule;
-}
 export declare const PARCEL_RULE_QUERY = "\n  query ParcelRule {\n    activeChannel { \n  id\n  customFields {\n    defaultParcelCapacity\n    maxParcelWeightGrams\n  }\n }\n  }\n";
 export declare const SET_PARCEL_RULE_MUTATION = "\n  mutation SetParcelRule($input: UpdateChannelInput!) {\n    updateChannel(input: $input) {\n      ... on Channel { \n  id\n  customFields {\n    defaultParcelCapacity\n    maxParcelWeightGrams\n  }\n }\n      ... on ErrorResult { errorCode message }\n    }\n  }\n";
-export declare function createShippingModule(transport: Transport): ShippingModule;
+export declare function createParcelRuleModule(transport: Transport): ParcelRuleModule;

package/dist/shipping/parcel-rule.js

@@ -58,34 +58,32 @@ function customFieldsOf(input) {
     }
     return fields;
 }
-export function createShippingModule(transport) {
+export function createParcelRuleModule(transport) {
     const get = async (options) => {
         const data = await transport.graphql({ api: 'admin', query: PARCEL_RULE_QUERY }, options);
         return toRule(data.activeChannel);
     };
     return {
-        parcelRule: {
-            get,
-            async set(input, options) {
-                assertBound('defaultParcelCapacity', input?.defaultParcelCapacity, PARCEL_CAPACITY_MAX, 'items');
-                assertBound('maxParcelWeightGrams', input?.maxParcelWeightGrams, PARCEL_WEIGHT_GRAMS_MAX, 'grams');
-                const customFields = customFieldsOf(input ?? {});
-                if (Object.keys(customFields).length === 0) {
-                    throw invalid('input', 'Pass defaultParcelCapacity and/or maxParcelWeightGrams; an empty input changes nothing.');
-                }
-                // `updateChannel` needs the id, and the active channel is the one the
-                // client is scoped to — read it with the SAME call options, so a
-                // per-call tenant writes its own channel rather than the client's.
-                const { channelId } = await get(options);
-                const data = await transport.graphql({
-                    api: 'admin',
-                    query: SET_PARCEL_RULE_MUTATION,
-                    variables: { input: { id: channelId, customFields } },
-                }, options);
-                if (isErrorResult(data.updateChannel))
-                    throw errorFromErrorResult(data.updateChannel);
-                return toRule(data.updateChannel);
-            },
+        get,
+        async set(input, options) {
+            assertBound('defaultParcelCapacity', input?.defaultParcelCapacity, PARCEL_CAPACITY_MAX, 'items');
+            assertBound('maxParcelWeightGrams', input?.maxParcelWeightGrams, PARCEL_WEIGHT_GRAMS_MAX, 'grams');
+            const customFields = customFieldsOf(input ?? {});
+            if (Object.keys(customFields).length === 0) {
+                throw invalid('input', 'Pass defaultParcelCapacity and/or maxParcelWeightGrams; an empty input changes nothing.');
+            }
+            // `updateChannel` needs the id, and the active channel is the one the
+            // client is scoped to — read it with the SAME call options, so a
+            // per-call tenant writes its own channel rather than the client's.
+            const { channelId } = await get(options);
+            const data = await transport.graphql({
+                api: 'admin',
+                query: SET_PARCEL_RULE_MUTATION,
+                variables: { input: { id: channelId, customFields } },
+            }, options);
+            if (isErrorResult(data.updateChannel))
+                throw errorFromErrorResult(data.updateChannel);
+            return toRule(data.updateChannel);
         },
     };
 }