@spscommerce/asst-api 5.3.0 → 5.3.3

package/dist/chunk-ATHXI7QZ.js

@@ -0,0 +1,1049 @@
+// lib/imports/models/ImportDetail.ts
+import { z } from "zod";
+var importDetailSchema = z.object({
+  completedAt: z.number().nullish(),
+  errorCount: z.number(),
+  importId: z.number(),
+  name: z.string(),
+  startedAt: z.string().nullish(),
+  status: z.string(),
+  uploadedAt: z.string()
+});
+
+// lib/imports/models/Import.ts
+import { z as z2 } from "zod";
+var importSchema = z2.object({
+  count: z2.number(),
+  imports: z2.array(importDetailSchema)
+});
+
+// lib/imports/models/ImportError.ts
+import { z as z3 } from "zod";
+var importErrorSchema = z3.object({
+  attribute: z3.string().nullish(),
+  description: z3.string(),
+  importErrorId: z3.number(),
+  row: z3.number()
+});
+
+// lib/imports/models/ImportErrors.ts
+import { z as z4 } from "zod";
+var importErrorsSchema = z4.object({
+  count: z4.number(),
+  errors: z4.array(importErrorSchema),
+  hasNext: z4.boolean(),
+  importId: z4.number(),
+  totalCount: z4.number()
+});
+
+// lib/imports/models/ImportsStatusEnum.ts
+import { z as z5 } from "zod";
+var importStatusEnumSchema = z5.enum([
+  "QUEUED_FOR_IMPORT",
+  "IN_PROGRESS",
+  "DOC_FAILED",
+  "VALIDATION_FAILED",
+  "COMPLETED"
+]);
+
+// lib/imports/models/ImportsStatus.ts
+import { z as z6 } from "zod";
+var importsStatusSchema = z6.object({
+  completedAt: z6.string().nullish(),
+  docInEventId: z6.string().nullish(),
+  errorCount: z6.number().nullish(),
+  importId: z6.number(),
+  invalidItemCount: z6.number().nullish(),
+  name: z6.string().nullish(),
+  status: importStatusEnumSchema,
+  totalItemCount: z6.number().nullish(),
+  validItemCount: z6.number().nullish()
+});
+
+// lib/imports/models/VendorPartnerAttGroups.ts
+import { z as z7 } from "zod";
+var vendorPartnerAttGroupsSchema = z7.object({
+  partnerCompanyId: z7.number(),
+  partnerCompanyName: z7.string(),
+  partnerAttributeGroups: z7.array(z7.number())
+});
+
+// lib/imports/models/GenerateImportTemplateParams.ts
+import { z as z9 } from "zod";
+
+// lib/_common/ApplicationType.ts
+import { z as z8 } from "zod";
+var applicationTypeSchema = z8.enum(["ASSORTMENT", "ITEM-XREF", "TEST-ORDER-GENERATOR"]);
+
+// lib/imports/models/GenerateImportTemplateParams.ts
+var generateImportTemplateParamsSchema = z9.object({
+  "multi-sheet": z9.boolean(),
+  callingApplicationType: applicationTypeSchema.optional(),
+  gids: z9.string().optional(),
+  groupTypeId: z9.number().optional(),
+  includeGuides: z9.boolean().optional(),
+  productTypeIds: z9.string().optional()
+});
+
+// lib/productTypes/models/AttrProdType.ts
+import { z as z10 } from "zod";
+var attrProdTypeSchema = z10.object({
+  attrProdTypeId: z10.number(),
+  productType: z10.string(),
+  description: z10.string(),
+  createdDate: z10.number(),
+  createdBy: z10.string(),
+  modifiedDate: z10.number().optional(),
+  modifiedBy: z10.string().optional(),
+  retailerId: z10.number().optional()
+});
+
+// lib/productTypes/models/PagedResults.ts
+import { z as z11 } from "zod";
+function pagedResultsSchema(resultsType) {
+  return z11.object({
+    next: z11.string(),
+    previous: z11.string(),
+    count: z11.number(),
+    results: z11.array(resultsType)
+  });
+}
+
+// lib/tradingPartners/models/Connection.ts
+import { z as z12 } from "zod";
+var connectionSchema = z12.object({
+  catalog_id: z12.number(),
+  catalog_name: z12.string().nullable(),
+  partner_company_name: z12.string(),
+  partner_company_id: z12.number(),
+  partner_org_id: z12.string()
+});
+
+// lib/tradingPartners/models/CompanyRelationshipUpsertBody.ts
+import { z as z13 } from "zod";
+var companyRelationshipUpsertBodySchema = z13.object({
+  supplierId: z13.number(),
+  retailerId: z13.number(),
+  catalogId: z13.number(),
+  active: z13.boolean(),
+  applicationType: z13.array(applicationTypeSchema).default([])
+});
+
+// lib/tradingPartners/models/ItemPartner.ts
+import { z as z14 } from "zod";
+var itemPartnerSchema = z14.object({
+  itemPartnerId: z14.number(),
+  retailerId: z14.number(),
+  supplierId: z14.number(),
+  catalogId: z14.number(),
+  isActive: z14.number(),
+  createdDate: z14.string(),
+  modifiedDate: z14.string(),
+  applications: z14.array(applicationTypeSchema)
+});
+
+// lib/companies/models/CompanyType.ts
+import { z as z15 } from "zod";
+var companyTypeSchema = z15.enum(["SUPPLIER", "RETAILER"]);
+
+// lib/tradingPartners/models/TradingPartnerAccessByCompanyId.ts
+import { z as z16 } from "zod";
+var tradingPartnerAccessByCompanyIdSchema = z16.object({
+  companyId: z16.number(),
+  companyTypes: z16.array(companyTypeSchema),
+  identityOrgId: z16.string(),
+  companyName: z16.string(),
+  count: z16.number(),
+  connections: z16.array(connectionSchema)
+});
+
+// lib/categories/models/ItemCategory.ts
+import { z as z17 } from "zod";
+var categoryTypeSchema = z17.enum(["CATALOG", "SELECTION_CODE", "PRODUCT_CODE", "EXPORT"]);
+var PRODUCT_CODE_DEFAULT_VALUE = "DEFAULT";
+var SELECTION_CODE_DEFAULT_VALUE = "000";
+var itemCategorySchema = z17.object({
+  categoryid: z17.number(),
+  encodedCategoryId: z17.string(),
+  companyId: z17.number(),
+  name: z17.string(),
+  isActive: z17.number(),
+  createdDate: z17.number().nullish(),
+  categorytimestamp: z17.number().nullish(),
+  typeId: z17.number(),
+  type: categoryTypeSchema,
+  categorykey: z17.string().nullish(),
+  description: z17.string().nullish(),
+  categoryCatalogName: z17.string().nullish()
+});
+
+// lib/categories/models/ItemCategoriesSearch.ts
+import { z as z18 } from "zod";
+var itemCategoriesSearchSchema = z18.object({
+  count: z18.number(),
+  data: z18.array(itemCategorySchema)
+});
+
+// lib/categories/models/ItemHierarchyResponse.ts
+import { z as z19 } from "zod";
+var baseHierarchySchema = z19.object({
+  id: z19.string(),
+  name: z19.string().nullish(),
+  description: z19.string().nullish(),
+  type: z19.string().nullish()
+});
+var hierarchySchema = baseHierarchySchema.extend({
+  child: z19.lazy(() => hierarchySchema).nullable()
+});
+var itemHierarchyResponseSchema = z19.object({
+  itemHierarchies: z19.array(
+    z19.object({
+      itemId: z19.string(),
+      hierarchies: z19.array(hierarchySchema)
+    })
+  )
+});
+
+// lib/categories/models/CatalogManagement.ts
+import { z as z20 } from "zod";
+var catalogCreateRequestSchema = z20.object({
+  type: z20.string(),
+  name: z20.string(),
+  companyId: z20.number()
+});
+var catalogCreateResponseSchema = z20.object({
+  categoryid: z20.number()
+});
+var catalogSearchParamsSchema = z20.object({
+  ownerCompanyIds: z20.array(z20.number()).optional(),
+  searchTerms: z20.string().optional(),
+  categoryType: z20.literal("CATALOG")
+});
+var catalogBriefResponseSchema = z20.object({
+  categoryId: z20.number(),
+  categoryName: z20.string(),
+  categoryDescription: z20.string(),
+  categoryDescriptionExt: z20.string(),
+  ownerCompanyId: z20.string(),
+  categoryTypeId: z20.number(),
+  createdAt: z20.string(),
+  modifiedAt: z20.string(),
+  createdBy: z20.string(),
+  modifiedBy: z20.string()
+});
+
+// lib/locale/models/Locale.ts
+import { z as z21 } from "zod";
+var localeSchema = z21.object({
+  localeCode: z21.string(),
+  localeDescription: z21.string()
+});
+
+// lib/spreadsheetTemplate/models/SpreadsheetTemplateCompany.ts
+import { z as z22 } from "zod";
+var spreadsheetTemplateCompanySchema = z22.object({
+  companyName: z22.string(),
+  companyId: z22.number(),
+  createdAt: z22.number()
+});
+
+// lib/spreadsheetTemplate/models/SpreadsheetTemplate.ts
+import { z as z23 } from "zod";
+var spreadsheetTemplateSchema = z23.object({
+  id: z23.number(),
+  fileLocation: z23.string(),
+  name: z23.string(),
+  templateType: z23.string(),
+  maxItemsPerDoc: z23.number(),
+  companies: z23.array(spreadsheetTemplateCompanySchema),
+  createdBy: z23.string().nullish(),
+  createdAt: z23.number().nullish(),
+  modifiedBy: z23.string().nullish(),
+  modifiedAt: z23.number().nullish()
+});
+
+// lib/whoami/models/IdentityServiceDatetimePreferences.ts
+import { z as z24 } from "zod";
+var identityServiceDatetimePreferencesSchema = z24.object({
+  DATE_TIME: z24.string(),
+  TIME: z24.string(),
+  SHORT_DATE: z24.string(),
+  LONG_DATETIME: z24.string(),
+  LONG_TIME: z24.string(),
+  DATE: z24.string()
+});
+
+// lib/whoami/models/IdentityServiceOrganizationMetadata.ts
+import { z as z25 } from "zod";
+var identityServiceOrganizationMetadataSchema = z25.object({
+  namespace: z25.string(),
+  key: z25.string(),
+  value: z25.string()
+});
+
+// lib/whoami/models/IdentityServiceOrganization.ts
+import { z as z26 } from "zod";
+var identityServiceOrganizationSchema = z26.object({
+  organization_name: z26.string().optional(),
+  organization_site: z26.string().optional(),
+  namespace: z26.string().optional(),
+  id: z26.string(),
+  permissions: z26.array(z26.string()).optional(),
+  metadata: identityServiceOrganizationMetadataSchema.optional()
+});
+
+// lib/whoami/models/IdentityServicePreferences.ts
+import { z as z27 } from "zod";
+var identityServicePreferencesSchema = z27.object({
+  locale: z27.string(),
+  timezone: z27.string(),
+  cpUpgrade: z27.string().optional(),
+  language: z27.array(z27.string()),
+  datetime: identityServiceDatetimePreferencesSchema
+});
+
+// lib/whoami/models/IdentityServiceUser.ts
+import { z as z28 } from "zod";
+var identityServiceUserSchema = z28.object({
+  id: z28.string(),
+  email: z28.string().optional(),
+  first_name: z28.string().optional(),
+  last_name: z28.string().optional(),
+  job_title: z28.string().optional(),
+  externally_managed: z28.boolean().optional(),
+  city: z28.string().optional(),
+  name: z28.string(),
+  state: z28.string().optional(),
+  country: z28.string().optional(),
+  user_type: z28.string().optional(),
+  token_type: z28.string().optional(),
+  avatar_image_id: z28.string().optional(),
+  avatar_image_url: z28.string().optional(),
+  origin_avatar_image_id: z28.string().optional(),
+  bio: z28.string().optional(),
+  phone_number: z28.string().optional(),
+  twitter_handle: z28.string().optional(),
+  linkedin_url: z28.string().optional(),
+  description: z28.string().optional(),
+  preferences: identityServicePreferencesSchema.optional(),
+  roles: z28.array(z28.string()),
+  organization: identityServiceOrganizationSchema,
+  password: z28.string(),
+  verified: z28.boolean()
+});
+
+// lib/whoami/models/RegisteredService.ts
+import { z as z29 } from "zod";
+var registeredServiceSchema = z29.object({
+  serviceId: z29.number(),
+  identityServiceId: z29.number(),
+  name: z29.string(),
+  isActive: z29.boolean()
+});
+
+// lib/whoami/models/UserAccount.ts
+import { z as z30 } from "zod";
+var userAccountSchema = z30.object({
+  identityUser: identityServiceUserSchema,
+  companyId: z30.number(),
+  companyName: z30.string(),
+  name: z30.string(),
+  assortmentPartnerCompanyId: z30.number().nullish(),
+  retailer: z30.boolean(),
+  supplier: z30.boolean(),
+  registeredService: registeredServiceSchema,
+  uniqueAttributes: z30.array(z30.string()),
+  admin: z30.boolean(),
+  adminToolUser: z30.boolean(),
+  attributeRegistryAdmin: z30.boolean(),
+  attributeRegistryDev: z30.boolean(),
+  attributeRegistryRsx: z30.boolean(),
+  attributeRegistryUser: z30.boolean(),
+  attributeRegistryViewer: z30.boolean()
+});
+
+// lib/items/v1/models/ItemHeader.ts
+import { z as z31 } from "zod";
+var itemHeaderSchema = z31.object({
+  status: z31.string().optional(),
+  catalogName: z31.string(),
+  productCodeName: z31.string(),
+  selectionCodeName: z31.string(),
+  gtin: z31.string(),
+  upc: z31.string(),
+  ean: z31.string(),
+  isbn: z31.string(),
+  partNumber: z31.string(),
+  lastUpdatedDateString: z31.string(),
+  companyId: z31.string(),
+  itemInfoId: z31.string()
+});
+
+// lib/items/v1/models/PhaseEnum.ts
+import { z as z32 } from "zod";
+var phaseEnumSchema = z32.enum([
+  "CORE",
+  "CORE_PLUS",
+  "CORE_ADVANCED",
+  "ENRICHED",
+  "STANDARD_REQUIREMENTS"
+]);
+
+// lib/items/v1/models/TradingPartnerStage.ts
+import { z as z33 } from "zod";
+var tradingPartnerStageSchema = z33.object({
+  companyId: z33.number(),
+  companyName: z33.string(),
+  stage: z33.nullable(phaseEnumSchema),
+  isValid: z33.boolean()
+});
+
+// lib/items/v1/models/ItemMap.ts
+import { z as z34 } from "zod";
+var itemMapSchema = z34.object({
+  rn: z34.number().optional(),
+  iteminfoid: z34.string(),
+  tradingPartnerStages: z34.array(tradingPartnerStageSchema).optional(),
+  gtin: z34.string().nullish(),
+  catalogname: z34.string().nullish(),
+  isbn: z34.string().nullish(),
+  lastupdateddatestring: z34.string().nullish(),
+  upc: z34.string().nullish(),
+  productcodename: z34.string().nullish(),
+  ean: z34.string().nullish(),
+  selectioncodename: z34.string().nullish(),
+  createddatestring: z34.string().nullish(),
+  partnumber: z34.string().nullish(),
+  consumeravailabledatestring: z34.string().nullish(),
+  status: z34.string().nullish(),
+  nrfcolorcode: z34.array(z34.string()).nullish(),
+  nrfsizecode: z34.array(z34.string()).nullish(),
+  productcolordescription: z34.array(z34.string()).nullish(),
+  productsizedescription: z34.array(z34.string()).nullish()
+}).passthrough();
+
+// lib/items/v1/models/ItemTable.ts
+import { z as z35 } from "zod";
+var itemTableSchema = z35.object({
+  headers: itemHeaderSchema,
+  itemMaps: z35.array(itemMapSchema)
+});
+
+// lib/items/v1/models/ItemSearchView.ts
+import { z as z36 } from "zod";
+var itemSearchViewSchema = z36.object({
+  itemTable: itemTableSchema,
+  hasNext: z36.boolean(),
+  count: z36.number()
+});
+
+// lib/items/v1/models/AttributeDetail.ts
+import { z as z38 } from "zod";
+
+// lib/items/v1/models/AttrDatatypeNameEnum.ts
+import { z as z37 } from "zod";
+var attrDatatypeNameEnumSchema = z37.enum([
+  "TEXT",
+  "SET",
+  "INTEGER",
+  "FLOAT",
+  "BOOLEAN",
+  "DATE",
+  "KEYVALUE",
+  "REFERENCE",
+  // Not used anymore
+  "STRING",
+  "REAL"
+]);
+
+// lib/items/v1/models/AttributeDetail.ts
+var attributeDetailSchema = z38.object({
+  type: attrDatatypeNameEnumSchema,
+  name: z38.string(),
+  value: z38.string().or(z38.number()).or(z38.array(z38.string())).or(z38.array(z38.number())).nullable(),
+  label: z38.string(),
+  group: z38.string(),
+  orderBy: z38.number().or(z38.string()).nullish()
+});
+
+// lib/items/v1/models/CategoryEnum.ts
+import { z as z39 } from "zod";
+var categoryEnumSchema = z39.enum([
+  "ALIAS",
+  "CATALOG",
+  "EXPORT",
+  "LEGACY_PRODUCT_TYPE",
+  "PRODUCT_CLASSIFICATION",
+  "PRODUCT_CODE",
+  "SELECTION_CODE",
+  "TAG",
+  "TAXONOMY_ROOT"
+]);
+
+// lib/items/v1/models/ComponentDetails.ts
+import { z as z40 } from "zod";
+var componentDetailsSchema = z40.object({
+  itemInfoId: z40.number(),
+  description: z40.string().nullish(),
+  saleable: z40.boolean(),
+  valid: z40.boolean(),
+  uniqueCriteria: z40.array(
+    z40.object({
+      name: z40.string(),
+      value: z40.string()
+    })
+  )
+});
+
+// lib/items/v1/models/RepeatableGroup.ts
+import { z as z41 } from "zod";
+var repeatableGroupSchema = z41.object({
+  repeatableGroupId: z41.string(),
+  repeatableNumber: z41.number()
+});
+
+// lib/items/v1/models/GroupedAttributeList.ts
+import { z as z42 } from "zod";
+var groupedAttributeListSchema = z42.object({
+  type: z42.string(),
+  rows: z42.array(z42.array(attributeDetailSchema)),
+  repeatableGroups: z42.array(repeatableGroupSchema)
+});
+
+// lib/items/v1/models/GroupedAttributes.ts
+import { z as z43 } from "zod";
+var groupedAttributesSchema = z43.object({
+  type: z43.string(),
+  attributes: z43.array(attributeDetailSchema),
+  attributeGroups: z43.array(groupedAttributeListSchema)
+});
+
+// lib/items/v1/models/HierarchyCategory.ts
+import { z as z44 } from "zod";
+var hierarchyCategorySchema = z44.object({
+  name: z44.string(),
+  description: z44.string().nullish(),
+  id: z44.number(),
+  companyId: z44.number().nullish(),
+  type: categoryEnumSchema
+});
+
+// lib/items/v1/models/HierarchyDetails.ts
+import { z as z45 } from "zod";
+var hierarchyDetailsSchema = z45.object({
+  catalogs: z45.array(hierarchyCategorySchema),
+  selectionCodes: z45.array(hierarchyCategorySchema),
+  productCodes: z45.array(hierarchyCategorySchema)
+});
+
+// lib/items/v1/models/PackComponentItemInfo.ts
+import { z as z46 } from "zod";
+var packComponentItemInfoSchema = z46.object({
+  companyid: z46.number(),
+  createddate: z46.number(),
+  isServiceApi: z46.boolean(),
+  isactive: z46.number(),
+  isvalid: z46.number(),
+  itemType: z46.string(),
+  iteminfoid: z46.number(),
+  itemtimestamp: z46.number(),
+  serviceId: z46.number(),
+  attributes: z46.record(z46.string(), z46.string().or(z46.array(z46.string())))
+});
+
+// lib/items/v1/models/ItemPrice.ts
+import { z as z47 } from "zod";
+var itemPriceSchema = z47.object({
+  amount: z47.number(),
+  currency: z47.string(),
+  id: z47.number().nullish(),
+  priceDivision: z47.string().nullish(),
+  iteminfoid: z47.number().nullish(),
+  startdate: z47.string().nullish(),
+  enddate: z47.string().nullish(),
+  qualifier: z47.string(),
+  region: z47.string().nullish(),
+  regionqualifier: z47.string().nullish(),
+  regiondescription: z47.string().nullish(),
+  partnercompanyid: z47.string().nullish(),
+  itempricetimestamp: z47.number().nullish(),
+  range_type: z47.string().nullish(),
+  date_range_type: z47.string().nullish(),
+  min_range: z47.number().nullish(),
+  gtin: z47.string().nullish(),
+  priceConditionDescription: z47.string().nullish(),
+  priceUnitQuantity: z47.number().nullish(),
+  priceUnitQuantityUOM: z47.string().nullish()
+});
+
+// lib/items/v1/models/PackComponentDetails.ts
+import { z as z48 } from "zod";
+var packComponentDetailsSchema = z48.object({
+  itemInfo: packComponentItemInfoSchema,
+  itemPrices: z48.array(itemPriceSchema)
+});
+
+// lib/items/v1/models/GroupedItem.ts
+import { z as z49 } from "zod";
+var groupedItemSchema = z49.object({
+  iteminfoid: z49.number(),
+  companyid: z49.number(),
+  status: z49.string(),
+  createdDate: z49.string(),
+  lastUpdatedDate: z49.string(),
+  identifiers: z49.record(z49.string(), z49.any()),
+  hierarchyDetails: hierarchyDetailsSchema,
+  groupedAttributes: z49.array(groupedAttributesSchema),
+  packComponentDetails: z49.array(packComponentDetailsSchema),
+  childComponentDetails: z49.array(componentDetailsSchema),
+  parentComponentDetails: z49.array(componentDetailsSchema),
+  locales: z49.array(z49.string())
+});
+
+// lib/items/v1/models/ItemDetailView.ts
+import { z as z50 } from "zod";
+var itemDetailViewSchema = z50.object({
+  item: groupedItemSchema
+});
+
+// lib/items/v1/models/Bulb.ts
+import { z as z51 } from "zod";
+var bulbSchema = z51.object({
+  iteminfoid: z51.number(),
+  id: z51.number(),
+  shape: z51.string(),
+  position: z51.number(),
+  quantity: z51.number(),
+  basetype: z51.string(),
+  maxwatt: z51.number(),
+  createdat: z51.string(),
+  modifiedat: z51.string(),
+  bulbtype: z51.string(),
+  bulbincluded: z51.string(),
+  bulbsize: z51.string(),
+  replacementbulb: z51.string(),
+  threewaybulb: z51.string()
+});
+
+// lib/items/v1/models/PackComponent.ts
+import { z as z52 } from "zod";
+var packComponentSchema = z52.object({
+  itemInfoId: z52.number().nullish(),
+  attributes: z52.record(z52.string(), z52.string().or(z52.array(z52.string()))),
+  prices: z52.array(itemPriceSchema)
+});
+
+// lib/items/v1/models/MediaItem.ts
+import { z as z53 } from "zod";
+var mediaItemSchema = z53.object({
+  id: z53.number(),
+  iteminfoid: z53.number(),
+  medianame: z53.string(),
+  height: z53.number().nullish(),
+  filename: z53.string(),
+  mediafilename: z53.string().nullish(),
+  description: z53.string().nullish(),
+  filesize: z53.number().nullish(),
+  format: z53.string().nullish(),
+  orientation: z53.string().nullish(),
+  pixeldensity: z53.string().nullish(),
+  purpose: z53.string().nullish(),
+  width: z53.number().nullish(),
+  mediatype: z53.string(),
+  mediaviewtype: z53.string().nullish(),
+  compressionquality: z53.string().nullish(),
+  thumbnailflag: z53.string().nullish()
+});
+
+// lib/items/v1/models/ItemDetail.ts
+import { z as z54 } from "zod";
+var itemDetailSchema = z54.object({
+  attributes: z54.record(z54.string(), z54.any()),
+  clusters: z54.record(
+    z54.string(),
+    z54.array(
+      z54.object({
+        itemInfoAttributes: z54.record(
+          z54.string(),
+          z54.string().or(z54.number()).or(z54.boolean())
+        )
+      })
+    )
+  ),
+  prices: z54.array(itemPriceSchema),
+  bulbs: z54.array(bulbSchema),
+  media: z54.array(mediaItemSchema),
+  packs: z54.array(packComponentSchema)
+});
+
+// lib/items/v1/models/SpsItemIdResponse.ts
+import { z as z55 } from "zod";
+var spsItemIdResponseSchema = z55.object({
+  id: z55.string(),
+  ref: z55.string()
+});
+
+// lib/items/v1/models/ItemStatusResponse.ts
+import { z as z58 } from "zod";
+
+// lib/items/v1/models/ItemStatus.ts
+import { z as z57 } from "zod";
+
+// lib/items/v1/models/ItemOrgStatus.ts
+import { z as z56 } from "zod";
+var itemOrgStatusSchema = z56.object({
+  org: z56.object({
+    ref: z56.string(),
+    id: z56.string(),
+    name: z56.string()
+  }),
+  lowestInvalidStage: phaseEnumSchema.nullable(),
+  validForRelationship: z56.boolean()
+});
+
+// lib/items/v1/models/ItemStatus.ts
+var itemStatusSchema = z57.object({
+  itemId: z57.string(),
+  itemOrgStatuses: z57.array(itemOrgStatusSchema)
+});
+
+// lib/items/v1/models/ItemStatusResponse.ts
+var itemStatusResponseSchema = z58.object({
+  itemStatuses: z58.array(itemStatusSchema)
+});
+
+// lib/errors/v1/models/ItemErrorDetails.ts
+import { z as z59 } from "zod";
+var itemErrorDetailsSchema = z59.object({
+  errorMessage: z59.string(),
+  attributeName: z59.string().nullable(),
+  tradingPartnerNames: z59.array(z59.string()),
+  phases: z59.array(phaseEnumSchema),
+  attributeDbNames: z59.array(z59.string()),
+  tradingPartnerStages: z59.array(tradingPartnerStageSchema),
+  repeatableGroupId: z59.string().nullish()
+});
+
+// lib/errors/v1/models/ItemErrorDetailsResult.ts
+import { z as z60 } from "zod";
+var itemErrorDetailsResultSchema = z60.object({
+  itemInfoId: z60.number(),
+  upc: z60.string().nullish(),
+  isbn: z60.string().nullish(),
+  gtin: z60.string().nullish(),
+  partnumber: z60.string().nullish(),
+  ean: z60.string().nullish(),
+  itemName: z60.string().nullable(),
+  itemErrorDetails: z60.array(itemErrorDetailsSchema)
+});
+
+// lib/errors/v2/models/TradingPartnerStage.ts
+import { z as z66 } from "zod";
+
+// lib/items/v2/models/ItemOrgStageDetails.ts
+import { z as z63 } from "zod";
+
+// lib/items/v2/models/Stage.ts
+import { z as z61 } from "zod";
+var stageSchema = z61.enum([
+  "CORE",
+  "CORE_PLUS",
+  "CORE_ADVANCED",
+  "ENRICHED"
+]);
+
+// lib/items/v2/models/OrgSummary.ts
+import { z as z62 } from "zod";
+var orgSummarySchema = z62.object({
+  ref: z62.string(),
+  id: z62.string(),
+  name: z62.string()
+});
+
+// lib/items/v2/models/ItemOrgStageDetails.ts
+var itemOrgStageDetailsSchema = z63.object({
+  /**
+   * When called as retailer, the vendor, else when vendor, the retailer.
+   * */
+  orgSummary: orgSummarySchema,
+  /**
+   * The company id of the retailer or vendor used for matching ItemOrgStageDetails to TradingPartnerStage for ErrorService
+   */
+  companyId: z63.number().nullish(),
+  /**
+   * "Standard Requirements" (null) UNLESS the retailer of the item is MSIS Enabled
+   * OTHERWISE the retailer default Stage UNLESS there's a currently active vendor-specific Stage defined
+   * OTHERWISE the trading partnership Stage UNLESS there's a currently active Item Level override defined
+   * OTHERWISE the item level override */
+  stage: stageSchema.nullish(),
+  /**
+   * If the item is valid for the active stage. Note that for "Standard Requirements" or
+   * "Enriched" this cam come directly from the item_doc table, but anything else requires validation
+   */
+  isValid: z63.boolean(),
+  /**
+   * Not null if there's an item level policy override for this trading partnership
+   */
+  itemPolicyId: z63.string().nullish(),
+  /**
+   * Start date for the Item level Stage if applicable
+   */
+  startDate: z63.number().transform((num) => new Date(num * 1e3)).nullish(),
+  /**
+   * End date for the Item level Stage if applicable
+   */
+  endDate: z63.number().transform((num) => new Date(num * 1e3)).nullish()
+});
+
+// lib/items/v2/models/ItemStatusV2.ts
+import { z as z64 } from "zod";
+var itemStatusV2Schema = z64.object({
+  itemId: z64.string(),
+  mostRestrictiveRetailerStage: stageSchema.nullable(),
+  itemOrgStageDetails: z64.array(itemOrgStageDetailsSchema)
+});
+
+// lib/items/v2/models/ItemStatusV2Response.ts
+import { z as z65 } from "zod";
+var itemStatusV2ResponseSchema = z65.object({
+  itemStatuses: z65.array(itemStatusV2Schema)
+});
+
+// lib/errors/v2/models/TradingPartnerStage.ts
+var tradingPartnerStageV2Schema = z66.object({
+  companyId: z66.number(),
+  companyName: z66.string(),
+  stage: stageSchema.nullish(),
+  isValid: z66.boolean()
+});
+
+// lib/errors/v2/models/ItemErrorSummary.ts
+import { z as z67 } from "zod";
+var itemErrorSummaryV2Schema = z67.object({
+  itemInfoId: z67.number(),
+  upc: z67.string().nullish(),
+  isbn: z67.string().nullish(),
+  gtin: z67.string().nullish(),
+  ean: z67.string().nullish(),
+  partnumber: z67.string().nullish(),
+  colorfamily: z67.string().nullish(),
+  fit: z67.string().nullish(),
+  productcolordescription: z67.string().nullish(),
+  distributioncentercode: z67.string().nullish(),
+  accountnumber: z67.string().nullish(),
+  erpid: z67.string().nullish(),
+  totalErrors: z67.number(),
+  tradingPartners: z67.array(z67.string()),
+  tradingPartnerIds: z67.array(z67.number()),
+  // These are the stages assigned to the TradingPartners, not the stages of the errors
+  phases: z67.array(z67.string()),
+  // Same thing for the stage property in here: it's the stage of the Item & TradingPartner, not the stage of the error
+  tradingPartnerStages: z67.array(tradingPartnerStageV2Schema),
+  validatedDate: z67.number().pipe(z67.coerce.date()).nullish()
+});
+
+// lib/errors/v2/models/ItemErrorSummaryResult.ts
+import { z as z68 } from "zod";
+var itemErrorSummaryResultV2Schema = z68.object({
+  hasNext: z68.boolean(),
+  errors: z68.array(itemErrorSummaryV2Schema)
+});
+
+// lib/errors/v2/models/ItemErrorDetails.ts
+import { z as z69 } from "zod";
+var itemErrorDetailsV2Schema = z69.object({
+  errorMessage: z69.string(),
+  attributeName: z69.string().nullable(),
+  tradingPartnerNames: z69.array(z69.string()),
+  phases: z69.array(stageSchema),
+  attributeDbNames: z69.array(z69.string()),
+  tradingPartnerStages: z69.array(tradingPartnerStageV2Schema),
+  repeatableGroupId: z69.string().nullish()
+});
+
+// lib/errors/v2/models/ItemErrorDetailsResult.ts
+import { z as z70 } from "zod";
+var itemErrorDetailsResultV2Schema = z70.object({
+  itemInfoId: z70.number(),
+  upc: z70.string().nullish(),
+  isbn: z70.string().nullish(),
+  gtin: z70.string().nullish(),
+  partnumber: z70.string().nullish(),
+  ean: z70.string().nullish(),
+  colorfamily: z70.string().nullish(),
+  fit: z70.string().nullish(),
+  productcolordescription: z70.string().nullish(),
+  distributioncentercode: z70.string().nullish(),
+  accountnumber: z70.string().nullish(),
+  erpid: z70.string().nullish(),
+  itemName: z70.string().nullish(),
+  itemErrorDetails: z70.array(itemErrorDetailsV2Schema)
+});
+
+// lib/companies/models/CompanyBriefByOrg.ts
+import { z as z71 } from "zod";
+var companyBriefByOrgSchema = z71.object({
+  companyId: z71.number(),
+  name: z71.string(),
+  orgId: z71.string(),
+  companyTypes: z71.array(companyTypeSchema),
+  dc4Id: z71.number()
+});
+
+// lib/companies/models/Company.ts
+import { z as z73 } from "zod";
+
+// lib/companies/models/CompanyRelationship.ts
+import { z as z72 } from "zod";
+var applicationSchema = z72.object({
+  application: applicationTypeSchema,
+  relationshipApplicationId: z72.number()
+});
+var catalogSchema = z72.object({
+  active: z72.boolean(),
+  catalogId: z72.number(),
+  itemPartnerId: z72.number()
+});
+var relationshipCompanySchema = z72.object({
+  companyId: z72.number(),
+  companyTypes: z72.array(companyTypeSchema),
+  dc4Id: z72.number().nullable(),
+  name: z72.string(),
+  orgId: z72.string()
+});
+var relationshipSchema = z72.object({
+  active: z72.boolean(),
+  application: z72.array(applicationSchema),
+  catalog: z72.array(catalogSchema),
+  company: relationshipCompanySchema,
+  createdAt: z72.number(),
+  modifiedAt: z72.number().nullable(),
+  relationshipId: z72.number()
+});
+
+// lib/companies/models/Company.ts
+var featureResponseSchema = z73.object({
+  active: z73.boolean(),
+  createdBy: z73.string().nullable(),
+  createdDate: z73.number().nullable(),
+  display: z73.string(),
+  modifiedBy: z73.string().nullish(),
+  modifiedDate: z73.number().nullish(),
+  type: z73.string()
+});
+var identitySchema = z73.object({
+  orgId: z73.string().nullable(),
+  service: z73.object({
+    name: z73.string()
+  }).nullable()
+});
+var companySchema = z73.object({
+  active: z73.boolean(),
+  companyId: z73.number(),
+  companyTypes: z73.array(companyTypeSchema),
+  createdAt: z73.number().nullable(),
+  features: z73.array(featureResponseSchema),
+  identity: identitySchema,
+  modifiedAt: z73.number().nullable(),
+  name: z73.string(),
+  relationships: z73.array(relationshipSchema),
+  uniqueAttributes: z73.array(z73.string())
+});
+
+// lib/companies/models/CompanySearch.ts
+import { z as z74 } from "zod";
+var companySearchParamsSchema = z74.object({
+  name: z74.string().min(2).max(100).optional(),
+  companyIds: z74.string().min(2).optional(),
+  orgId: z74.string().min(2).optional(),
+  catalogName: z74.string().min(2).max(100).optional(),
+  catalogIds: z74.string().min(2).optional(),
+  type: companyTypeSchema.optional()
+});
+var companyCatalogSchema = z74.object({
+  categoryId: z74.number(),
+  categoryName: z74.string()
+});
+var companySearchSchema = z74.object({
+  id: z74.string(),
+  organizationName: z74.string(),
+  description: z74.string(),
+  orgId: z74.string().optional(),
+  roles: z74.array(companyTypeSchema),
+  connections: z74.number(),
+  uniqueCriteria: z74.array(z74.string()).optional(),
+  serviceName: z74.string(),
+  catalogs: z74.array(companyCatalogSchema),
+  application: z74.array(applicationTypeSchema).optional()
+});
+
+export {
+  importDetailSchema,
+  importSchema,
+  importErrorSchema,
+  importErrorsSchema,
+  importStatusEnumSchema,
+  importsStatusSchema,
+  vendorPartnerAttGroupsSchema,
+  generateImportTemplateParamsSchema,
+  attrProdTypeSchema,
+  pagedResultsSchema,
+  connectionSchema,
+  companyRelationshipUpsertBodySchema,
+  itemPartnerSchema,
+  tradingPartnerAccessByCompanyIdSchema,
+  categoryTypeSchema,
+  PRODUCT_CODE_DEFAULT_VALUE,
+  SELECTION_CODE_DEFAULT_VALUE,
+  itemCategorySchema,
+  itemCategoriesSearchSchema,
+  itemHierarchyResponseSchema,
+  catalogCreateResponseSchema,
+  catalogBriefResponseSchema,
+  localeSchema,
+  spreadsheetTemplateCompanySchema,
+  spreadsheetTemplateSchema,
+  identityServiceDatetimePreferencesSchema,
+  identityServiceOrganizationMetadataSchema,
+  identityServiceOrganizationSchema,
+  identityServicePreferencesSchema,
+  identityServiceUserSchema,
+  registeredServiceSchema,
+  userAccountSchema,
+  itemHeaderSchema,
+  phaseEnumSchema,
+  tradingPartnerStageSchema,
+  itemMapSchema,
+  itemTableSchema,
+  itemSearchViewSchema,
+  attributeDetailSchema,
+  categoryEnumSchema,
+  componentDetailsSchema,
+  repeatableGroupSchema,
+  groupedAttributeListSchema,
+  groupedAttributesSchema,
+  hierarchyCategorySchema,
+  hierarchyDetailsSchema,
+  packComponentItemInfoSchema,
+  itemPriceSchema,
+  packComponentDetailsSchema,
+  groupedItemSchema,
+  itemDetailViewSchema,
+  bulbSchema,
+  packComponentSchema,
+  mediaItemSchema,
+  itemDetailSchema,
+  spsItemIdResponseSchema,
+  itemStatusResponseSchema,
+  itemStatusV2ResponseSchema,
+  itemErrorDetailsSchema,
+  itemErrorDetailsResultSchema,
+  tradingPartnerStageV2Schema,
+  itemErrorSummaryV2Schema,
+  itemErrorSummaryResultV2Schema,
+  itemErrorDetailsV2Schema,
+  itemErrorDetailsResultV2Schema,
+  companyBriefByOrgSchema,
+  companySchema,
+  companySearchSchema
+};