@unified-api/typescript-sdk 2.83.19 → 2.83.21

package/src/sdk/models/shared/atsmetadata.ts

@@ -10,16 +10,16 @@ import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export type AtsMetadata1 = {};
+export type One = {};
 
-export type AtsMetadata5 = AtsMetadata1 | string | number | boolean;
+export type Five = One | string | number | boolean;
 
 export type ExtraData =
   | { [k: string]: any }
   | string
   | number
   | boolean
-  | Array<AtsMetadata1 | string | number | boolean>;
+  | Array<One | string | number | boolean>;
 
 export const Format = {
   Text: "TEXT",
@@ -38,20 +38,16 @@ export const Format = {
 } as const;
 export type Format = OpenEnum<typeof Format>;
 
-export type AtsMetadataSchemas1 = {};
+export type AtsMetadata1 = {};
 
-export type AtsMetadataSchemas5 =
-  | AtsMetadataSchemas1
-  | string
-  | number
-  | boolean;
+export type AtsMetadata5 = AtsMetadata1 | string | number | boolean;
 
-export type AtsMetadataValue =
+export type Value =
   | { [k: string]: any }
   | string
   | number
   | boolean
-  | Array<AtsMetadataSchemas1 | string | number | boolean>;
+  | Array<AtsMetadata1 | string | number | boolean>;
 
 export type AtsMetadata = {
   extraData?:
@@ -59,7 +55,7 @@ export type AtsMetadata = {
     | string
     | number
     | boolean
-    | Array<AtsMetadata1 | string | number | boolean>
+    | Array<One | string | number | boolean>
     | undefined;
   format?: Format | undefined;
   id?: string | undefined;
@@ -70,79 +66,63 @@ export type AtsMetadata = {
     | string
     | number
     | boolean
-    | Array<AtsMetadataSchemas1 | string | number | boolean>
+    | Array<AtsMetadata1 | string | number | boolean>
     | undefined;
 };
 
 /** @internal */
-export const AtsMetadata1$inboundSchema: z.ZodType<
-  AtsMetadata1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({});
+export const One$inboundSchema: z.ZodType<One, z.ZodTypeDef, unknown> = z
+  .object({});
 /** @internal */
-export type AtsMetadata1$Outbound = {};
+export type One$Outbound = {};
 
 /** @internal */
-export const AtsMetadata1$outboundSchema: z.ZodType<
-  AtsMetadata1$Outbound,
-  z.ZodTypeDef,
-  AtsMetadata1
-> = z.object({});
+export const One$outboundSchema: z.ZodType<One$Outbound, z.ZodTypeDef, One> = z
+  .object({});
 
-export function atsMetadata1ToJSON(atsMetadata1: AtsMetadata1): string {
-  return JSON.stringify(AtsMetadata1$outboundSchema.parse(atsMetadata1));
+export function oneToJSON(one: One): string {
+  return JSON.stringify(One$outboundSchema.parse(one));
 }
-export function atsMetadata1FromJSON(
+export function oneFromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadata1, SDKValidationError> {
+): SafeParseResult<One, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadata1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadata1' from JSON`,
+    (x) => One$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'One' from JSON`,
   );
 }
 
 /** @internal */
-export const AtsMetadata5$inboundSchema: z.ZodType<
-  AtsMetadata5,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => AtsMetadata1$inboundSchema),
-  z.string(),
-  z.number(),
-  z.boolean(),
-]);
+export const Five$inboundSchema: z.ZodType<Five, z.ZodTypeDef, unknown> = z
+  .union([
+    z.lazy(() => One$inboundSchema),
+    z.string(),
+    z.number(),
+    z.boolean(),
+  ]);
 /** @internal */
-export type AtsMetadata5$Outbound =
-  | AtsMetadata1$Outbound
-  | string
-  | number
-  | boolean;
+export type Five$Outbound = One$Outbound | string | number | boolean;
 
 /** @internal */
-export const AtsMetadata5$outboundSchema: z.ZodType<
-  AtsMetadata5$Outbound,
-  z.ZodTypeDef,
-  AtsMetadata5
-> = z.union([
-  z.lazy(() => AtsMetadata1$outboundSchema),
-  z.string(),
-  z.number(),
-  z.boolean(),
-]);
+export const Five$outboundSchema: z.ZodType<Five$Outbound, z.ZodTypeDef, Five> =
+  z.union([
+    z.lazy(() => One$outboundSchema),
+    z.string(),
+    z.number(),
+    z.boolean(),
+  ]);
 
-export function atsMetadata5ToJSON(atsMetadata5: AtsMetadata5): string {
-  return JSON.stringify(AtsMetadata5$outboundSchema.parse(atsMetadata5));
+export function fiveToJSON(five: Five): string {
+  return JSON.stringify(Five$outboundSchema.parse(five));
 }
-export function atsMetadata5FromJSON(
+export function fiveFromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadata5, SDKValidationError> {
+): SafeParseResult<Five, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadata5$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadata5' from JSON`,
+    (x) => Five$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Five' from JSON`,
   );
 }
 
@@ -158,7 +138,7 @@ export const ExtraData$inboundSchema: z.ZodType<
   z.boolean(),
   z.array(
     z.union([
-      z.lazy(() => AtsMetadata1$inboundSchema),
+      z.lazy(() => One$inboundSchema),
       z.string(),
       z.number(),
       z.boolean(),
@@ -171,7 +151,7 @@ export type ExtraData$Outbound =
   | string
   | number
   | boolean
-  | Array<AtsMetadata1$Outbound | string | number | boolean>;
+  | Array<One$Outbound | string | number | boolean>;
 
 /** @internal */
 export const ExtraData$outboundSchema: z.ZodType<
@@ -185,7 +165,7 @@ export const ExtraData$outboundSchema: z.ZodType<
   z.boolean(),
   z.array(
     z.union([
-      z.lazy(() => AtsMetadata1$outboundSchema),
+      z.lazy(() => One$outboundSchema),
       z.string(),
       z.number(),
       z.boolean(),
@@ -214,117 +194,106 @@ export const Format$outboundSchema: z.ZodType<string, z.ZodTypeDef, Format> =
   openEnums.outboundSchema(Format);
 
 /** @internal */
-export const AtsMetadataSchemas1$inboundSchema: z.ZodType<
-  AtsMetadataSchemas1,
+export const AtsMetadata1$inboundSchema: z.ZodType<
+  AtsMetadata1,
   z.ZodTypeDef,
   unknown
 > = z.object({});
 /** @internal */
-export type AtsMetadataSchemas1$Outbound = {};
+export type AtsMetadata1$Outbound = {};
 
 /** @internal */
-export const AtsMetadataSchemas1$outboundSchema: z.ZodType<
-  AtsMetadataSchemas1$Outbound,
+export const AtsMetadata1$outboundSchema: z.ZodType<
+  AtsMetadata1$Outbound,
   z.ZodTypeDef,
-  AtsMetadataSchemas1
+  AtsMetadata1
 > = z.object({});
 
-export function atsMetadataSchemas1ToJSON(
-  atsMetadataSchemas1: AtsMetadataSchemas1,
-): string {
-  return JSON.stringify(
-    AtsMetadataSchemas1$outboundSchema.parse(atsMetadataSchemas1),
-  );
+export function atsMetadata1ToJSON(atsMetadata1: AtsMetadata1): string {
+  return JSON.stringify(AtsMetadata1$outboundSchema.parse(atsMetadata1));
 }
-export function atsMetadataSchemas1FromJSON(
+export function atsMetadata1FromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadataSchemas1, SDKValidationError> {
+): SafeParseResult<AtsMetadata1, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadataSchemas1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadataSchemas1' from JSON`,
+    (x) => AtsMetadata1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AtsMetadata1' from JSON`,
   );
 }
 
 /** @internal */
-export const AtsMetadataSchemas5$inboundSchema: z.ZodType<
-  AtsMetadataSchemas5,
+export const AtsMetadata5$inboundSchema: z.ZodType<
+  AtsMetadata5,
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => AtsMetadataSchemas1$inboundSchema),
+  z.lazy(() => AtsMetadata1$inboundSchema),
   z.string(),
   z.number(),
   z.boolean(),
 ]);
 /** @internal */
-export type AtsMetadataSchemas5$Outbound =
-  | AtsMetadataSchemas1$Outbound
+export type AtsMetadata5$Outbound =
+  | AtsMetadata1$Outbound
   | string
   | number
   | boolean;
 
 /** @internal */
-export const AtsMetadataSchemas5$outboundSchema: z.ZodType<
-  AtsMetadataSchemas5$Outbound,
+export const AtsMetadata5$outboundSchema: z.ZodType<
+  AtsMetadata5$Outbound,
   z.ZodTypeDef,
-  AtsMetadataSchemas5
+  AtsMetadata5
 > = z.union([
-  z.lazy(() => AtsMetadataSchemas1$outboundSchema),
+  z.lazy(() => AtsMetadata1$outboundSchema),
   z.string(),
   z.number(),
   z.boolean(),
 ]);
 
-export function atsMetadataSchemas5ToJSON(
-  atsMetadataSchemas5: AtsMetadataSchemas5,
-): string {
-  return JSON.stringify(
-    AtsMetadataSchemas5$outboundSchema.parse(atsMetadataSchemas5),
-  );
+export function atsMetadata5ToJSON(atsMetadata5: AtsMetadata5): string {
+  return JSON.stringify(AtsMetadata5$outboundSchema.parse(atsMetadata5));
 }
-export function atsMetadataSchemas5FromJSON(
+export function atsMetadata5FromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadataSchemas5, SDKValidationError> {
+): SafeParseResult<AtsMetadata5, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadataSchemas5$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadataSchemas5' from JSON`,
+    (x) => AtsMetadata5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AtsMetadata5' from JSON`,
   );
 }
 
 /** @internal */
-export const AtsMetadataValue$inboundSchema: z.ZodType<
-  AtsMetadataValue,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.record(z.any()),
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.array(
-    z.union([
-      z.lazy(() => AtsMetadataSchemas1$inboundSchema),
-      z.string(),
-      z.number(),
-      z.boolean(),
-    ]),
-  ),
-]);
+export const Value$inboundSchema: z.ZodType<Value, z.ZodTypeDef, unknown> = z
+  .union([
+    z.record(z.any()),
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(
+      z.union([
+        z.lazy(() => AtsMetadata1$inboundSchema),
+        z.string(),
+        z.number(),
+        z.boolean(),
+      ]),
+    ),
+  ]);
 /** @internal */
-export type AtsMetadataValue$Outbound =
+export type Value$Outbound =
   | { [k: string]: any }
   | string
   | number
   | boolean
-  | Array<AtsMetadataSchemas1$Outbound | string | number | boolean>;
+  | Array<AtsMetadata1$Outbound | string | number | boolean>;
 
 /** @internal */
-export const AtsMetadataValue$outboundSchema: z.ZodType<
-  AtsMetadataValue$Outbound,
+export const Value$outboundSchema: z.ZodType<
+  Value$Outbound,
   z.ZodTypeDef,
-  AtsMetadataValue
+  Value
 > = z.union([
   z.record(z.any()),
   z.string(),
@@ -332,7 +301,7 @@ export const AtsMetadataValue$outboundSchema: z.ZodType<
   z.boolean(),
   z.array(
     z.union([
-      z.lazy(() => AtsMetadataSchemas1$outboundSchema),
+      z.lazy(() => AtsMetadata1$outboundSchema),
       z.string(),
       z.number(),
       z.boolean(),
@@ -340,20 +309,16 @@ export const AtsMetadataValue$outboundSchema: z.ZodType<
   ),
 ]);
 
-export function atsMetadataValueToJSON(
-  atsMetadataValue: AtsMetadataValue,
-): string {
-  return JSON.stringify(
-    AtsMetadataValue$outboundSchema.parse(atsMetadataValue),
-  );
+export function valueToJSON(value: Value): string {
+  return JSON.stringify(Value$outboundSchema.parse(value));
 }
-export function atsMetadataValueFromJSON(
+export function valueFromJSON(
   jsonString: string,
-): SafeParseResult<AtsMetadataValue, SDKValidationError> {
+): SafeParseResult<Value, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => AtsMetadataValue$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AtsMetadataValue' from JSON`,
+    (x) => Value$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Value' from JSON`,
   );
 }
 
@@ -370,7 +335,7 @@ export const AtsMetadata$inboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadata1$inboundSchema),
+        z.lazy(() => One$inboundSchema),
         z.string(),
         z.number(),
         z.boolean(),
@@ -388,7 +353,7 @@ export const AtsMetadata$inboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadataSchemas1$inboundSchema),
+        z.lazy(() => AtsMetadata1$inboundSchema),
         z.string(),
         z.number(),
         z.boolean(),
@@ -407,7 +372,7 @@ export type AtsMetadata$Outbound = {
     | string
     | number
     | boolean
-    | Array<AtsMetadata1$Outbound | string | number | boolean>
+    | Array<One$Outbound | string | number | boolean>
     | undefined;
   format?: string | undefined;
   id?: string | undefined;
@@ -418,7 +383,7 @@ export type AtsMetadata$Outbound = {
     | string
     | number
     | boolean
-    | Array<AtsMetadataSchemas1$Outbound | string | number | boolean>
+    | Array<AtsMetadata1$Outbound | string | number | boolean>
     | undefined;
 };
 
@@ -435,7 +400,7 @@ export const AtsMetadata$outboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadata1$outboundSchema),
+        z.lazy(() => One$outboundSchema),
         z.string(),
         z.number(),
         z.boolean(),
@@ -453,7 +418,7 @@ export const AtsMetadata$outboundSchema: z.ZodType<
     z.boolean(),
     z.array(
       z.union([
-        z.lazy(() => AtsMetadataSchemas1$outboundSchema),
+        z.lazy(() => AtsMetadata1$outboundSchema),
         z.string(),
         z.number(),
         z.boolean(),

package/src/sdk/models/shared/commerceitem.ts

@@ -5,6 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../../lib/primitives.js";
 import { safeParse } from "../../../lib/schemas.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -13,6 +15,12 @@ import {
   CommerceItemMedia$Outbound,
   CommerceItemMedia$outboundSchema,
 } from "./commerceitemmedia.js";
+import {
+  CommerceItemPrice,
+  CommerceItemPrice$inboundSchema,
+  CommerceItemPrice$Outbound,
+  CommerceItemPrice$outboundSchema,
+} from "./commerceitemprice.js";
 import {
   CommerceItemvariant,
   CommerceItemvariant$inboundSchema,
@@ -32,6 +40,14 @@ import {
   CommerceReference$outboundSchema,
 } from "./commercereference.js";
 
+export const WeightUnit = {
+  G: "g",
+  Kg: "kg",
+  Oz: "oz",
+  Lb: "lb",
+} as const;
+export type WeightUnit = OpenEnum<typeof WeightUnit>;
+
 export type CommerceItem = {
   accountId?: string | undefined;
   /**
@@ -46,17 +62,23 @@ export type CommerceItem = {
   description?: string | undefined;
   globalCode?: string | undefined;
   id?: string | undefined;
+  inventoryId?: string | undefined;
   isActive?: boolean | undefined;
+  isFeatured?: boolean | undefined;
   isTaxable?: boolean | undefined;
+  isVisible?: boolean | undefined;
   media?: Array<CommerceItemMedia> | undefined;
   metadata?: Array<CommerceMetadata> | undefined;
   name?: string | undefined;
+  prices?: Array<CommerceItemPrice> | undefined;
   publicDescription?: string | undefined;
   publicName?: string | undefined;
   raw?: { [k: string]: any } | undefined;
+  requiresShipping?: boolean | undefined;
   slug?: string | undefined;
   tags?: Array<string> | undefined;
   taxrateId?: string | undefined;
+  totalStock?: number | undefined;
   type?: string | undefined;
   updatedAt?: Date | undefined;
   /**
@@ -64,8 +86,23 @@ export type CommerceItem = {
    */
   variants?: Array<CommerceItemvariant> | undefined;
   vendorName?: string | undefined;
+  weight?: number | undefined;
+  weightUnit?: WeightUnit | undefined;
 };
 
+/** @internal */
+export const WeightUnit$inboundSchema: z.ZodType<
+  WeightUnit,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(WeightUnit);
+/** @internal */
+export const WeightUnit$outboundSchema: z.ZodType<
+  string,
+  z.ZodTypeDef,
+  WeightUnit
+> = openEnums.outboundSchema(WeightUnit);
+
 /** @internal */
 export const CommerceItem$inboundSchema: z.ZodType<
   CommerceItem,
@@ -80,35 +117,49 @@ export const CommerceItem$inboundSchema: z.ZodType<
   description: z.string().optional(),
   global_code: z.string().optional(),
   id: z.string().optional(),
+  inventory_id: z.string().optional(),
   is_active: z.boolean().optional(),
+  is_featured: z.boolean().optional(),
   is_taxable: z.boolean().optional(),
+  is_visible: z.boolean().optional(),
   media: z.array(CommerceItemMedia$inboundSchema).optional(),
   metadata: z.array(CommerceMetadata$inboundSchema).optional(),
   name: z.string().optional(),
+  prices: z.array(CommerceItemPrice$inboundSchema).optional(),
   public_description: z.string().optional(),
   public_name: z.string().optional(),
   raw: z.record(z.any()).optional(),
+  requires_shipping: z.boolean().optional(),
   slug: z.string().optional(),
   tags: z.array(z.string()).optional(),
   taxrate_id: z.string().optional(),
+  total_stock: z.number().optional(),
   type: z.string().optional(),
   updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
   variants: z.array(CommerceItemvariant$inboundSchema).optional(),
   vendor_name: z.string().optional(),
+  weight: z.number().optional(),
+  weight_unit: WeightUnit$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "account_id": "accountId",
     "collection_ids": "collectionIds",
     "created_at": "createdAt",
     "global_code": "globalCode",
+    "inventory_id": "inventoryId",
     "is_active": "isActive",
+    "is_featured": "isFeatured",
     "is_taxable": "isTaxable",
+    "is_visible": "isVisible",
     "public_description": "publicDescription",
     "public_name": "publicName",
+    "requires_shipping": "requiresShipping",
     "taxrate_id": "taxrateId",
+    "total_stock": "totalStock",
     "updated_at": "updatedAt",
     "vendor_name": "vendorName",
+    "weight_unit": "weightUnit",
   });
 });
 /** @internal */
@@ -120,21 +171,29 @@ export type CommerceItem$Outbound = {
   description?: string | undefined;
   global_code?: string | undefined;
   id?: string | undefined;
+  inventory_id?: string | undefined;
   is_active?: boolean | undefined;
+  is_featured?: boolean | undefined;
   is_taxable?: boolean | undefined;
+  is_visible?: boolean | undefined;
   media?: Array<CommerceItemMedia$Outbound> | undefined;
   metadata?: Array<CommerceMetadata$Outbound> | undefined;
   name?: string | undefined;
+  prices?: Array<CommerceItemPrice$Outbound> | undefined;
   public_description?: string | undefined;
   public_name?: string | undefined;
   raw?: { [k: string]: any } | undefined;
+  requires_shipping?: boolean | undefined;
   slug?: string | undefined;
   tags?: Array<string> | undefined;
   taxrate_id?: string | undefined;
+  total_stock?: number | undefined;
   type?: string | undefined;
   updated_at?: string | undefined;
   variants?: Array<CommerceItemvariant$Outbound> | undefined;
   vendor_name?: string | undefined;
+  weight?: number | undefined;
+  weight_unit?: string | undefined;
 };
 
 /** @internal */
@@ -150,34 +209,48 @@ export const CommerceItem$outboundSchema: z.ZodType<
   description: z.string().optional(),
   globalCode: z.string().optional(),
   id: z.string().optional(),
+  inventoryId: z.string().optional(),
   isActive: z.boolean().optional(),
+  isFeatured: z.boolean().optional(),
   isTaxable: z.boolean().optional(),
+  isVisible: z.boolean().optional(),
   media: z.array(CommerceItemMedia$outboundSchema).optional(),
   metadata: z.array(CommerceMetadata$outboundSchema).optional(),
   name: z.string().optional(),
+  prices: z.array(CommerceItemPrice$outboundSchema).optional(),
   publicDescription: z.string().optional(),
   publicName: z.string().optional(),
   raw: z.record(z.any()).optional(),
+  requiresShipping: z.boolean().optional(),
   slug: z.string().optional(),
   tags: z.array(z.string()).optional(),
   taxrateId: z.string().optional(),
+  totalStock: z.number().optional(),
   type: z.string().optional(),
   updatedAt: z.date().transform(v => v.toISOString()).optional(),
   variants: z.array(CommerceItemvariant$outboundSchema).optional(),
   vendorName: z.string().optional(),
+  weight: z.number().optional(),
+  weightUnit: WeightUnit$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     accountId: "account_id",
     collectionIds: "collection_ids",
     createdAt: "created_at",
     globalCode: "global_code",
+    inventoryId: "inventory_id",
     isActive: "is_active",
+    isFeatured: "is_featured",
     isTaxable: "is_taxable",
+    isVisible: "is_visible",
     publicDescription: "public_description",
     publicName: "public_name",
+    requiresShipping: "requires_shipping",
     taxrateId: "taxrate_id",
+    totalStock: "total_stock",
     updatedAt: "updated_at",
     vendorName: "vendor_name",
+    weightUnit: "weight_unit",
   });
 });