lapyme 0.2.4 → 0.2.5

package/src/models/api-order-list-response.ts

@@ -6,49 +6,30 @@
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import * as types from "../types/primitives.js";
+import {
+  ApiSharedEnum2f67ddf0e8,
+  ApiSharedEnum2f67ddf0e8$inboundSchema,
+} from "./api-shared-enum2f67ddf0e8.js";
+import {
+  ApiSharedEnum4ac9200c4a,
+  ApiSharedEnum4ac9200c4a$inboundSchema,
+} from "./api-shared-enum4ac9200c4a.js";
+import {
+  ApiSharedEnum6cfb146157,
+  ApiSharedEnum6cfb146157$inboundSchema,
+} from "./api-shared-enum6cfb146157.js";
+import {
+  ApiSharedEnum8d46e1ec20,
+  ApiSharedEnum8d46e1ec20$inboundSchema,
+} from "./api-shared-enum8d46e1ec20.js";
+import {
+  ApiSharedEnumb49e56b125,
+  ApiSharedEnumb49e56b125$inboundSchema,
+} from "./api-shared-enumb49e56b125.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
-export const ApiOrderListResponseCurrency = {
-  Pes: "PES",
-  Dol: "DOL",
-} as const;
-export type ApiOrderListResponseCurrency = OpenEnum<
-  typeof ApiOrderListResponseCurrency
->;
-
-export const ApiOrderListResponseOrderStatus = {
-  Open: "open",
-  Completed: "completed",
-  Cancelled: "cancelled",
-} as const;
-export type ApiOrderListResponseOrderStatus = OpenEnum<
-  typeof ApiOrderListResponseOrderStatus
->;
-
-export const ApiOrderListResponseFulfillmentStatus = {
-  Unfulfilled: "unfulfilled",
-  InProgress: "in_progress",
-  PartiallyFulfilled: "partially_fulfilled",
-  Fulfilled: "fulfilled",
-  Cancelled: "cancelled",
-} as const;
-export type ApiOrderListResponseFulfillmentStatus = OpenEnum<
-  typeof ApiOrderListResponseFulfillmentStatus
->;
-
-export const ApiOrderListResponseInvoicingStatus = {
-  Pending: "pending",
-  PartiallyInvoiced: "partially_invoiced",
-  Invoiced: "invoiced",
-} as const;
-export type ApiOrderListResponseInvoicingStatus = OpenEnum<
-  typeof ApiOrderListResponseInvoicingStatus
->;
-
 export type ApiOrderListResponseData = {
   object: "order";
   id: string;
@@ -64,28 +45,15 @@ export type ApiOrderListResponseData = {
   subtotal: number;
   taxAmount: number;
   total: number;
-  currency: ApiOrderListResponseCurrency;
-  orderStatus: ApiOrderListResponseOrderStatus;
-  fulfillmentStatus: ApiOrderListResponseFulfillmentStatus;
-  invoicingStatus: ApiOrderListResponseInvoicingStatus;
+  currency: ApiSharedEnum6cfb146157;
+  orderStatus: ApiSharedEnum4ac9200c4a;
+  fulfillmentStatus: ApiSharedEnumb49e56b125;
+  invoicingStatus: ApiSharedEnum2f67ddf0e8;
   notes: string | null;
   createdAt: Date;
   createdByName: string;
 };
 
-/**
- * List-envelope discriminator.
- */
-export const ApiOrderListResponseObject = {
-  List: "list",
-} as const;
-/**
- * List-envelope discriminator.
- */
-export type ApiOrderListResponseObject = ClosedEnum<
-  typeof ApiOrderListResponseObject
->;
-
 export type ApiOrderListResponse = {
   requestId: string;
   data: Array<ApiOrderListResponseData>;
@@ -94,37 +62,13 @@ export type ApiOrderListResponse = {
   /**
    * List-envelope discriminator.
    */
-  object: ApiOrderListResponseObject;
+  object: ApiSharedEnum8d46e1ec20;
   /**
    * Requested list path.
    */
   url: string;
 };
 
-/** @internal */
-export const ApiOrderListResponseCurrency$inboundSchema: z.ZodMiniType<
-  ApiOrderListResponseCurrency,
-  unknown
-> = openEnums.inboundSchema(ApiOrderListResponseCurrency);
-
-/** @internal */
-export const ApiOrderListResponseOrderStatus$inboundSchema: z.ZodMiniType<
-  ApiOrderListResponseOrderStatus,
-  unknown
-> = openEnums.inboundSchema(ApiOrderListResponseOrderStatus);
-
-/** @internal */
-export const ApiOrderListResponseFulfillmentStatus$inboundSchema: z.ZodMiniType<
-  ApiOrderListResponseFulfillmentStatus,
-  unknown
-> = openEnums.inboundSchema(ApiOrderListResponseFulfillmentStatus);
-
-/** @internal */
-export const ApiOrderListResponseInvoicingStatus$inboundSchema: z.ZodMiniType<
-  ApiOrderListResponseInvoicingStatus,
-  unknown
-> = openEnums.inboundSchema(ApiOrderListResponseInvoicingStatus);
-
 /** @internal */
 export const ApiOrderListResponseData$inboundSchema: z.ZodMiniType<
   ApiOrderListResponseData,
@@ -145,10 +89,10 @@ export const ApiOrderListResponseData$inboundSchema: z.ZodMiniType<
     subtotal: types.number(),
     tax_amount: types.number(),
     total: types.number(),
-    currency: ApiOrderListResponseCurrency$inboundSchema,
-    order_status: ApiOrderListResponseOrderStatus$inboundSchema,
-    fulfillment_status: ApiOrderListResponseFulfillmentStatus$inboundSchema,
-    invoicing_status: ApiOrderListResponseInvoicingStatus$inboundSchema,
+    currency: ApiSharedEnum6cfb146157$inboundSchema,
+    order_status: ApiSharedEnum4ac9200c4a$inboundSchema,
+    fulfillment_status: ApiSharedEnumb49e56b125$inboundSchema,
+    invoicing_status: ApiSharedEnum2f67ddf0e8$inboundSchema,
     notes: types.nullable(types.string()),
     created_at: types.date(),
     created_by_name: types.string(),
@@ -184,11 +128,6 @@ export function apiOrderListResponseDataFromJSON(
   );
 }
 
-/** @internal */
-export const ApiOrderListResponseObject$inboundSchema: z.ZodMiniEnum<
-  typeof ApiOrderListResponseObject
-> = z.enum(ApiOrderListResponseObject);
-
 /** @internal */
 export const ApiOrderListResponse$inboundSchema: z.ZodMiniType<
   ApiOrderListResponse,
@@ -199,7 +138,7 @@ export const ApiOrderListResponse$inboundSchema: z.ZodMiniType<
     data: z.array(z.lazy(() => ApiOrderListResponseData$inboundSchema)),
     has_more: types.boolean(),
     next_cursor: types.nullable(types.string()),
-    object: ApiOrderListResponseObject$inboundSchema,
+    object: ApiSharedEnum8d46e1ec20$inboundSchema,
     url: types.string(),
   }),
   z.transform((v) => {

package/src/models/api-order-prepare-request.ts

@@ -5,51 +5,21 @@
 
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../lib/primitives.js";
-
-export type ApiOrderPrepareRequestItem = {
-  orderLineId: string;
-  quantity: number;
-};
+import {
+  ApiSharedObject1dbe66a4f8,
+  ApiSharedObject1dbe66a4f8$Outbound,
+  ApiSharedObject1dbe66a4f8$outboundSchema,
+} from "./api-shared-object1dbe66a4f8.js";
 
 export type ApiOrderPrepareRequest = {
   warehouseId?: string | undefined;
-  items: Array<ApiOrderPrepareRequestItem>;
-};
-
-/** @internal */
-export type ApiOrderPrepareRequestItem$Outbound = {
-  order_line_id: string;
-  quantity: number;
+  items: Array<ApiSharedObject1dbe66a4f8>;
 };
 
-/** @internal */
-export const ApiOrderPrepareRequestItem$outboundSchema: z.ZodMiniType<
-  ApiOrderPrepareRequestItem$Outbound,
-  ApiOrderPrepareRequestItem
-> = z.pipe(
-  z.object({
-    orderLineId: z.string(),
-    quantity: z.int(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      orderLineId: "order_line_id",
-    });
-  }),
-);
-
-export function apiOrderPrepareRequestItemToJSON(
-  apiOrderPrepareRequestItem: ApiOrderPrepareRequestItem,
-): string {
-  return JSON.stringify(
-    ApiOrderPrepareRequestItem$outboundSchema.parse(apiOrderPrepareRequestItem),
-  );
-}
-
 /** @internal */
 export type ApiOrderPrepareRequest$Outbound = {
   warehouse_id?: string | undefined;
-  items: Array<ApiOrderPrepareRequestItem$Outbound>;
+  items: Array<ApiSharedObject1dbe66a4f8$Outbound>;
 };
 
 /** @internal */
@@ -59,7 +29,7 @@ export const ApiOrderPrepareRequest$outboundSchema: z.ZodMiniType<
 > = z.pipe(
   z.object({
     warehouseId: z.optional(z.string()),
-    items: z.array(z.lazy(() => ApiOrderPrepareRequestItem$outboundSchema)),
+    items: z.array(ApiSharedObject1dbe66a4f8$outboundSchema),
   }),
   z.transform((v) => {
     return remap$(v, {

package/src/models/api-order-write-response.ts

@@ -6,152 +6,16 @@
 import * as z from "zod/v4-mini";
 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 * as types from "../types/primitives.js";
+import {
+  ApiSharedObject9223e6f740,
+  ApiSharedObject9223e6f740$inboundSchema,
+} from "./api-shared-object9223e6f740.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 
-export const ApiOrderWriteResponseCurrency = {
-  Pes: "PES",
-  Dol: "DOL",
-} as const;
-export type ApiOrderWriteResponseCurrency = OpenEnum<
-  typeof ApiOrderWriteResponseCurrency
->;
-
-export const ApiOrderWriteResponseOrderStatus = {
-  Open: "open",
-  Completed: "completed",
-  Cancelled: "cancelled",
-} as const;
-export type ApiOrderWriteResponseOrderStatus = OpenEnum<
-  typeof ApiOrderWriteResponseOrderStatus
->;
-
-export const ApiOrderWriteResponseFulfillmentStatus = {
-  Unfulfilled: "unfulfilled",
-  InProgress: "in_progress",
-  PartiallyFulfilled: "partially_fulfilled",
-  Fulfilled: "fulfilled",
-  Cancelled: "cancelled",
-} as const;
-export type ApiOrderWriteResponseFulfillmentStatus = OpenEnum<
-  typeof ApiOrderWriteResponseFulfillmentStatus
->;
-
-export const ApiOrderWriteResponseInvoicingStatus = {
-  Pending: "pending",
-  PartiallyInvoiced: "partially_invoiced",
-  Invoiced: "invoiced",
-} as const;
-export type ApiOrderWriteResponseInvoicingStatus = OpenEnum<
-  typeof ApiOrderWriteResponseInvoicingStatus
->;
-
-export type ApiOrderWriteResponseLineItem = {
-  id: string;
-  lineNumber: number;
-  productId: string | null;
-  productName: string;
-  sku: string;
-  orderedQuantity: number;
-  allocatedQuantity: number;
-  fulfilledQuantity: number;
-  invoicedQuantity: number;
-  cancelledQuantity: number;
-  unitPrice: number;
-  taxRateId: number;
-  discountAmount: number | null;
-  discountPercentage: number | null;
-  subtotal: number;
-};
-
-export type ApiOrderWriteResponseActiveWarehouse = {
-  id: string;
-  name: string;
-  isDefault: boolean;
-};
-
-export const ApiOrderWriteResponseStatus = {
-  Open: "open",
-  InProgress: "in_progress",
-  OnHold: "on_hold",
-  Closed: "closed",
-  Cancelled: "cancelled",
-} as const;
-export type ApiOrderWriteResponseStatus = OpenEnum<
-  typeof ApiOrderWriteResponseStatus
->;
-
-export const ApiOrderWriteResponseDeliveryMethod = {
-  Shipping: "shipping",
-  LocalDelivery: "local_delivery",
-  Pickup: "pickup",
-} as const;
-export type ApiOrderWriteResponseDeliveryMethod = OpenEnum<
-  typeof ApiOrderWriteResponseDeliveryMethod
->;
-
-export type ApiOrderWriteResponseLine = {
-  id: string;
-  orderLineId: string;
-  productId: string | null;
-  productName: string;
-  sku: string;
-  quantity: number;
-  fulfilledQuantity: number;
-  cancelledQuantity: number;
-};
-
-export type ApiOrderWriteResponseFulfillmentOrder = {
-  object: "fulfillment_order";
-  id: string;
-  status: ApiOrderWriteResponseStatus;
-  assignedWarehouseId: string;
-  assignedWarehouseName: string | null;
-  deliveryMethod: ApiOrderWriteResponseDeliveryMethod;
-  requestedAt: Date;
-  startedAt: Date | null;
-  closedAt: Date | null;
-  cancelledAt: Date | null;
-  notes: string | null;
-  lines: Array<ApiOrderWriteResponseLine>;
-};
-
-export type Order = {
-  object: "order";
-  id: string;
-  orderNumber: string;
-  rawOrderNumber: number;
-  orderDate: Date;
-  customerId: string;
-  customerName: string;
-  customerTaxId: string | null;
-  itemsCount: number;
-  totalUnits: number;
-  discountAmount: number;
-  subtotal: number;
-  taxAmount: number;
-  total: number;
-  currency: ApiOrderWriteResponseCurrency;
-  orderStatus: ApiOrderWriteResponseOrderStatus;
-  fulfillmentStatus: ApiOrderWriteResponseFulfillmentStatus;
-  invoicingStatus: ApiOrderWriteResponseInvoicingStatus;
-  notes: string | null;
-  createdAt: Date;
-  createdByName: string;
-  createdBy: string;
-  lineItems: Array<ApiOrderWriteResponseLineItem>;
-  activeWarehouses: Array<ApiOrderWriteResponseActiveWarehouse>;
-  pendingFulfillmentLocationId: string | null;
-  fulfillmentOrders: Array<ApiOrderWriteResponseFulfillmentOrder>;
-  fulfillments: Array<any>;
-  generatedInvoices: Array<any>;
-};
-
 export type ApiOrderWriteResponseData = {
-  order: Order;
+  order: ApiSharedObject9223e6f740;
   idempotentReplay?: boolean | undefined;
   result?: any | undefined;
 };
@@ -162,280 +26,13 @@ export type ApiOrderWriteResponse = {
   warnings: Array<any>;
 };
 
-/** @internal */
-export const ApiOrderWriteResponseCurrency$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseCurrency,
-  unknown
-> = openEnums.inboundSchema(ApiOrderWriteResponseCurrency);
-
-/** @internal */
-export const ApiOrderWriteResponseOrderStatus$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseOrderStatus,
-  unknown
-> = openEnums.inboundSchema(ApiOrderWriteResponseOrderStatus);
-
-/** @internal */
-export const ApiOrderWriteResponseFulfillmentStatus$inboundSchema:
-  z.ZodMiniType<ApiOrderWriteResponseFulfillmentStatus, unknown> = openEnums
-    .inboundSchema(ApiOrderWriteResponseFulfillmentStatus);
-
-/** @internal */
-export const ApiOrderWriteResponseInvoicingStatus$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseInvoicingStatus,
-  unknown
-> = openEnums.inboundSchema(ApiOrderWriteResponseInvoicingStatus);
-
-/** @internal */
-export const ApiOrderWriteResponseLineItem$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseLineItem,
-  unknown
-> = z.pipe(
-  z.object({
-    id: types.string(),
-    line_number: types.number(),
-    product_id: types.nullable(types.string()),
-    product_name: types.string(),
-    sku: types.string(),
-    ordered_quantity: types.number(),
-    allocated_quantity: types.number(),
-    fulfilled_quantity: types.number(),
-    invoiced_quantity: types.number(),
-    cancelled_quantity: types.number(),
-    unit_price: types.number(),
-    tax_rate_id: types.number(),
-    discount_amount: types.nullable(types.number()),
-    discount_percentage: types.nullable(types.number()),
-    subtotal: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "line_number": "lineNumber",
-      "product_id": "productId",
-      "product_name": "productName",
-      "ordered_quantity": "orderedQuantity",
-      "allocated_quantity": "allocatedQuantity",
-      "fulfilled_quantity": "fulfilledQuantity",
-      "invoiced_quantity": "invoicedQuantity",
-      "cancelled_quantity": "cancelledQuantity",
-      "unit_price": "unitPrice",
-      "tax_rate_id": "taxRateId",
-      "discount_amount": "discountAmount",
-      "discount_percentage": "discountPercentage",
-    });
-  }),
-);
-
-export function apiOrderWriteResponseLineItemFromJSON(
-  jsonString: string,
-): SafeParseResult<ApiOrderWriteResponseLineItem, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ApiOrderWriteResponseLineItem$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ApiOrderWriteResponseLineItem' from JSON`,
-  );
-}
-
-/** @internal */
-export const ApiOrderWriteResponseActiveWarehouse$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseActiveWarehouse,
-  unknown
-> = z.pipe(
-  z.object({
-    id: types.string(),
-    name: types.string(),
-    is_default: types.boolean(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "is_default": "isDefault",
-    });
-  }),
-);
-
-export function apiOrderWriteResponseActiveWarehouseFromJSON(
-  jsonString: string,
-): SafeParseResult<ApiOrderWriteResponseActiveWarehouse, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      ApiOrderWriteResponseActiveWarehouse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ApiOrderWriteResponseActiveWarehouse' from JSON`,
-  );
-}
-
-/** @internal */
-export const ApiOrderWriteResponseStatus$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseStatus,
-  unknown
-> = openEnums.inboundSchema(ApiOrderWriteResponseStatus);
-
-/** @internal */
-export const ApiOrderWriteResponseDeliveryMethod$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseDeliveryMethod,
-  unknown
-> = openEnums.inboundSchema(ApiOrderWriteResponseDeliveryMethod);
-
-/** @internal */
-export const ApiOrderWriteResponseLine$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseLine,
-  unknown
-> = z.pipe(
-  z.object({
-    id: types.string(),
-    order_line_id: types.string(),
-    product_id: types.nullable(types.string()),
-    product_name: types.string(),
-    sku: types.string(),
-    quantity: types.number(),
-    fulfilled_quantity: types.number(),
-    cancelled_quantity: types.number(),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "order_line_id": "orderLineId",
-      "product_id": "productId",
-      "product_name": "productName",
-      "fulfilled_quantity": "fulfilledQuantity",
-      "cancelled_quantity": "cancelledQuantity",
-    });
-  }),
-);
-
-export function apiOrderWriteResponseLineFromJSON(
-  jsonString: string,
-): SafeParseResult<ApiOrderWriteResponseLine, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ApiOrderWriteResponseLine$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ApiOrderWriteResponseLine' from JSON`,
-  );
-}
-
-/** @internal */
-export const ApiOrderWriteResponseFulfillmentOrder$inboundSchema: z.ZodMiniType<
-  ApiOrderWriteResponseFulfillmentOrder,
-  unknown
-> = z.pipe(
-  z.object({
-    object: types.literal("fulfillment_order"),
-    id: types.string(),
-    status: ApiOrderWriteResponseStatus$inboundSchema,
-    assigned_warehouse_id: types.string(),
-    assigned_warehouse_name: types.nullable(types.string()),
-    delivery_method: ApiOrderWriteResponseDeliveryMethod$inboundSchema,
-    requested_at: types.date(),
-    started_at: types.nullable(types.date()),
-    closed_at: types.nullable(types.date()),
-    cancelled_at: types.nullable(types.date()),
-    notes: types.nullable(types.string()),
-    lines: z.array(z.lazy(() => ApiOrderWriteResponseLine$inboundSchema)),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "assigned_warehouse_id": "assignedWarehouseId",
-      "assigned_warehouse_name": "assignedWarehouseName",
-      "delivery_method": "deliveryMethod",
-      "requested_at": "requestedAt",
-      "started_at": "startedAt",
-      "closed_at": "closedAt",
-      "cancelled_at": "cancelledAt",
-    });
-  }),
-);
-
-export function apiOrderWriteResponseFulfillmentOrderFromJSON(
-  jsonString: string,
-): SafeParseResult<ApiOrderWriteResponseFulfillmentOrder, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      ApiOrderWriteResponseFulfillmentOrder$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ApiOrderWriteResponseFulfillmentOrder' from JSON`,
-  );
-}
-
-/** @internal */
-export const Order$inboundSchema: z.ZodMiniType<Order, unknown> = z.pipe(
-  z.object({
-    object: types.literal("order"),
-    id: types.string(),
-    order_number: types.string(),
-    raw_order_number: types.number(),
-    order_date: types.date(),
-    customer_id: types.string(),
-    customer_name: types.string(),
-    customer_tax_id: types.nullable(types.string()),
-    items_count: types.number(),
-    total_units: types.number(),
-    discount_amount: types.number(),
-    subtotal: types.number(),
-    tax_amount: types.number(),
-    total: types.number(),
-    currency: ApiOrderWriteResponseCurrency$inboundSchema,
-    order_status: ApiOrderWriteResponseOrderStatus$inboundSchema,
-    fulfillment_status: ApiOrderWriteResponseFulfillmentStatus$inboundSchema,
-    invoicing_status: ApiOrderWriteResponseInvoicingStatus$inboundSchema,
-    notes: types.nullable(types.string()),
-    created_at: types.date(),
-    created_by_name: types.string(),
-    created_by: types.string(),
-    line_items: z.array(z.lazy(() =>
-      ApiOrderWriteResponseLineItem$inboundSchema
-    )),
-    active_warehouses: z.array(z.lazy(() =>
-      ApiOrderWriteResponseActiveWarehouse$inboundSchema
-    )),
-    pending_fulfillment_location_id: types.nullable(types.string()),
-    fulfillment_orders: z.array(z.lazy(() =>
-      ApiOrderWriteResponseFulfillmentOrder$inboundSchema
-    )),
-    fulfillments: z.array(z.any()),
-    generated_invoices: z.array(z.any()),
-  }),
-  z.transform((v) => {
-    return remap$(v, {
-      "order_number": "orderNumber",
-      "raw_order_number": "rawOrderNumber",
-      "order_date": "orderDate",
-      "customer_id": "customerId",
-      "customer_name": "customerName",
-      "customer_tax_id": "customerTaxId",
-      "items_count": "itemsCount",
-      "total_units": "totalUnits",
-      "discount_amount": "discountAmount",
-      "tax_amount": "taxAmount",
-      "order_status": "orderStatus",
-      "fulfillment_status": "fulfillmentStatus",
-      "invoicing_status": "invoicingStatus",
-      "created_at": "createdAt",
-      "created_by_name": "createdByName",
-      "created_by": "createdBy",
-      "line_items": "lineItems",
-      "active_warehouses": "activeWarehouses",
-      "pending_fulfillment_location_id": "pendingFulfillmentLocationId",
-      "fulfillment_orders": "fulfillmentOrders",
-      "generated_invoices": "generatedInvoices",
-    });
-  }),
-);
-
-export function orderFromJSON(
-  jsonString: string,
-): SafeParseResult<Order, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Order$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Order' from JSON`,
-  );
-}
-
 /** @internal */
 export const ApiOrderWriteResponseData$inboundSchema: z.ZodMiniType<
   ApiOrderWriteResponseData,
   unknown
 > = z.pipe(
   z.object({
-    order: z.lazy(() => Order$inboundSchema),
+    order: ApiSharedObject9223e6f740$inboundSchema,
     idempotent_replay: types.optional(types.boolean()),
     result: types.optional(z.any()),
   }),