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

package/dist/index.cjs

@@ -32,65 +32,24 @@ var lib_exports = {};
 __export(lib_exports, {
   AsstClient: () => AsstClient,
   BASE_URLS: () => BASE_URLS,
+  createAttributesApi: () => createAttributesApi,
   createCategoriesApi: () => createCategoriesApi,
+  createCompanyFeaturesApi: () => createCompanyFeaturesApi,
+  createErrorsApi: () => createErrorsApi,
   createExportsApi: () => createExportsApi,
+  createFeatureFlagsApi: () => createFeatureFlagsApi,
   createImportsApi: () => createImportsApi,
+  createItemsApi: () => createItemsApi,
+  createLocaleApi: () => createLocaleApi,
   createProductTypesApi: () => createProductTypesApi,
-  createTradingPartnerAccessApi: () => createTradingPartnerAccessApi
+  createSpreadsheetTemplateApi: () => createSpreadsheetTemplateApi,
+  createTradingPartnerAccessApi: () => createTradingPartnerAccessApi,
+  createWhoAmIApi: () => createWhoAmIApi
 });
 module.exports = __toCommonJS(lib_exports);
 
 // lib/asstClient.ts
 var import_ky_universal = __toESM(require("ky-universal"), 1);
-var BASE_URLS = {
-  local: "https://localhost:8443",
-  test: "https://integration.api.spscommerce.com/assortment/gateway",
-  prod: "https://api.spscommerce.com/assortment/gateway"
-};
-var AsstClient = class {
-  #client = import_ky_universal.default.create({
-    prefixUrl: BASE_URLS["test"],
-    retry: 0
-  });
-  #baseUrl = BASE_URLS["test"];
-  #subscriptionCallback;
-  constructor(options) {
-    this.updateConfig(options);
-  }
-  updateConfig(options) {
-    this.#client = this.#client.extend(options);
-    if (options.prefixUrl) {
-      this.#baseUrl = options.prefixUrl;
-    }
-    if (this.#subscriptionCallback) {
-      this.#subscriptionCallback(options);
-    }
-  }
-  getBaseUrl() {
-    return this.#baseUrl;
-  }
-  subscribeToConfigChange(subscriptionCallback) {
-    this.#subscriptionCallback = subscriptionCallback;
-  }
-  get(url, options) {
-    return this.#client.get(url, options);
-  }
-  post(url, options) {
-    return this.#client.post(url, options);
-  }
-  put(url, options) {
-    return this.#client.put(url, options);
-  }
-  patch(url, options) {
-    return this.#client.patch(url, options);
-  }
-  head(url, options) {
-    return this.#client.head(url, options);
-  }
-  delete(url, options) {
-    return this.#client.delete(url, options);
-  }
-};
 
 // ../../node_modules/.pnpm/zod@3.21.4/node_modules/zod/lib/index.mjs
 var util;
@@ -3774,13 +3733,80 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodError
 });
 
+// lib/asstClient.ts
+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
+};
+var AsstClient = class {
+  #client = import_ky_universal.default.create(initialConfig);
+  #baseUrl = BASE_URLS["test"];
+  #listeners = /* @__PURE__ */ new Set();
+  #currentConfig = initialConfig;
+  constructor(options) {
+    if (options) {
+      this.updateConfig(options);
+    }
+  }
+  updateConfig(options) {
+    this.#client = this.#client.extend(options);
+    this.#currentConfig = options;
+    if (options.prefixUrl) {
+      this.#baseUrl = options.prefixUrl;
+    }
+    this.#listeners.forEach((listener) => listener(options));
+  }
+  getBaseUrl() {
+    return this.#baseUrl;
+  }
+  /**
+   * Subscribe to config changes.  The callback will be immediately invoked with the current config.
+   * @param subscriptionCallback Function that will be called with the new config every time it is changed
+   * @returns Function to unsubscribe to config changes
+   */
+  subscribeToConfigChange(listener) {
+    this.#listeners.add(listener);
+    listener(this.#currentConfig);
+    return () => this.#listeners.delete(listener);
+  }
+  get(url, options) {
+    return this.#client.get(url, options);
+  }
+  post(url, options) {
+    return this.#client.post(url, options);
+  }
+  put(url, options) {
+    return this.#client.put(url, options);
+  }
+  patch(url, options) {
+    return this.#client.patch(url, options);
+  }
+  head(url, options) {
+    return this.#client.head(url, options);
+  }
+  delete(url, options) {
+    return this.#client.delete(url, options);
+  }
+};
+
 // 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()
 });
