@wix/auto_sdk_stores_inventory 1.0.63 → 1.0.65

package/build/internal/es/index.typings.mjs

@@ -10,67 +10,6 @@ import { transformSDKTimestampToRESTTimestamp } from "@wix/sdk-runtime/transform
 import { transformRESTTimestampToSDKTimestamp } from "@wix/sdk-runtime/transformations/timestamp";
 import { transformPaths } from "@wix/sdk-runtime/transformations/transform-paths";
 import { resolveUrl } from "@wix/sdk-runtime/rest-modules";
-function resolveWixInventoryApiV1InventoryReadApiUrl(opts) {
-  const domainToMappings = {
-    "api._api_base_domain_": [
-      {
-        srcPath: "/wix-ecommerce-catalog-reader-web",
-        destPath: ""
-      }
-    ],
-    "manage._base_domain_": [
-      {
-        srcPath: "/wix-ecommerce-catalog-reader-web",
-        destPath: ""
-      }
-    ],
-    "www.wixapis.com": [
-      {
-        srcPath: "/stores-reader/v2/collections",
-        destPath: "/v2/collections"
-      },
-      {
-        srcPath: "/stores-reader/v2/inventoryItems",
-        destPath: "/v2/inventoryItems"
-      }
-    ],
-    "www._base_domain_": [
-      {
-        srcPath: "/wix-ecommerce-catalog-reader-web",
-        destPath: ""
-      }
-    ],
-    "editor._base_domain_": [
-      {
-        srcPath: "/_api/wix-ecommerce-catalog-reader-web",
-        destPath: ""
-      }
-    ],
-    "blocks._base_domain_": [
-      {
-        srcPath: "/_api/wix-ecommerce-catalog-reader-web",
-        destPath: ""
-      }
-    ],
-    "create.editorx": [
-      {
-        srcPath: "/_api/wix-ecommerce-catalog-reader-web",
-        destPath: ""
-      }
-    ],
-    _: [
-      {
-        srcPath: "/stores-reader/v2/inventoryItems",
-        destPath: "/v2/inventoryItems"
-      },
-      {
-        srcPath: "/stores-reader/v2/collections",
-        destPath: "/v2/collections"
-      }
-    ]
-  };
-  return resolveUrl(Object.assign(opts, { domainToMappings }));
-}
 function resolveWixInventoryApiV1InventoryWriteApiUrl(opts) {
   const domainToMappings = {
     "api._api_base_domain_": [
@@ -154,7 +93,122 @@ function resolveWixInventoryApiV1InventoryWriteApiUrl(opts) {
   };
   return resolveUrl(Object.assign(opts, { domainToMappings }));
 }
+function resolveWixInventoryApiV1InventoryReadApiUrl(opts) {
+  const domainToMappings = {
+    "api._api_base_domain_": [
+      {
+        srcPath: "/wix-ecommerce-catalog-reader-web",
+        destPath: ""
+      }
+    ],
+    "manage._base_domain_": [
+      {
+        srcPath: "/wix-ecommerce-catalog-reader-web",
+        destPath: ""
+      }
+    ],
+    "www.wixapis.com": [
+      {
+        srcPath: "/stores-reader/v2/collections",
+        destPath: "/v2/collections"
+      },
+      {
+        srcPath: "/stores-reader/v2/inventoryItems",
+        destPath: "/v2/inventoryItems"
+      }
+    ],
+    "www._base_domain_": [
+      {
+        srcPath: "/wix-ecommerce-catalog-reader-web",
+        destPath: ""
+      }
+    ],
+    "editor._base_domain_": [
+      {
+        srcPath: "/_api/wix-ecommerce-catalog-reader-web",
+        destPath: ""
+      }
+    ],
+    "blocks._base_domain_": [
+      {
+        srcPath: "/_api/wix-ecommerce-catalog-reader-web",
+        destPath: ""
+      }
+    ],
+    "create.editorx": [
+      {
+        srcPath: "/_api/wix-ecommerce-catalog-reader-web",
+        destPath: ""
+      }
+    ],
+    _: [
+      {
+        srcPath: "/stores-reader/v2/inventoryItems",
+        destPath: "/v2/inventoryItems"
+      },
+      {
+        srcPath: "/stores-reader/v2/collections",
+        destPath: "/v2/collections"
+      }
+    ]
+  };
+  return resolveUrl(Object.assign(opts, { domainToMappings }));
+}
 var PACKAGE_NAME = "@wix/auto_sdk_stores_inventory";
+function getInventoryVariants(payload) {
+  function __getInventoryVariants({ host }) {
+    const metadata = {
+      entityFqdn: "wix.stores.v2.inventory",
+      method: "POST",
+      methodFqn: "wix.inventory.api.v1.InventoryReadApi.GetInventoryVariants",
+      packageName: PACKAGE_NAME,
+      migrationOptions: {
+        optInTransformResponse: true
+      },
+      url: resolveWixInventoryApiV1InventoryReadApiUrl({
+        protoPath: "/v2/inventoryItems/{inventoryId}/getVariants",
+        data: payload,
+        host
+      }),
+      data: payload,
+      transformResponse: (payload2) => transformPaths(payload2, [
+        {
+          transformFn: transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "inventoryItem.lastUpdated" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __getInventoryVariants;
+}
+function queryInventory(payload) {
+  function __queryInventory({ host }) {
+    const metadata = {
+      entityFqdn: "wix.stores.v2.inventory",
+      method: "POST",
+      methodFqn: "wix.inventory.api.v1.InventoryReadApi.QueryInventory",
+      packageName: PACKAGE_NAME,
+      migrationOptions: {
+        optInTransformResponse: true
+      },
+      url: resolveWixInventoryApiV1InventoryReadApiUrl({
+        protoPath: "/v2/inventoryItems/query",
+        data: payload,
+        host
+      }),
+      data: payload,
+      transformResponse: (payload2) => transformPaths(payload2, [
+        {
+          transformFn: transformRESTTimestampToSDKTimestamp,
+          paths: [{ path: "inventoryItems.lastUpdated" }]
+        }
+      ])
+    };
+    return metadata;
+  }
+  return __queryInventory;
+}
 function updateInventoryVariants(payload) {
   function __updateInventoryVariants({ host }) {
     const serializedData = transformPaths(payload, [
@@ -224,60 +278,222 @@ function incrementInventory(payload) {
   }
   return __incrementInventory;
 }
-function getInventoryVariants(payload) {
-  function __getInventoryVariants({ host }) {
-    const metadata = {
-      entityFqdn: "wix.stores.v2.inventory",
-      method: "POST",
-      methodFqn: "wix.inventory.api.v1.InventoryReadApi.GetInventoryVariants",
-      packageName: PACKAGE_NAME,
-      migrationOptions: {
-        optInTransformResponse: true
-      },
-      url: resolveWixInventoryApiV1InventoryReadApiUrl({
-        protoPath: "/v2/inventoryItems/{inventoryId}/getVariants",
-        data: payload,
-        host
+
+// src/stores-v2-inventory-inventory.schemas.ts
+import * as z from "zod";
+var GetInventoryVariantsRequest = z.object({
+  inventoryId: z.string().describe("Inventory item ID."),
+  options: z.intersection(
+    z.object({ variantIds: z.array(z.string()).optional() }),
+    z.xor([
+      z.object({
+        inventoryId: z.never().optional(),
+        externalId: z.never().optional(),
+        productId: z.never().optional()
       }),
-      data: payload,
-      transformResponse: (payload2) => transformPaths(payload2, [
-        {
-          transformFn: transformRESTTimestampToSDKTimestamp,
-          paths: [{ path: "inventoryItem.lastUpdated" }]
-        }
+      z.object({
+        externalId: z.never().optional(),
+        productId: z.never().optional(),
+        inventoryId: z.string().describe("Inventory item ID.")
+      }),
+      z.object({
+        inventoryId: z.never().optional(),
+        productId: z.never().optional(),
+        externalId: z.string().describe("Deprecated (use productID instead).")
+      }),
+      z.object({
+        inventoryId: z.never().optional(),
+        externalId: z.never().optional(),
+        productId: z.string().describe("Product ID.")
+      })
+    ])
+  ).optional()
+});
+var GetInventoryVariantsResponse = z.object({
+  inventoryItem: z.object({
+    _id: z.string().describe("Inventory item ID.").optional().nullable(),
+    externalId: z.string().describe("Deprecated: use productId.").optional().nullable(),
+    productId: z.string().describe("Product ID.").optional().nullable(),
+    trackQuantity: z.boolean().describe("Whether quantity is being tracked.").optional().nullable(),
+    variants: z.array(
+      z.object({
+        variantId: z.string().describe("Variant ID.").optional(),
+        inStock: z.boolean().describe("Whether the product is listed as in stock.").optional().nullable(),
+        quantity: z.number().int().describe("Quantity currently left in inventory.").min(0).optional().nullable(),
+        availableForPreorder: z.boolean().describe(
+          "Whether the variant is available for preorder. When `true`, the variant is out of stock and preorder is enabled on inventory level."
+        ).optional()
+      })
+    ).optional(),
+    lastUpdated: z.date().describe("Last updated timestamp.").optional().nullable(),
+    numericId: z.string().regex(/^\d+$/, "Must be a valid UInt64 string").describe(
+      "Inventory\u2019s unique numeric ID (assigned in ascending order).\nPrimarily for sorting and filtering when crawling all inventories."
+    ).optional(),
+    preorderInfo: z.object({
+      enabled: z.boolean().describe("Whether the item is available for preorder.").optional(),
+      message: z.string().describe(
+        "A message the buyer will see when the item is out of stock and preorder is enabled."
+      ).min(1).max(250).optional().nullable(),
+      limit: z.number().int().describe(
+        "Number of products that can be preordered after stock reaches zero."
+      ).min(0).max(1e5).optional().nullable()
+    }).describe("Preorder information.").optional()
+  }).describe("Inventory item.").optional()
+});
+var QueryInventoryRequest = z.object({
+  options: z.object({
+    query: z.object({
+      paging: z.object({
+        limit: z.number().int().describe("Amount of items to load per page").min(0).max(100).optional().nullable(),
+        offset: z.number().int().describe(
+          "Number of items to skip in the display (relevant for all pages after the first)"
+        ).min(0).optional().nullable()
+      }).optional(),
+      filter: z.string().describe("Filter string").optional().nullable(),
+      sort: z.string().describe("Sort string").optional().nullable()
+    }).optional()
+  }).optional()
+});
+var QueryInventoryResponse = z.object({
+  inventoryItems: z.array(
+    z.object({
+      _id: z.string().describe("Inventory item ID.").optional().nullable(),
+      externalId: z.string().describe("Deprecated: use productId.").optional().nullable(),
+      productId: z.string().describe("Product ID.").optional().nullable(),
+      trackQuantity: z.boolean().describe("Whether quantity is being tracked.").optional().nullable(),
+      variants: z.array(
+        z.object({
+          variantId: z.string().describe("Variant ID.").optional(),
+          inStock: z.boolean().describe("Whether the product is listed as in stock.").optional().nullable(),
+          quantity: z.number().int().describe("Quantity currently left in inventory.").min(0).optional().nullable(),
+          availableForPreorder: z.boolean().describe(
+            "Whether the variant is available for preorder. When `true`, the variant is out of stock and preorder is enabled on inventory level."
+          ).optional()
+        })
+      ).optional(),
+      lastUpdated: z.date().describe("Last updated timestamp.").optional().nullable(),
+      numericId: z.string().regex(/^\d+$/, "Must be a valid UInt64 string").describe(
+        "Inventory\u2019s unique numeric ID (assigned in ascending order).\nPrimarily for sorting and filtering when crawling all inventories."
+      ).optional(),
+      preorderInfo: z.object({
+        enabled: z.boolean().describe("Whether the item is available for preorder.").optional(),
+        message: z.string().describe(
+          "A message the buyer will see when the item is out of stock and preorder is enabled."
+        ).min(1).max(250).optional().nullable(),
+        limit: z.number().int().describe(
+          "Number of products that can be preordered after stock reaches zero."
+        ).min(0).max(1e5).optional().nullable()
+      }).describe("Preorder information.").optional()
+    })
+  ).optional(),
+  metadata: z.object({
+    items: z.number().int().describe("Amount of items to load per page").optional(),
+    offset: z.number().int().describe(
+      "Number of items to skip in the display (relevant for all pages after the first)"
+    ).optional()
+  }).describe("Display metadata.").optional(),
+  totalResults: z.number().int().describe("Number of total results.").optional()
+});
+var UpdateInventoryVariantsRequest = z.object({
+  productId: z.string().describe("Product ID."),
+  inventoryItem: z.object({
+    _id: z.string().describe("Inventory item ID.").optional().nullable(),
+    externalId: z.string().describe("Deprecated: use productId.").optional().nullable(),
+    productId: z.string().describe("Product ID.").optional().nullable(),
+    trackQuantity: z.boolean().describe("Whether quantity is being tracked.").optional().nullable(),
+    variants: z.array(
+      z.object({
+        variantId: z.string().describe("Variant ID.").optional(),
+        inStock: z.boolean().describe("Whether the product is listed as in stock.").optional().nullable(),
+        quantity: z.number().int().describe("Quantity currently left in inventory.").min(0).optional().nullable(),
+        availableForPreorder: z.boolean().describe(
+          "Whether the variant is available for preorder. When `true`, the variant is out of stock and preorder is enabled on inventory level."
+        ).optional()
+      })
+    ).optional(),
+    lastUpdated: z.date().describe("Last updated timestamp.").optional().nullable(),
+    numericId: z.string().regex(/^\d+$/, "Must be a valid UInt64 string").describe(
+      "Inventory\u2019s unique numeric ID (assigned in ascending order).\nPrimarily for sorting and filtering when crawling all inventories."
+    ).optional(),
+    preorderInfo: z.object({
+      enabled: z.boolean().describe("Whether the item is available for preorder.").optional(),
+      message: z.string().describe(
+        "A message the buyer will see when the item is out of stock and preorder is enabled."
+      ).min(1).max(250).optional().nullable(),
+      limit: z.number().int().describe(
+        "Number of products that can be preordered after stock reaches zero."
+      ).min(0).max(1e5).optional().nullable()
+    }).describe("Preorder information.").optional()
+  }).describe("Inventory item to update.")
+});
+var UpdateInventoryVariantsResponse = z.object({});
+var DecrementInventoryRequest = z.object({
+  decrementData: z.array(
+    z.intersection(
+      z.object({
+        variantId: z.string().describe("Variant ID.").regex(
+          /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+          "Must be a valid GUID"
+        ).optional(),
+        decrementBy: z.number().int().describe("Number to decrement inventory by.").min(1).optional(),
+        preorderRequest: z.boolean().describe(
+          "Whether the request to decrement the item's inventory was made as part of a purchase that includes preorder items.\nIf true and the item is available for preorder, we allow negative inventory.\nIf false and the item is not available for preorder, we allow regular buy flow (no negative inventory)."
+        ).optional()
+      }),
+      z.xor([
+        z.object({
+          inventoryId: z.never().optional(),
+          externalId: z.never().optional(),
+          productId: z.never().optional()
+        }),
+        z.object({
+          externalId: z.never().optional(),
+          productId: z.never().optional(),
+          inventoryId: z.string().describe("Inventory item ID.").max(36)
+        }),
+        z.object({
+          inventoryId: z.never().optional(),
+          productId: z.never().optional(),
+          externalId: z.string().describe("Deprecated: use productId.").max(36)
+        }),
+        z.object({
+          inventoryId: z.never().optional(),
+          externalId: z.never().optional(),
+          productId: z.string().describe("Product ID.").max(36)
+        })
       ])
-    };
-    return metadata;
-  }
-  return __getInventoryVariants;
-}
-function queryInventory(payload) {
-  function __queryInventory({ host }) {
-    const metadata = {
-      entityFqdn: "wix.stores.v2.inventory",
-      method: "POST",
-      methodFqn: "wix.inventory.api.v1.InventoryReadApi.QueryInventory",
-      packageName: PACKAGE_NAME,
-      migrationOptions: {
-        optInTransformResponse: true
-      },
-      url: resolveWixInventoryApiV1InventoryReadApiUrl({
-        protoPath: "/v2/inventoryItems/query",
-        data: payload,
-        host
+    )
+  ).min(1).max(300)
+});
+var DecrementInventoryResponse = z.object({});
+var IncrementInventoryRequest = z.object({
+  incrementData: z.array(
+    z.intersection(
+      z.object({
+        variantId: z.string().describe("Variant ID.").regex(
+          /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+          "Must be a valid GUID"
+        ).optional(),
+        incrementBy: z.number().int().describe("Number to increment inventory by.").min(1).optional()
       }),
-      data: payload,
-      transformResponse: (payload2) => transformPaths(payload2, [
-        {
-          transformFn: transformRESTTimestampToSDKTimestamp,
-          paths: [{ path: "inventoryItems.lastUpdated" }]
-        }
+      z.xor([
+        z.object({
+          inventoryId: z.never().optional(),
+          productId: z.never().optional()
+        }),
+        z.object({
+          productId: z.never().optional(),
+          inventoryId: z.string().describe("Inventory item ID.").max(36)
+        }),
+        z.object({
+          inventoryId: z.never().optional(),
+          productId: z.string().describe("Product ID.").max(36)
+        })
       ])
-    };
-    return metadata;
-  }
-  return __queryInventory;
-}
+    )
+  ).min(1).max(300)
+});
+var IncrementInventoryResponse = z.object({});
 
 // src/stores-v2-inventory-inventory.universal.ts
 var ReasonType = /* @__PURE__ */ ((ReasonType2) => {
@@ -295,60 +511,79 @@ var WebhookIdentityType = /* @__PURE__ */ ((WebhookIdentityType2) => {
   WebhookIdentityType2["APP"] = "APP";
   return WebhookIdentityType2;
 })(WebhookIdentityType || {});
-async function updateInventoryVariants2(productId, inventoryItem) {
-  const { httpClient, sideEffects } = arguments[2];
+async function getInventoryVariants2(inventoryId, options) {
+  const { httpClient, sideEffects, validateRequestSchema } = arguments[2];
+  if (validateRequestSchema) {
+    GetInventoryVariantsRequest.parse({ inventoryId, options });
+  }
   const payload = renameKeysFromSDKRequestToRESTRequest({
-    inventoryItem: { ...inventoryItem, productId }
+    inventoryId,
+    externalId: options?.externalId,
+    productId: options?.productId,
+    variantIds: options?.variantIds
   });
-  const reqOpts = updateInventoryVariants(payload);
+  const reqOpts = getInventoryVariants(payload);
   sideEffects?.onSiteCall?.();
   try {
     const result = await httpClient.request(reqOpts);
     sideEffects?.onSuccess?.(result);
+    return renameKeysFromRESTResponseToSDKResponse(result.data);
   } catch (err) {
     const transformedError = sdkTransformError(
       err,
       {
-        spreadPathsToArguments: { inventoryItem: "$[1]" },
-        explicitPathsToArguments: { "inventoryItem.productId": "$[0]" },
+        spreadPathsToArguments: {},
+        explicitPathsToArguments: {
+          inventoryId: "$[0]",
+          externalId: "$[1].externalId",
+          productId: "$[1].productId",
+          variantIds: "$[1].variantIds"
+        },
         singleArgumentUnchanged: false
       },
-      ["productId", "inventoryItem"]
+      ["inventoryId", "options"]
     );
     sideEffects?.onError?.(err);
     throw transformedError;
   }
 }
-async function decrementInventory2(decrementData) {
-  const { httpClient, sideEffects } = arguments[1];
+async function queryInventory2(options) {
+  const { httpClient, sideEffects, validateRequestSchema } = arguments[1];
+  if (validateRequestSchema) {
+    QueryInventoryRequest.parse({ options });
+  }
   const payload = renameKeysFromSDKRequestToRESTRequest({
-    decrementData
+    query: options?.query
   });
-  const reqOpts = decrementInventory(payload);
+  const reqOpts = queryInventory(payload);
   sideEffects?.onSiteCall?.();
   try {
     const result = await httpClient.request(reqOpts);
     sideEffects?.onSuccess?.(result);
+    return renameKeysFromRESTResponseToSDKResponse(result.data);
   } catch (err) {
     const transformedError = sdkTransformError(
       err,
       {
         spreadPathsToArguments: {},
-        explicitPathsToArguments: { decrementData: "$[0]" },
+        explicitPathsToArguments: { query: "$[0].query" },
         singleArgumentUnchanged: false
       },
-      ["decrementData"]
+      ["options"]
     );
     sideEffects?.onError?.(err);
     throw transformedError;
   }
 }
-async function incrementInventory2(incrementData) {
-  const { httpClient, sideEffects } = arguments[1];
+async function updateInventoryVariants2(productId, inventoryItem) {
+  const { httpClient, sideEffects, validateRequestSchema } = arguments[2];
+  if (validateRequestSchema) {
+    UpdateInventoryVariantsRequest.parse({ productId, inventoryItem });
+  }
   const payload = renameKeysFromSDKRequestToRESTRequest({
-    incrementData
+    inventoryItem: { ...inventoryItem, productId }
   });
-  const reqOpts = incrementInventory(payload);
+  const reqOpts = updateInventoryVariants(payload);
   sideEffects?.onSiteCall?.();
   try {
     const result = await httpClient.request(reqOpts);
@@ -357,69 +592,65 @@ async function incrementInventory2(incrementData) {
     const transformedError = sdkTransformError(
       err,
       {
-        spreadPathsToArguments: {},
-        explicitPathsToArguments: { incrementData: "$[0]" },
+        spreadPathsToArguments: { inventoryItem: "$[1]" },
+        explicitPathsToArguments: { "inventoryItem.productId": "$[0]" },
         singleArgumentUnchanged: false
       },
-      ["incrementData"]
+      ["productId", "inventoryItem"]
     );
     sideEffects?.onError?.(err);
     throw transformedError;
   }
 }
-async function getInventoryVariants2(inventoryId, options) {
-  const { httpClient, sideEffects } = arguments[2];
+async function decrementInventory2(decrementData) {
+  const { httpClient, sideEffects, validateRequestSchema } = arguments[1];
+  if (validateRequestSchema) {
+    DecrementInventoryRequest.parse({ decrementData });
+  }
   const payload = renameKeysFromSDKRequestToRESTRequest({
-    inventoryId,
-    externalId: options?.externalId,
-    productId: options?.productId,
-    variantIds: options?.variantIds
+    decrementData
   });
-  const reqOpts = getInventoryVariants(payload);
+  const reqOpts = decrementInventory(payload);
   sideEffects?.onSiteCall?.();
   try {
     const result = await httpClient.request(reqOpts);
     sideEffects?.onSuccess?.(result);
-    return renameKeysFromRESTResponseToSDKResponse(result.data);
   } catch (err) {
     const transformedError = sdkTransformError(
       err,
       {
         spreadPathsToArguments: {},
-        explicitPathsToArguments: {
-          inventoryId: "$[0]",
-          externalId: "$[1].externalId",
-          productId: "$[1].productId",
-          variantIds: "$[1].variantIds"
-        },
+        explicitPathsToArguments: { decrementData: "$[0]" },
         singleArgumentUnchanged: false
       },
-      ["inventoryId", "options"]
+      ["decrementData"]
     );
     sideEffects?.onError?.(err);
     throw transformedError;
   }
 }
-async function queryInventory2(options) {
-  const { httpClient, sideEffects } = arguments[1];
+async function incrementInventory2(incrementData) {
+  const { httpClient, sideEffects, validateRequestSchema } = arguments[1];
+  if (validateRequestSchema) {
+    IncrementInventoryRequest.parse({ incrementData });
+  }
   const payload = renameKeysFromSDKRequestToRESTRequest({
-    query: options?.query
+    incrementData
   });
-  const reqOpts = queryInventory(payload);
+  const reqOpts = incrementInventory(payload);
   sideEffects?.onSiteCall?.();
   try {
     const result = await httpClient.request(reqOpts);
     sideEffects?.onSuccess?.(result);
-    return renameKeysFromRESTResponseToSDKResponse(result.data);
   } catch (err) {
     const transformedError = sdkTransformError(
       err,
       {
         spreadPathsToArguments: {},
-        explicitPathsToArguments: { query: "$[0].query" },
+        explicitPathsToArguments: { incrementData: "$[0]" },
         singleArgumentUnchanged: false
       },
-      ["options"]
+      ["incrementData"]
     );
     sideEffects?.onError?.(err);
     throw transformedError;