@spscommerce/asst-api 0.0.1-beta.1 → 0.0.1-beta.10

package/dist/msw.cjs

@@ -30,11 +30,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // lib/msw.ts
 var msw_exports = {};
 __export(msw_exports, {
+  createAttributesApiHandlers: () => createAttributesApiHandlers,
   createCategoriesApiHandlers: () => createCategoriesApiHandlers,
+  createCompanyFeaturesApiHandlers: () => createCompanyFeaturesApiHandlers,
+  createErrorsApiHandlers: () => createErrorsApiHandlers,
   createExportsApiHandlers: () => createExportsApiHandlers,
+  createFeatureFlagsApiHandlers: () => createFeatureFlagsApiHandlers,
   createImportsApiHandlers: () => createImportsApiHandlers,
+  createItemsApiHandlers: () => createItemsApiHandlers,
+  createLocaleApiHandlers: () => createLocaleApiHandlers,
   createProductTypesApiHandlers: () => createProductTypesApiHandlers,
-  createTradingPartnerAccessApiHandlers: () => createTradingPartnerAccessApiHandlers
+  createSpreadsheetTemplateApiHandlers: () => createSpreadsheetTemplateApiHandlers,
+  createTradingPartnerAccessApiHandlers: () => createTradingPartnerAccessApiHandlers,
+  createWhoAmIApiHandlers: () => createWhoAmIApiHandlers
 });
 module.exports = __toCommonJS(msw_exports);
 
@@ -2654,8 +2662,8 @@ var ZodTuple = class extends ZodType {
       });
       return INVALID;
     }