@@ -3793,7 +3819,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()
@@ -3819,15 +3845,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
@@ -3847,7 +3873,6 @@ var generateImportTemplateParamsSchema = z.object({
 });
 
 // lib/imports/index.ts
-var import_query_string = __toESM(require("query-string"), 1);
 var BASE_URL = "imports";
 function createImportsApi(client) {
   async function getImportErrors(importId, params, signal) {
@@ -3873,15 +3898,12 @@ function createImportsApi(client) {
     return z.array(vendorPartnerAttGroupsSchema).parse(data);
   }
   async function generateImportTemplate(params) {
-    const searchParams = params ? import_query_string.default.stringify(params, {
-      arrayFormat: "comma",
-      skipEmptyString: true
-    }) : void 0;
     const response = await client.get(`${BASE_URL}/template/generate`, {
-      searchParams,
+      searchParams: params,
       headers: {
         Accept: "application/octet-stream"
-      }
+      },
+      timeout: false
     });
     const disposition = response.headers.get("content-disposition") || "";
     const filename = disposition.match(/filename="(.+)"/)?.[1];
@@ -3908,13 +3930,38 @@ function createImportsApi(client) {
 }
 
 // lib/exports/index.ts
-var BASE_URL2 = "v2/exports";
+var BASE_URL2 = "exports";
+var BASE_URL_V2 = "v2/exports";
 function createExportsApi(client) {
   async function createExport(data) {
-    await client.post(`${BASE_URL2}/add`, { json: data });
+    await client.post(`${BASE_URL_V2}/add`, { json: data });
+  }
+  async function downloadItems(params) {
+    const searchParams = { ...params, ids: params.ids.join(",") };
+    const response = await client.get(`${BASE_URL2}/spreadsheet/by-item`, {
+      searchParams,
+      headers: {
+        Accept: "application/octet-stream"
+      },
+      timeout: false
+    });
+    const disposition = response.headers.get("content-disposition") || "";
+    const filename = disposition.match(/filename="(.+)"/)?.[1];
+    const downloadUrl = window.URL.createObjectURL(
+      new Blob([await response.blob()])
+    );
+    const link = document.createElement("a");
+    link.href = downloadUrl;
+    if (filename) {
+      link.download = filename;
+    }
+    document.body.appendChild(link);
+    link.click();
+    link.remove();
   }
   return {
-    createExport
+    createExport,
+    downloadItems
   };
 }
 
@@ -3931,11 +3978,10 @@ var attrProdTypeSchema = z.object({
 });
 
 // lib/productTypes/index.ts
-var import_query_string2 = __toESM(require("query-string"), 1);
 var BASE_URL3 = "product-types";
 function createProductTypesApi(client) {
   async function getProductTypes(params, signal) {
-    const searchParams = params ? import_query_string2.default.stringify(params, { arrayFormat: "comma" }) : void 0;
+    const searchParams = params ? { retailerIds: params.retailerIds.join(",") } : void 0;
     const data = await client.get(`${BASE_URL3}/all`, {
       searchParams,
       signal
@@ -3950,9 +3996,10 @@ function createProductTypesApi(client) {
 // 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
@@ -3985,13 +4032,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
@@ -4000,6 +4047,30 @@ 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_URL5 = "categories";
 function createCategoriesApi(client) {
@@ -4011,28 +4082,874 @@ function createCategoriesApi(client) {
     return itemCategoriesSearchSchema.parse(data);
   }
   async function getProductCodes(params, signal) {
+    const searchParams = { type: "PRODUCT_CODE" };
+    if (params?.categoryName) {
+      searchParams.categoryName = params.categoryName;
+    }
+    if (params?.catalogId) {
+      searchParams.catalogId = params.catalogId;
+    }
+    if (params?.selectionCodeId) {
+      searchParams.selectionCodeId = params.selectionCodeId;
+    }
     const data = await client.get(`${BASE_URL5}/search-category`, {
-      searchParams: { ...params, type: "PRODUCT_CODE" },
-      signal
+      searchParams,
+      signal,
+      timeout: false
     }).json();
     return itemCategoriesSearchSchema.parse(data);
   }
   async function getSelectionCodes(params, signal) {
+    const searchParams = { type: "SELECTION_CODE" };
+    if (params?.categoryName) {
+      searchParams.categoryName = params.categoryName;
+    }
+    if (params?.catalogId) {
+      searchParams.catalogId = params.catalogId;
+    }
     const data = await client.get(`${BASE_URL5}/search-category`, {
-      searchParams: { ...params, type: "SELECTION_CODE" },
+      searchParams,
       signal
     }).json();
     return itemCategoriesSearchSchema.parse(data);
   }
-  return { getCatalogs, getProductCodes, getSelectionCodes };
+  async function getItemHierarchy(itemIds) {
+    const data = await client.post(`${BASE_URL5}/item-hierarchy`, { json: { itemIds } }).json();
+    return itemHierarchyResponseSchema.parse(data);
+  }
+  return { getCatalogs, getProductCodes, getSelectionCodes, getItemHierarchy };
+}
+
+// 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/attributes/index.ts
+var BASE_URL6 = "attributes";
+function createAttributesApi(client) {
+  async function getAllAttributes(signal) {
+    const data = await client.get(`${BASE_URL6}`, { signal }).json();
+    return z.array(attributeMetaDataSchema).parse(data);
+  }
+  async function getAllAttributesByCompany(params, signal) {
+    const data = await client.get(`${BASE_URL6}/company`, {
+      searchParams: params,
+      signal
+    }).json();
+    return attributesByCompanySchema.parse(data);
+  }
+  async function getAttributesExtensiveInfo(signal) {
+    const data = await client.get(`${BASE_URL6}/registry/editui`, { signal }).json();
+    return z.array(attributeDefinitionSchema).parse(data);
+  }
+  async function getAttributeValidValues(attributeDbName, signal) {
+    const data = await client.get(`${BASE_URL6}/registry/attribute/${attributeDbName}/values`, {
+      signal
+    }).json();
+    return z.array(attributeValidValuesSchema).parse(data);
+  }
+  async function getCompanyInterestedAttributes(signal) {
+    const data = await client.get(`${BASE_URL6}/company/interested-attributes`, { signal }).json();
+    return z.array(z.string()).parse(data);
+  }
+  return {
+    getAllAttributes,
+    getAllAttributesByCompany,
+    getAttributesExtensiveInfo,
+    getAttributeValidValues,
+    getCompanyInterestedAttributes
+  };
+}
+
+// lib/locale/models/Locale.ts
+var localeSchema = z.object({
+  localeCode: z.string(),
+  localeDescription: z.string()
+});
+
+// lib/locale/index.ts
+var BASE_URL7 = "locale";
+function createLocaleApi(client) {
+  async function getLocale(signal) {
+    const data = await client.get(`${BASE_URL7}`, { signal }).json();
+    return z.array(localeSchema).parse(data);
+  }
+  return {
+    getLocale
+  };
+}
+
+// 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/spreadsheetTemplate/index.ts
+var BASE_URL8 = "templates";
+function createSpreadsheetTemplateApi(client) {
+  async function getTemplates(signal) {
+    const data = await client.get(`${BASE_URL8}`, { signal }).json();
+    return z.array(spreadsheetTemplateSchema).parse(data);
+  }
+  return {
+    getTemplates
+  };
+}
+
+// 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_URL9 = "whoami";
+function createWhoAmIApi(client) {
+  async function whoAmI(signal) {
+    const data = await client.get(`${BASE_URL9}`, { signal }).json();
+    return userAccountSchema.parse(data);
+  }
+  return {
+    whoAmI
+  };
+}
+
+// lib/companyFeatures/index.ts
+var BASE_URL10 = "feature";
+function createCompanyFeaturesApi(client) {
+  async function checkIfStageItemSetupIsEnabled(signal) {
+    const data = await client.get(`${BASE_URL10}/isphaseditemsetupenabled`, {
+      signal
+    }).json();
+    return z.boolean().parse(data);
+  }
+  return {
+    checkIfStageItemSetupIsEnabled
+  };
+}
+
+// lib/featureFlags/index.ts
+var BASE_URL11 = "feature-flag";
+function createFeatureFlagsApi(client) {
+  async function checkEnableItemsApiEndpointsForImports(signal) {
+    const data = await client.get(`${BASE_URL11}/enable-items-api-endpoints-for-imports/`, {
+      signal
+    }).json();
+    return z.boolean().parse(data);
+  }
+  return {
+    checkEnableItemsApiEndpointsForImports
+  };
+}
+
+// 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/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/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/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/items/index.ts
+var BASE_URL12 = "items";
+function createItemsApi(client) {
+  async function searchItems(params, signal) {
+    const searchParams = params ? `limit=${params.limit}&offset=${params.offset}` + (params.url ? `&${params.url}` : "") : void 0;
+    const data = await client.get(`${BASE_URL12}`, { searchParams, signal }).json();
+    return itemSearchViewSchema.parse(data);
+  }
+  async function getItem(itemId, locale = "en-US", signal) {
+    const data = await client.get(`${BASE_URL12}/${itemId}`, { searchParams: { locale }, signal }).json();
+    return itemDetailViewSchema.parse(data);
+  }
+  async function updateItem(itemId, item) {
+    await client.put(`${BASE_URL12}/details/${itemId}`, { json: { ...item } }).json();
+  }
+  async function deleteItem(itemId) {
+    await client.delete(`${BASE_URL12}/${itemId}`);
+  }
+  async function deleteItems(itemIds) {
+    const params = new URLSearchParams();
+    itemIds.forEach((id) => {
+      params.append("items", id);
+    });
+    await client.delete(`${BASE_URL12}`, { searchParams: params });
+  }
+  async function getItemInfoId(spsItemId, signal) {
+    const data = await client.get(`${BASE_URL12}/${spsItemId}/itemInfoId`, { signal }).json();
+    return z.number().parse(data);
+  }
+  async function getSpsItemId(itemInfoId, signal) {
+    const data = await client.get(`${BASE_URL12}/${itemInfoId}/spsItemId`, { signal }).json();
+    return spsItemIdResponseSchema.parse(data);
+  }
+  async function getItemStatus(itemIds) {
+    const data = await client.post(`${BASE_URL12}/status`, { json: { itemIds } }).json();
+    return itemStatusResponseSchema.parse(data);
+  }
+  return {
+    searchItems,
+    getItem,
+    updateItem,
+    deleteItem,
+    deleteItems,
+    getItemInfoId,
+    getSpsItemId,
+    getItemStatus
+  };
+}
+
+// lib/errors/index.ts
+var BASE_URL13 = "errors";
+function createErrorsApi(client) {
+  async function getInvalidItemErrorDetails(itemInfoId, signal) {
+    const data = await client.get(`${BASE_URL13}/items/${itemInfoId}`, {
+      signal
+    }).json();
+    return itemErrorDetailsResultSchema.parse(data);
+  }
+  return {
+    getInvalidItemErrorDetails
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AsstClient,
   BASE_URLS,
+  createAttributesApi,
   createCategoriesApi,
+  createCompanyFeaturesApi,
+  createErrorsApi,
   createExportsApi,
+  createFeatureFlagsApi,
   createImportsApi,
+  createItemsApi,
+  createLocaleApi,
   createProductTypesApi,
-  createTradingPartnerAccessApi
+  createSpreadsheetTemplateApi,
+  createTradingPartnerAccessApi,
+  createWhoAmIApi
 });