-    const rest6 = this._def.rest;
-    if (!rest6 && ctx.data.length > this._def.items.length) {
+    const rest14 = this._def.rest;
+    if (!rest14 && ctx.data.length > this._def.items.length) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.too_big,
         maximum: this._def.items.length,
@@ -2682,10 +2690,10 @@ var ZodTuple = class extends ZodType {
   get items() {
     return this._def.items;
   }
-  rest(rest6) {
+  rest(rest14) {
     return new ZodTuple({
       ...this._def,
-      rest: rest6
+      rest: rest14
     });
   }
 };
@@ -3726,11 +3734,11 @@ var z = /* @__PURE__ */ Object.freeze({
 
 // lib/imports/models/ImportDetail.ts
 var importDetailSchema = z.object({
-  completedAt: z.nullable(z.number()),
+  completedAt: z.number().nullish(),
   errorCount: z.number(),
   importId: z.number(),
   name: z.string(),
-  startedAt: z.nullable(z.string()),
+  startedAt: z.string().nullish(),
   status: z.string(),
   uploadedAt: z.string()
 });
@@ -3743,7 +3751,7 @@ var importSchema = z.object({
 
 // lib/imports/models/ImportError.ts
 var importErrorSchema = z.object({
-  attribute: z.string(),
+  attribute: z.string().nullish(),
   description: z.string(),
   importErrorId: z.number(),
   row: z.number()
@@ -3769,15 +3777,15 @@ var importStatusEnumSchema = z.enum([
 
 // lib/imports/models/ImportsStatus.ts
 var importsStatusSchema = z.object({
-  completedAt: z.nullable(z.string()).optional(),
-  docInEventId: z.nullable(z.string()).optional(),
-  errorCount: z.nullable(z.number()).optional(),
+  completedAt: z.string().nullish(),
+  docInEventId: z.string().nullish(),
+  errorCount: z.number().nullish(),
   importId: z.number(),
-  invalidItemCount: z.nullable(z.number()).optional(),
-  name: z.string(),
+  invalidItemCount: z.number().nullish(),
+  name: z.string().nullish(),
   status: importStatusEnumSchema,
-  totalItemCount: z.nullable(z.number()).optional(),
-  validItemCount: z.nullable(z.number()).optional()
+  totalItemCount: z.number().nullish(),
+  validItemCount: z.number().nullish()
 });
 
 // lib/imports/models/VendorPartnerAttGroups.ts
@@ -3797,7 +3805,6 @@ var generateImportTemplateParamsSchema = z.object({
 });
 
 // lib/imports/index.ts
-var import_query_string = __toESM(require("query-string"), 1);
 var BASE_URL = "imports";
 
 // lib/imports/mockHandlers.ts
@@ -3825,7 +3832,7 @@ function createImportsApiHandlers(client) {
   }) {
     return import_msw.rest.get(`${client.getBaseUrl()}/${BASE_URL}/status`, resolver);
   }
-  getImportsStatus.generateData = () => (0, import_zod_mock.generateMock)(importsStatusSchema);
+  getImportsStatus.generateData = () => (0, import_zod_mock.generateMock)(z.array(importsStatusSchema));
   function getVendorPartnerGroups(resolver = (_req, res, ctx) => {
     const data = (0, import_zod_mock.generateMock)(z.array(vendorPartnerAttGroupsSchema));
     return res(ctx.status(200), ctx.json(data));
@@ -3835,7 +3842,7 @@ function createImportsApiHandlers(client) {
       resolver
     );
   }
-  getVendorPartnerGroups.generateData = () => (0, import_zod_mock.generateMock)(vendorPartnerAttGroupsSchema);
+  getVendorPartnerGroups.generateData = () => (0, import_zod_mock.generateMock)(z.array(vendorPartnerAttGroupsSchema));
   function uploadImport(resolver = (_req, res, ctx) => {
     return res(ctx.status(200));
   }) {
@@ -3869,13 +3876,13 @@ var itemCategorySchema = z.object({
   companyId: z.number(),
   name: z.string(),
   isActive: z.number(),
-  createdDate: z.nullable(z.number()),
-  categorytimestamp: z.nullable(z.number()),
+  createdDate: z.number().nullish(),
+  categorytimestamp: z.number().nullish(),
   typeId: z.number(),
   type: z.string(),
-  categorykey: z.optional(z.string()),
-  description: z.nullable(z.string()).optional(),
-  categoryCatalogName: z.nullable(z.string()).optional()
+  categorykey: z.string().nullish(),
+  description: z.string().nullish(),
+  categoryCatalogName: z.string().nullish()
 });
 
 // lib/categories/models/ItemCategoriesSearch.ts
@@ -3884,45 +3891,63 @@ var itemCategoriesSearchSchema = z.object({
   data: z.array(itemCategorySchema)
 });
 
+// lib/categories/models/Hierarchy.ts
+var baseHierarchySchema = z.object({
+  id: z.string(),
+  name: z.string().nullish(),
+  description: z.string().nullish(),
+  type: z.string().nullish()
+});
+var hierarchySchema = baseHierarchySchema.extend(
+  {
+    child: z.lazy(() => hierarchySchema).nullable()
+  }
+);
+
+// lib/categories/models/ItemHierarchy.ts
+var itemHierarchySchema = z.object({
+  itemId: z.string(),
+  hierarchies: z.array(hierarchySchema)
+});
+
+// lib/categories/models/ItemHierarchyResponse.ts
+var itemHierarchyResponseSchema = z.object({
+  itemHierarchies: z.array(itemHierarchySchema)
+});
+
 // lib/categories/index.ts
 var BASE_URL2 = "categories";
 
 // lib/categories/mockHandlers.ts
 function createCategoriesApiHandlers(client) {
-  function getCatalogs(resolver = (_req, res, ctx) => {
-    const data = (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema);
-    res(ctx.status(200), ctx.json(data));
-  }) {
-    return import_msw2.rest.get(
-      `${client.getBaseUrl()}/${BASE_URL2}/search-category?type=CATALOG`,
-      resolver
-    );
-  }
-  getCatalogs.generateData = () => (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema);
-  function getProductCodes(resolver = (_req, res, ctx) => {
-    const data = (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema);
-    res(ctx.status(200), ctx.json(data));
-  }) {
-    return import_msw2.rest.get(
-      `${client.getBaseUrl()}/${BASE_URL2}/search-category?type=PRODUCT_CODE`,
-      resolver
-    );
-  }
-  getProductCodes.generateData = () => (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema);
-  function getSelectionCodes(resolver = (_req, res, ctx) => {
-    const data = (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema);
-    res(ctx.status(200), ctx.json(data));
+  function getCategory(resolver = (req, res, ctx) => {
+    let data;
+    if (req.url.searchParams.get("type") === "CATALOG") {
+      data = (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema, {
+        stringMap: {
+          type: () => "CATALOG"
+        }
+      });
+    } else if (req.url.searchParams.get("type") === "PRODUCT_CODE") {
+      data = (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema, {
+        stringMap: {
+          type: () => "PRODUCT_CODE"
+        }
+      });
+    } else {
+      data = (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema, {
+        stringMap: {
+          type: () => "SELECTION_CODE"
+        }
+      });
+    }
+    return res(ctx.status(200), ctx.json(data));
   }) {
-    return import_msw2.rest.get(
-      `${client.getBaseUrl()}/${BASE_URL2}/search-category?type=SELECTION_CODE`,
-      resolver
-    );
+    return import_msw2.rest.get(`${client.getBaseUrl()}/${BASE_URL2}/search-category`, resolver);
   }
-  getSelectionCodes.generateData = () => (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema);
+  getCategory.generateData = () => (0, import_zod_mock2.generateMock)(itemCategoriesSearchSchema);
   return {
-    getCatalogs,
-    getProductCodes,
-    getSelectionCodes
+    getCategory
   };
 }
 
@@ -3930,17 +3955,27 @@ function createCategoriesApiHandlers(client) {
 var import_msw3 = require("msw");
 
 // lib/exports/index.ts
-var BASE_URL3 = "v2/exports";
+var BASE_URL3 = "exports";
+var BASE_URL_V2 = "v2/exports";
 
 // lib/exports/mockHandlers.ts
 function createExportsApiHandlers(client) {
-  function add(resolver = (_req, res, ctx) => {
+  function createExport(resolver = (_req, res, ctx) => {
     return res(ctx.status(200));
   }) {
-    return import_msw3.rest.post(`${client.getBaseUrl()}/${BASE_URL3}/add`, resolver);
+    return import_msw3.rest.post(`${client.getBaseUrl()}/${BASE_URL_V2}/add`, resolver);
+  }
+  function downloadItems(resolver = (_req, res, ctx) => {
+    return res(ctx.status(400, "Not supported"));
+  }) {
+    return import_msw3.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL3}/spreadsheet/by-item`,
+      resolver
+    );
   }
   return {
-    add
+    createExport,
+    downloadItems
   };
 }
 
@@ -3960,10 +3995,6 @@ var attrProdTypeSchema = z.object({
   retailerId: z.number().optional()
 });
 
-// lib/productTypes/index.ts
-var import_query_string2 = __toESM(require("query-string"), 1);
-var BASE_URL4 = "product-types";
-
 // lib/productTypes/models/PagedResults.ts
 function pagedResultsSchema(resultsType) {
   return z.object({
@@ -3974,6 +4005,9 @@ function pagedResultsSchema(resultsType) {
   });
 }
 
+// lib/productTypes/index.ts
+var BASE_URL4 = "product-types";
+
 // lib/productTypes/mockHandlers.ts
 function createProductTypesApiHandlers(client) {
   function getProductTypes(resolver = (_req, res, ctx) => {
@@ -3995,9 +4029,10 @@ var import_msw5 = require("msw");
 // lib/tradingPartners/models/Connection.ts
 var connectionSchema = z.object({
   catalog_id: z.number(),
-  catalog_name: z.string(),
+  catalog_name: z.string().nullable(),
   partner_company_name: z.string(),
-  partner_company_id: z.number()
+  partner_company_id: z.number(),
+  partner_org_id: z.string()
 });
 
 // lib/tradingPartners/models/TradingPartnerAccessByCompanyId.ts
@@ -4026,11 +4061,967 @@ function createTradingPartnerAccessApiHandlers(client) {
     getAllTradingPartners
   };
 }
+
+// lib/whoami/mockHandlers.ts
+var import_zod_mock5 = require("@anatine/zod-mock");
+var import_msw6 = require("msw");
+
+// lib/whoami/models/IdentityServiceDatetimePreferences.ts
+var identityServiceDatetimePreferencesSchema = z.object({
+  DATE_TIME: z.string(),
+  TIME: z.string(),
+  SHORT_DATE: z.string(),
+  LONG_DATETIME: z.string(),
+  LONG_TIME: z.string(),
+  DATE: z.string()
+});
+
+// lib/whoami/models/IdentityServiceOrganizationMetadata.ts
+var identityServiceOrganizationMetadataSchema = z.object({
+  namespace: z.string(),
+  key: z.string(),
+  value: z.string()
+});
+
+// lib/whoami/models/IdentityServiceOrganization.ts
+var identityServiceOrganizationSchema = z.object({
+  organization_name: z.string().optional(),
+  organization_site: z.string().optional(),
+  namespace: z.string().optional(),
+  id: z.string(),
+  permissions: z.array(z.string()).optional(),
+  metadata: identityServiceOrganizationMetadataSchema.optional()
+});
+
+// lib/whoami/models/IdentityServicePreferences.ts
+var identityServicePreferencesSchema = z.object({
+  locale: z.string(),
+  timezone: z.string(),
+  cpUpgrade: z.string().optional(),
+  language: z.array(z.string()),
+  datetime: identityServiceDatetimePreferencesSchema
+});
+
+// lib/whoami/models/IdentityServiceUser.ts
+var identityServiceUserSchema = z.object({
+  id: z.string(),
+  email: z.string().optional(),
+  first_name: z.string().optional(),
+  last_name: z.string().optional(),
+  job_title: z.string().optional(),
+  externally_managed: z.boolean().optional(),
+  city: z.string().optional(),
+  name: z.string(),
+  state: z.string().optional(),
+  country: z.string().optional(),
+  user_type: z.string().optional(),
+  token_type: z.string().optional(),
+  avatar_image_id: z.string().optional(),
+  avatar_image_url: z.string().optional(),
+  origin_avatar_image_id: z.string().optional(),
+  bio: z.string().optional(),
+  phone_number: z.string().optional(),
+  twitter_handle: z.string().optional(),
+  linkedin_url: z.string().optional(),
+  description: z.string().optional(),
+  preferences: identityServicePreferencesSchema.optional(),
+  roles: z.array(z.string()),
+  organization: identityServiceOrganizationSchema,
+  password: z.string(),
+  verified: z.boolean()
+});
+
+// lib/whoami/models/RegisteredService.ts
+var registeredServiceSchema = z.object({
+  serviceId: z.number(),
+  identityServiceId: z.number(),
+  name: z.string(),
+  isActive: z.boolean()
+});
+
+// lib/whoami/models/UserAccount.ts
+var userAccountSchema = z.object({
+  identityUser: identityServiceUserSchema,
+  companyId: z.number(),
+  companyName: z.string(),
+  name: z.string(),
+  assortmentPartnerCompanyId: z.number().nullish(),
+  retailer: z.boolean(),
+  supplier: z.boolean(),
+  registeredService: registeredServiceSchema,
+  uniqueAttributes: z.array(z.string()),
+  admin: z.boolean(),
+  adminToolUser: z.boolean(),
+  attributeRegistryAdmin: z.boolean(),
+  attributeRegistryDev: z.boolean(),
+  attributeRegistryRsx: z.boolean(),
+  attributeRegistryUser: z.boolean(),
+  attributeRegistryViewer: z.boolean()
+});
+
+// lib/whoami/index.ts
+var BASE_URL6 = "whoami";
+
+// lib/whoami/mockHandlers.ts
+function createWhoAmIApiHandlers(client) {
+  function whoAmI(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock5.generateMock)(userAccountSchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw6.rest.get(`${client.getBaseUrl()}/${BASE_URL6}`, resolver);
+  }
+  whoAmI.generateData = () => (0, import_zod_mock5.generateMock)(userAccountSchema);
+  return {
+    whoAmI
+  };
+}
+
+// lib/errors/mockHandlers.ts
+var import_zod_mock6 = require("@anatine/zod-mock");
+var import_msw7 = require("msw");
+
+// lib/items/models/ItemHeader.ts
+var itemHeaderSchema = z.object({
+  status: z.string().optional(),
+  catalogName: z.string(),
+  productCodeName: z.string(),
+  selectionCodeName: z.string(),
+  gtin: z.string(),
+  upc: z.string(),
+  ean: z.string(),
+  isbn: z.string(),
+  partNumber: z.string(),
+  lastUpdatedDateString: z.string(),
+  companyId: z.string(),
+  itemInfoId: z.string()
+});
+
+// lib/items/models/PhaseEnum.ts
+var phaseEnumSchema = z.enum([
+  "CORE",
+  "CORE_PLUS",
+  "CORE_ADVANCED",
+  "ENRICHED",
+  "STANDARD_REQUIREMENTS"
+]);
+
+// lib/items/models/TradingPartnerStage.ts
+var tradingPartnerStageSchema = z.object({
+  companyId: z.number(),
+  companyName: z.string(),
+  stage: z.nullable(phaseEnumSchema),
+  isValid: z.boolean()
+});
+
+// lib/items/models/ItemMap.ts
+var itemMapSchema = z.object({
+  rn: z.number().optional(),
+  iteminfoid: z.string(),
+  tradingPartnerStages: z.array(tradingPartnerStageSchema).optional(),
+  gtin: z.string().nullish(),
+  catalogname: z.string().nullish(),
+  isbn: z.string().nullish(),
+  lastupdateddatestring: z.string().nullish(),
+  upc: z.string().nullish(),
+  productcodename: z.string().nullish(),
+  ean: z.string().nullish(),
+  selectioncodename: z.string().nullish(),
+  createddatestring: z.string().nullish(),
+  partnumber: z.string().nullish(),
+  consumeravailabledatestring: z.string().nullish(),
+  status: z.string().nullish(),
+  nrfcolorcode: z.array(z.string()).nullish(),
+  nrfsizecode: z.array(z.string()).nullish(),
+  productcolordescription: z.array(z.string()).nullish(),
+  productsizedescription: z.array(z.string()).nullish()
+}).passthrough();
+
+// lib/items/models/ItemTable.ts
+var itemTableSchema = z.object({
+  headers: itemHeaderSchema,
+  itemMaps: z.array(itemMapSchema)
+});
+
+// lib/items/models/ItemSearchView.ts
+var itemSearchViewSchema = z.object({
+  itemTable: itemTableSchema,
+  hasNext: z.boolean(),
+  count: z.number()
+});
+
+// lib/asstClient.ts
+var import_ky_universal = __toESM(require("ky-universal"), 1);
+var baseUrlsSchema = z.object({
+  local: z.literal("https://localhost:8443"),
+  test: z.literal("https://integration.api.spscommerce.com/assortment/gateway"),
+  prod: z.literal("https://api.spscommerce.com/assortment/gateway")
+});
+var BASE_URLS = {
+  local: "https://localhost:8443",
+  test: "https://integration.api.spscommerce.com/assortment/gateway",
+  prod: "https://api.spscommerce.com/assortment/gateway"
+};
+var envSchema = baseUrlsSchema.keyof();
+var initialConfig = {
+  prefixUrl: BASE_URLS["test"],
+  retry: 0
+};
+
+// lib/exports/models/ExportType.ts
+var exportTypeEnum = z.enum(["ALL", "UPDATES", "DELTAS_UPDATE", "NO_BUYER_PART_NUMBER"]);
+
+// lib/exports/models/ExportFrequency.ts
+var exportFrequencyEnum = z.enum([
+  "IMMEDIATE",
+  "ONETIME",
+  "DAILY",
+  "WEEKLY",
+  "MONTHLY"
+]);
+
+// lib/exports/models/ExportDayOfWeek.ts
+var exportDayOfWeekEnum = z.enum([
+  "MON",
+  "TUE",
+  "WED",
+  "THU",
+  "FRI",
+  "SAT",
+  "SUN"
+]);
+
+// lib/exports/models/Export.ts
+var exportSchema = z.object({
+  exportName: z.string(),
+  exportDescription: z.string(),
+  isActive: z.boolean(),
+  exportType: exportTypeEnum,
+  exportFrequency: exportFrequencyEnum,
+  includeValidAttributes: z.optional(z.boolean()),
+  dayOfMonth: z.optional(z.number()),
+  dayOfWeek: z.optional(exportDayOfWeekEnum),
+  hourOfDay: z.optional(z.number()),
+  date: z.optional(z.string()),
+  catalogIds: z.optional(z.array(z.number())),
+  itemInfoIds: z.optional(z.array(z.number())),
+  excludeItemInfoIds: z.optional(z.array(z.number())),
+  selectionCodeIds: z.optional(z.array(z.number())),
+  productCodeIds: z.optional(z.array(z.number())),
+  productTypes: z.optional(z.array(z.string())),
+  deliveryType: z.optional(z.string()),
+  spreadsheetTemplateId: z.optional(z.number()),
+  emailAddresses: z.optional(z.array(z.string())),
+  subjectLine: z.optional(z.string()),
+  additionalLocales: z.optional(z.array(z.string()))
+});
+
+// lib/exports/models/DownloadItemsParams.ts
+var downLoadItemsParamsSchema = z.object({
+  "multi-sheet": z.boolean(),
+  ids: z.array(z.string())
+});
+
+// lib/attributes/models/AttributeMetaData.ts
+var attributeMetaDataSchema = z.object({
+  dbName: z.string(),
+  label: z.string(),
+  group: z.string(),
+  aliases: z.array(z.string()),
+  orderBy: z.string().or(z.number()),
+  type: z.string(),
+  storageType: z.string(),
+  rsxPath: z.string(),
+  indexed: z.boolean(),
+  repeatable: z.boolean(),
+  extended: z.boolean(),
+  hybrid: z.boolean(),
+  userVisible: z.boolean(),
+  retailerOwnedId: z.number().nullish()
+});
+
+// lib/attributes/models/AttributeSummary.ts
+var attributeSummarySchema = z.object({
+  attributeId: z.number(),
+  attributeName: z.string(),
+  displayName: z.string(),
+  modifiedBy: z.string(),
+  modifiedDate: z.number(),
+  retailerOwnedId: z.number().nullish(),
+  clusterAttrGroupId: z.number().nullish(),
+  attributeType: z.string()
+});
+
+// lib/attributes/models/AttributesByCompany.ts
+var attributesByCompanySchema = z.object({
+  next: z.string().nullish(),
+  previous: z.string().nullish(),
+  count: z.number(),
+  results: z.array(attributeSummarySchema)
+});
+
+// lib/attributes/models/AttrDatatypeNameEnum.ts
+var attrDatatypeNameEnumSchema = z.enum([
+  "TEXT",
+  "SET",
+  "INTEGER",
+  "FLOAT",
+  "BOOLEAN",
+  "DATE",
+  "KEYVALUE",
+  "STRING",
+  "REAL"
+]);
+
+// lib/attributes/models/AttributeGroup.ts
+var attributeGroupSchema = z.object({
+  attrGroupId: z.number(),
+  attrGroupType: z.object({
+    attrGroupTypeId: z.number(),
+    groupTypeName: z.string(),
+    primary: z.boolean(),
+    restricted: z.boolean()
+  }),
+  attrGroupTypeId: z.number(),
+  groupName: z.string(),
+  isDefault: z.boolean(),
+  orderWeight: z.number(),
+  primary: z.boolean()
+});
+
+// lib/attributes/models/AttributeDefinition.ts
+var parentAttributeSchema = z.object({
+  attrDataTypeId: z.number(),
+  attrDatatype: z.object({
+    attrDatatypeId: z.number(),
+    datatypeName: attrDatatypeNameEnumSchema,
+    displayOnly: z.boolean()
+  }),
+  attrGroupId: z.number(),
+  attrGroups: z.array(attributeGroupSchema),
+  attrRoundId: z.number(),
+  attrStorageId: z.number(),
+  attributeId: z.number(),
+  attributeName: z.string(),
+  createdBy: z.string(),
+  createdDate: z.number(),
+  description: z.string().optional(),
+  displayName: z.string(),
+  modifiedDate: z.number(),
+  orderWeight: z.number(),
+  parentAttributeId: z.number().optional(),
+  primaryAttrGroup: attributeGroupSchema
+});
+var attributeDefinitionSchema = z.object({
+  attrDataTypeId: z.number(),
+  attrDatatype: z.object({
+    attrDatatypeId: z.number(),
+    datatypeName: attrDatatypeNameEnumSchema,
+    displayOnly: z.boolean()
+  }),
+  attrGroupId: z.number(),
+  attrGroups: z.array(attributeGroupSchema),
+  attrRestrictions: z.array(
+    z.object({
+      attrRestrictId: z.number(),
+      ignoreGlobal: z.boolean().optional(),
+      isDefault: z.boolean(),
+      isEssential: z.boolean(),
+      locale: z.string(),
+      mandatory: z.boolean(),
+      repeatable: z.boolean(),
+      minLength: z.number().optional(),
+      maxLength: z.number().optional()
+    })
+  ).optional(),
+  attrRoundId: z.number(),
+  attrStorage: z.object({
+    attrStorageId: z.number(),
+    storageName: z.string()
+  }),
+  attrStorageId: z.number(),
+  attrValues: z.array(
+    z.object({
+      attrKeyPair: z.string(),
+      attrValueId: z.number().optional(),
+      isDefault: z.boolean(),
+      locale: z.string(),
+      value: z.string()
+    })
+  ).optional(),
+  attributeId: z.number(),
+  attributeName: z.string(),
+  createdBy: z.string(),
+  createdDate: z.number(),
+  description: z.string().optional(),
+  displayName: z.string(),
+  modifiedDate: z.number(),
+  orderWeight: z.number().optional(),
+  parentAttribute: parentAttributeSchema.optional(),
+  parentAttributeId: z.number().optional(),
+  primaryAttrGroup: attributeGroupSchema
+});
+
+// lib/attributes/models/AttributeValidValues.ts
+var attributeValidValuesSchema = z.object({
+  value: z.string(),
+  isDefault: z.boolean(),
+  locale: z.string(),
+  createdBy: z.string(),
+  createdDate: z.number(),
+  modifiedDate: z.number(),
+  modifiedBy: z.string(),
+  attributeId: z.number(),
+  attrValueId: z.number(),
+  attrKeyPair: z.string()
+});
+
+// lib/locale/models/Locale.ts
+var localeSchema = z.object({
+  localeCode: z.string(),
+  localeDescription: z.string()
+});
+
+// lib/spreadsheetTemplate/models/SpreadsheetTemplateCompany.ts
+var spreadsheetTemplateCompanySchema = z.object({
+  companyName: z.string(),
+  companyId: z.number(),
+  createdAt: z.number()
+});
+
+// lib/spreadsheetTemplate/models/SpreadsheetTemplate.ts
+var spreadsheetTemplateSchema = z.object({
+  id: z.number(),
+  fileLocation: z.string(),
+  name: z.string(),
+  templateType: z.string(),
+  maxItemsPerDoc: z.number(),
+  companies: z.array(spreadsheetTemplateCompanySchema),
+  createdBy: z.string().nullish(),
+  createdAt: z.number().nullish(),
+  modifiedBy: z.string().nullish(),
+  modifiedAt: z.number().nullish()
+});
+
+// lib/items/models/AttributeDetail.ts
+var attributeDetailSchema = z.object({
+  type: attrDatatypeNameEnumSchema,
+  name: z.string(),
+  value: z.string().or(z.number()).or(z.array(z.string())).or(z.array(z.number())).nullable(),
+  label: z.string(),
+  group: z.string(),
+  orderBy: z.number().or(z.string()).nullish()
+});
+
+// lib/items/models/CategoryEnum.ts
+var categoryEnumSchema = z.enum([
+  "AKA",
+  "CATALOG",
+  "EXPORT",
+  "LABEL",
+  "LEGACY_PRODUCT_TYPE",
+  "PRODUCT_CLASSIFICATION",
+  "PRODUCT_CODE",
+  "SELECTION_CODE",
+  "TAXONOMY_ROOT"
+]);
+
+// lib/items/models/ComponentDetails.ts
+var componentDetailsSchema = z.object({
+  itemInfoId: z.number(),
+  description: z.string(),
+  saleable: z.boolean(),
+  valid: z.boolean(),
+  uniqueCriteria: z.array(
+    z.object({
+      name: z.string(),
+      value: z.string()
+    })
+  )
+});
+
+// lib/items/models/RepeatableGroup.ts
+var repeatableGroupSchema = z.object({
+  repeatableGroupId: z.string(),
+  repeatableNumber: z.number()
+});
+
+// lib/items/models/GroupedAttributeList.ts
+var groupedAttributeListSchema = z.object({
+  type: z.string(),
+  rows: z.array(z.array(attributeDetailSchema)),
+  repeatableGroups: z.array(repeatableGroupSchema)
+});
+
+// lib/items/models/GroupedAttributes.ts
+var groupedAttributesSchema = z.object({
+  type: z.string(),
+  attributes: z.array(attributeDetailSchema),
+  attributeGroups: z.array(groupedAttributeListSchema)
+});
+
+// lib/items/models/HierarchyCategory.ts
+var hierarchyCategorySchema = z.object({
+  name: z.string(),
+  description: z.string().nullish(),
+  id: z.number(),
+  companyId: z.number(),
+  type: categoryEnumSchema
+});
+
+// lib/items/models/HierarchyDetails.ts
+var hierarchyDetailsSchema = z.object({
+  catalogs: z.array(hierarchyCategorySchema),
+  selectionCodes: z.array(hierarchyCategorySchema),
+  productCodes: z.array(hierarchyCategorySchema)
+});
+
+// lib/items/models/PackComponentItemInfo.ts
+var packComponentItemInfoSchema = z.object({
+  companyid: z.number(),
+  createddate: z.number(),
+  isServiceApi: z.boolean(),
+  isactive: z.number(),
+  isvalid: z.number(),
+  itemType: z.string(),
+  iteminfoid: z.number(),
+  itemtimestamp: z.number(),
+  serviceId: z.number(),
+  attributes: z.record(z.string(), z.string().or(z.array(z.string())))
+});
+
+// lib/items/models/ItemPrice.ts
+var itemPriceSchema = z.object({
+  amount: z.number(),
+  currency: z.string(),
+  id: z.number().nullish(),
+  priceDivision: z.string().nullish(),
+  iteminfoid: z.number().nullish(),
+  startdate: z.string().nullish(),
+  enddate: z.string().nullish(),
+  qualifier: z.string(),
+  region: z.string().nullish(),
+  regionqualifier: z.string().nullish(),
+  regiondescription: z.string().nullish(),
+  partnercompanyid: z.string().nullish(),
+  itempricetimestamp: z.number().nullish(),
+  range_type: z.string().nullish(),
+  date_range_type: z.string().nullish(),
+  min_range: z.number().nullish(),
+  gtin: z.string().nullish(),
+  priceConditionDescription: z.string().nullish(),
+  priceUnitQuantity: z.number().nullish(),
+  priceUnitQuantityUOM: z.string().nullish()
+});
+
+// lib/items/models/PackComponentDetails.ts
+var packComponentDetailsSchema = z.object({
+  itemInfo: packComponentItemInfoSchema,
+  itemPrices: z.array(itemPriceSchema)
+});
+
+// lib/items/models/GroupedItem.ts
+var groupedItemSchema = z.object({
+  iteminfoid: z.number(),
+  companyid: z.number(),
+  status: z.string(),
+  createdDate: z.string(),
+  lastUpdatedDate: z.string(),
+  identifiers: z.record(z.string(), z.any()),
+  hierarchyDetails: hierarchyDetailsSchema,
+  groupedAttributes: z.array(groupedAttributesSchema),
+  packComponentDetails: z.array(packComponentDetailsSchema),
+  childComponentDetails: z.array(componentDetailsSchema),
+  parentComponentDetails: z.array(componentDetailsSchema),
+  locales: z.array(z.string())
+});
+
+// lib/items/models/ItemDetailView.ts
+var itemDetailViewSchema = z.object({
+  item: groupedItemSchema
+});
+
+// lib/items/models/Bulb.ts
+var bulbSchema = z.object({
+  iteminfoid: z.number(),
+  id: z.number(),
+  shape: z.string(),
+  position: z.number(),
+  quantity: z.number(),
+  basetype: z.string(),
+  maxwatt: z.number(),
+  createdat: z.string(),
+  modifiedat: z.string(),
+  bulbtype: z.string(),
+  bulbincluded: z.string(),
+  bulbsize: z.string(),
+  replacementbulb: z.string(),
+  threewaybulb: z.string()
+});
+
+// lib/items/models/PackComponent.ts
+var packComponentSchema = z.object({
+  itemInfoId: z.number().nullish(),
+  attributes: z.record(z.string(), z.string().or(z.array(z.string()))),
+  prices: z.array(itemPriceSchema)
+});
+
+// lib/items/models/MediaItem.ts
+var mediaItemSchema = z.object({
+  id: z.number(),
+  iteminfoid: z.number(),
+  medianame: z.string(),
+  height: z.number().nullish(),
+  filename: z.string(),
+  mediafilename: z.string().nullish(),
+  description: z.string().nullish(),
+  filesize: z.number().nullish(),
+  format: z.string().nullish(),
+  orientation: z.string().nullish(),
+  pixeldensity: z.string().nullish(),
+  purpose: z.string().nullish(),
+  width: z.number().nullish(),
+  mediatype: z.string(),
+  mediaviewtype: z.string().nullish(),
+  compressionquality: z.string().nullish(),
+  thumbnailflag: z.string().nullish()
+});
+
+// lib/items/models/ItemDetail.ts
+var itemDetailSchema = z.object({
+  attributes: z.record(z.string(), z.any()),
+  clusters: z.record(
+    z.string(),
+    z.array(
+      z.object({
+        itemInfoAttributes: z.record(
+          z.string(),
+          z.string().or(z.number()).or(z.boolean())
+        )
+      })
+    )
+  ),
+  prices: z.array(itemPriceSchema),
+  bulbs: z.array(bulbSchema),
+  media: z.array(mediaItemSchema),
+  packs: z.array(packComponentSchema)
+});
+
+// lib/items/models/SpsItemIdResponse.ts
+var spsItemIdResponseSchema = z.object({
+  id: z.string(),
+  ref: z.string()
+});
+
+// lib/items/models/ItemOrgStatus.ts
+var itemOrgStatusSchema = z.object({
+  org: z.object({
+    ref: z.string(),
+    id: z.string(),
+    name: z.string()
+  }),
+  lowestInvalidStage: phaseEnumSchema.nullable(),
+  validForRelationship: z.boolean()
+});
+
+// lib/items/models/ItemStatus.ts
+var itemStatusSchema = z.object({
+  itemId: z.string(),
+  itemOrgStatuses: z.array(itemOrgStatusSchema)
+});
+
+// lib/items/models/ItemStatusResponse.ts
+var itemStatusResponseSchema = z.object({
+  itemStatuses: z.array(itemStatusSchema)
+});
+
+// lib/errors/models/ItemErrorDetails.ts
+var itemErrorDetailsSchema = z.object({
+  errorMessage: z.string(),
+  attributeName: z.string().nullable(),
+  tradingPartnerNames: z.array(z.string()),
+  phases: z.array(phaseEnumSchema),
+  attributeDbNames: z.array(z.string()),
+  tradingPartnerStages: z.array(tradingPartnerStageSchema),
+  repeatableGroupId: z.string().nullish()
+});
+
+// lib/errors/models/ItemErrorDetailsResult.ts
+var itemErrorDetailsResultSchema = z.object({
+  itemInfoId: z.number(),
+  upc: z.string().nullish(),
+  isbn: z.string().nullish(),
+  gtin: z.string().nullish(),
+  partnumber: z.string().nullish(),
+  ean: z.string().nullish(),
+  itemName: z.string().nullable(),
+  itemErrorDetails: z.array(itemErrorDetailsSchema)
+});
+
+// lib/errors/index.ts
+var BASE_URL7 = "errors";
+
+// lib/errors/mockHandlers.ts
+function createErrorsApiHandlers(client) {
+  function getInvalidItemErrorDetails(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock6.generateMock)(itemErrorDetailsResultSchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw7.rest.get(`${client.getBaseUrl()}/${BASE_URL7}/items/:itemInfoId`, resolver);
+  }
+  getInvalidItemErrorDetails.generateData = () => (0, import_zod_mock6.generateMock)(itemErrorDetailsResultSchema);
+  return {
+    getInvalidItemErrorDetails
+  };
+}
+
+// lib/locale/mockHandlers.ts
+var import_msw8 = require("msw");
+
+// lib/locale/index.ts
+var BASE_URL8 = "locale";
+
+// lib/locale/mockHandlers.ts
+var import_zod_mock7 = require("@anatine/zod-mock");
+function createLocaleApiHandlers(client) {
+  function getLocale(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock7.generateMock)(z.array(localeSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw8.rest.get(`${client.getBaseUrl()}/${BASE_URL8}`, resolver);
+  }
+  getLocale.generateData = () => (0, import_zod_mock7.generateMock)(z.array(localeSchema));
+  return {
+    getLocale
+  };
+}
+
+// lib/items/mockHandlers.ts
+var import_zod_mock8 = require("@anatine/zod-mock");
+var import_msw9 = require("msw");
+
+// lib/items/index.ts
+var BASE_URL9 = "items";
+
+// lib/items/mockHandlers.ts
+function createItemsApiHandlers(client) {
+  function searchItems(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock8.generateMock)(itemSearchViewSchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw9.rest.get(`${client.getBaseUrl()}/${BASE_URL9}`, resolver);
+  }
+  searchItems.generateData = () => (0, import_zod_mock8.generateMock)(itemSearchViewSchema);
+  function getItem(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock8.generateMock)(itemDetailViewSchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw9.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL9}/:itemId`,
+      resolver
+    );
+  }
+  getItem.generateData = () => (0, import_zod_mock8.generateMock)(itemDetailViewSchema);
+  function updateItem(resolver = (_req, res, ctx) => {
+    return res(ctx.status(200));
+  }) {
+    return import_msw9.rest.put(
+      `${client.getBaseUrl()}/${BASE_URL9}/details/:itemId`,
+      resolver
+    );
+  }
+  function deleteItem(resolver = (_req, res, ctx) => {
+    return res(ctx.status(200));
+  }) {
+    return import_msw9.rest.post(`${client.getBaseUrl()}/${BASE_URL9}/:itemId`, resolver);
+  }
+  function deleteItems(resolver = (_req, res, ctx) => {
+    return res(ctx.status(200));
+  }) {
+    return import_msw9.rest.post(`${client.getBaseUrl()}/${BASE_URL9}/items`, resolver);
+  }
+  function getItemInfoId(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock8.generateMock)(z.number());
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw9.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL9}/:spsItemId/itemInfoId`,
+      resolver
+    );
+  }
+  getItemInfoId.generateData = () => (0, import_zod_mock8.generateMock)(z.number());
+  function getSpsItemId(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock8.generateMock)(z.string());
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw9.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL9}/:itemInfoId/spsItemId`,
+      resolver
+    );
+  }
+  getSpsItemId.generateData = () => (0, import_zod_mock8.generateMock)(z.string());
+  function getItemStatus(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock8.generateMock)(itemStatusResponseSchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw9.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL9}/status`,
+      resolver
+    );
+  }
+  getItemStatus.generateData = () => (0, import_zod_mock8.generateMock)(itemStatusResponseSchema);
+  return {
+    searchItems,
+    getItem,
+    updateItem,
+    deleteItem,
+    deleteItems,
+    getItemInfoId,
+    getSpsItemId,
+    getItemStatus
+  };
+}
+
+// lib/attributes/mockHandlers.ts
+var import_msw10 = require("msw");
+
+// lib/attributes/index.ts
+var BASE_URL10 = "attributes";
+
+// lib/attributes/mockHandlers.ts
+var import_zod_mock9 = require("@anatine/zod-mock");
+function createAttributesApiHandlers(client) {
+  function getAllAttributes(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock9.generateMock)(z.array(attributeMetaDataSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw10.rest.get(`${client.getBaseUrl()}/${BASE_URL10}`, resolver);
+  }
+  getAllAttributes.generateData = () => (0, import_zod_mock9.generateMock)(attributeMetaDataSchema);
+  function getAllAttributesByCompany(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock9.generateMock)(attributesByCompanySchema);
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw10.rest.get(`${client.getBaseUrl()}/${BASE_URL10}/company`, resolver);
+  }
+  getAllAttributesByCompany.generateData = () => (0, import_zod_mock9.generateMock)(attributesByCompanySchema);
+  function getAttributesExtensiveInfo(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock9.generateMock)(z.array(attributeDefinitionSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw10.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL10}/registry/editui`,
+      resolver
+    );
+  }
+  getAttributesExtensiveInfo.generateData = () => (0, import_zod_mock9.generateMock)(z.array(attributeDefinitionSchema));
+  function getAttributeValidValues(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock9.generateMock)(z.array(attributeValidValuesSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw10.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL10}/registry/attribute/:attributeDbName/values`,
+      resolver
+    );
+  }
+  getAttributeValidValues.generateData = () => (0, import_zod_mock9.generateMock)(attributeValidValuesSchema);
+  function getCompanyInterestedAttributes(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock9.generateMock)(z.array(z.string()));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw10.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL10}/company/interested-attributes`,
+      resolver
+    );
+  }
+  getCompanyInterestedAttributes.generateData = () => (0, import_zod_mock9.generateMock)(z.array(z.string()));
+  return {
+    getAllAttributes,
+    getAllAttributesByCompany,
+    getAttributesExtensiveInfo,
+    getAttributeValidValues,
+    getCompanyInterestedAttributes
+  };
+}
+
+// lib/spreadsheetTemplate/mockHandlers.ts
+var import_msw11 = require("msw");
+
+// lib/spreadsheetTemplate/index.ts
+var BASE_URL11 = "templates";
+
+// lib/spreadsheetTemplate/mockHandlers.ts
+var import_zod_mock10 = require("@anatine/zod-mock");
+function createSpreadsheetTemplateApiHandlers(client) {
+  function getTemplates(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock10.generateMock)(z.array(spreadsheetTemplateSchema));
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw11.rest.get(`${client.getBaseUrl()}/${BASE_URL11}`, resolver);
+  }
+  getTemplates.generateData = () => (0, import_zod_mock10.generateMock)(z.array(spreadsheetTemplateSchema));
+  return {
+    getTemplates
+  };
+}
+
+// lib/companyFeatures/mockHandlers.ts
+var import_zod_mock11 = require("@anatine/zod-mock");
+var import_msw12 = require("msw");
+
+// lib/companyFeatures/index.ts
+var BASE_URL12 = "feature";
+
+// lib/companyFeatures/mockHandlers.ts
+function createCompanyFeaturesApiHandlers(client) {
+  function checkIfStageItemSetupIsEnabled(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock11.generateMock)(z.boolean());
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw12.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL12}/isphaseditemsetupenabled`,
+      resolver
+    );
+  }
+  return {
+    checkIfStageItemSetupIsEnabled
+  };
+}
+
+// lib/featureFlags/mockHandlers.ts
+var import_zod_mock12 = require("@anatine/zod-mock");
+var import_msw13 = require("msw");
+
+// lib/featureFlags/index.ts
+var BASE_URL13 = "feature-flag";
+
+// lib/featureFlags/mockHandlers.ts
+function createFeatureFlagsApiHandlers(client) {
+  function checkEnableItemsApiEndpointsForImports(resolver = (_req, res, ctx) => {
+    const data = (0, import_zod_mock12.generateMock)(z.boolean());
+    return res(ctx.status(200), ctx.json(data));
+  }) {
+    return import_msw13.rest.get(
+      `${client.getBaseUrl()}/${BASE_URL13}/enable-items-api-endpoints-for-imports/`,
+      resolver
+    );
+  }
+  return {
+    checkEnableItemsApiEndpointsForImports
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createAttributesApiHandlers,
   createCategoriesApiHandlers,
+  createCompanyFeaturesApiHandlers,
+  createErrorsApiHandlers,
   createExportsApiHandlers,
+  createFeatureFlagsApiHandlers,
   createImportsApiHandlers,
+  createItemsApiHandlers,
+  createLocaleApiHandlers,
   createProductTypesApiHandlers,
-  createTradingPartnerAccessApiHandlers
+  createSpreadsheetTemplateApiHandlers,
+  createTradingPartnerAccessApiHandlers,
+  createWhoAmIApiHandlers
 });