vintrace-sdk 0.0.7 → 0.0.9

package/dist/index.cjs

@@ -146,7 +146,11 @@ async function vintraceFetch(baseUrl, organization, token, endpoint, method, opt
     Accept: "application/json"
   };
   if (options.validateRequest && options.requestSchema && body) {
-    const [validatedBody, requestError] = validateRequest(options.requestSchema, body, correlationId);
+    const [validatedBody, requestError] = validateRequest(
+      options.requestSchema,
+      body,
+      correlationId
+    );
     if (requestError) {
       return [null, requestError];
     }
@@ -285,8 +289,723 @@ async function vintraceFetch(baseUrl, organization, token, endpoint, method, opt
   }
 }
 
+// src/client/utils.ts
+async function batchFetch(ids, fetchFn) {
+  const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+  const errors = [];
+  const data = [];
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      const [item, error] = result.value;
+      if (error) {
+        errors.push(error);
+      } else if (item !== null) {
+        data.push(item);
+      }
+    } else {
+      errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
+    }
+  }
+  if (errors.length > 0) {
+    return [null, new VintraceAggregateError(errors)];
+  }
+  return [data, null];
+}
+var ExtIdentifiableEntitySchema = zod.z.object({
+  id: zod.z.number().optional(),
+  extId: zod.z.string().optional()
+});
+var IdentifiableEntitySchema = zod.z.object({
+  id: zod.z.number().optional()
+});
+var CodedIdentifiableEntitySchema = zod.z.object({
+  id: zod.z.number().optional(),
+  code: zod.z.string().optional()
+});
+var ResourceLinkSchema = zod.z.object({
+  rel: zod.z.string().optional(),
+  href: zod.z.string().optional()
+});
+var FieldValuePairSchema = zod.z.object({
+  fieldName: zod.z.string().optional(),
+  value: zod.z.unknown().optional()
+});
+var WorkOrderJobSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  type: zod.z.enum(["WINERY", "MRP"]).optional(),
+  jobNumber: zod.z.number().optional(),
+  status: zod.z.enum([
+    "INCOMPLETE",
+    "ASSIGNED",
+    "COMPLETED",
+    "ROLLBACK_REPLAY",
+    "IN_PROGRESS",
+    "PENDING_APPROVAL"
+  ]).optional(),
+  scheduledTime: zod.z.number().optional(),
+  finishedTime: zod.z.number().optional(),
+  link: ResourceLinkSchema.optional()
+});
+var WineryWorkOrderJobSchema = WorkOrderJobSchema.extend({
+  operationType: zod.z.string().optional()
+});
+var WorkOrderSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string().optional(),
+  assignedTo: ExtIdentifiableEntitySchema.optional(),
+  issuedBy: ExtIdentifiableEntitySchema.optional(),
+  status: zod.z.enum(["DRAFT", "READY", "IN_PROGRESS", "SUBMITTED", "COMPLETED", "CANCELLED", "REPLAY"]).optional(),
+  scheduledTime: zod.z.number().optional(),
+  summary: zod.z.string().optional(),
+  jobs: WineryWorkOrderJobSchema.array().optional()
+});
+zod.z.object({
+  totalResults: zod.z.number().optional(),
+  offset: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  first: zod.z.string().optional(),
+  previous: zod.z.string().optional(),
+  next: zod.z.string().optional(),
+  last: zod.z.string().optional(),
+  results: WorkOrderSchema.array().optional()
+});
+var ProductLiveMetricMeasurementSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  value: zod.z.number().optional(),
+  unit: zod.z.string().optional(),
+  maxVal: zod.z.number().optional()
+});
+var ProductLiveMetricSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  measurements: ProductLiveMetricMeasurementSchema.array().optional()
+});
+var VolumeSchema = zod.z.object({
+  value: zod.z.number().optional(),
+  unit: zod.z.string().optional()
+});
+var BeverageTypePropertiesSchema = zod.z.record(zod.z.string(), zod.z.unknown());
+var ProductSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  batchCode: zod.z.string().optional(),
+  vesselId: zod.z.number().optional(),
+  description: zod.z.string().optional(),
+  descriptionCanEdit: zod.z.boolean().optional(),
+  volume: VolumeSchema.optional(),
+  vesselCode: zod.z.string().optional(),
+  hasDipTable: zod.z.boolean().optional(),
+  dipTableEndpoint: zod.z.string().optional(),
+  colour: zod.z.string().optional(),
+  physicalProductState: zod.z.string().optional(),
+  vesselType: zod.z.string().optional(),
+  productStatus: zod.z.string().optional(),
+  productAnalysisEndpoint: zod.z.string().optional(),
+  productCompositionEndpoint: zod.z.string().optional(),
+  productEndpoint: zod.z.string().optional(),
+  liveMetrics: ProductLiveMetricSchema.array().optional(),
+  fieldValuePairs: FieldValuePairSchema.array().optional(),
+  canAccessNotes: zod.z.boolean().optional(),
+  notesCount: zod.z.number().optional(),
+  notesEndpoint: zod.z.string().optional(),
+  beverageTypeProperties: BeverageTypePropertiesSchema.optional()
+});
+var ProductVesselDetailsSchema = zod.z.object({
+  vesselId: zod.z.number().optional(),
+  containerType: zod.z.enum(["Tank", "Barrel", "Barrel group", "Bin group", "Press", "Bin", "Tanker"]).optional()
+});
+var ProductResponseSchema = zod.z.object({
+  status: zod.z.string().optional(),
+  product: ProductSchema.optional(),
+  vessel: ProductVesselDetailsSchema.optional()
+});
+var ProductListResponseSchema = zod.z.object({
+  status: zod.z.string().optional(),
+  products: ProductSchema.array().optional(),
+  totalResultCount: zod.z.number().optional(),
+  firstResult: zod.z.number().optional(),
+  maxResult: zod.z.number().optional(),
+  nextURLPath: zod.z.string().nullable().optional(),
+  prevURLPath: zod.z.string().nullable().optional()
+});
+var ProductUpdateFieldSchema = zod.z.object({
+  propertyType: zod.z.string().optional(),
+  propertyValue: zod.z.string().optional(),
+  propertyId: zod.z.number().optional()
+});
+var ProductUpdateDataSchema = zod.z.object({
+  productId: zod.z.number().optional(),
+  updateFields: ProductUpdateFieldSchema.array().optional()
+});
+var ProductUpdateResponseSchema = zod.z.object({
+  status: zod.z.string().optional(),
+  product: ProductSchema.optional()
+});
+var AddressSchema = zod.z.object({
+  street1: zod.z.string().nullable(),
+  street2: zod.z.string().nullable(),
+  city: zod.z.string().nullable(),
+  state: zod.z.string().nullable(),
+  postalCode: zod.z.string().nullable(),
+  country: zod.z.string().nullable()
+});
+var SendToAddressSchema = zod.z.object({
+  name: zod.z.string().nullable(),
+  phone: zod.z.string().nullable(),
+  address: AddressSchema.nullable()
+});
+var TaxBreakdownSchema = zod.z.object({
+  name: zod.z.string(),
+  amount: zod.z.number(),
+  ratePct: zod.z.number(),
+  inclusive: zod.z.boolean()
+});
+var SalesOrderItemSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  itemId: zod.z.number().optional(),
+  itemName: zod.z.string().optional(),
+  unitPrice: zod.z.number().optional(),
+  quantity: zod.z.number().optional(),
+  unitOfMeasure: zod.z.string().nullable(),
+  discountPct: zod.z.number().nullable(),
+  adjustment: zod.z.number().nullable(),
+  taxAmount: zod.z.number().optional(),
+  lineTotal: zod.z.number().optional(),
+  accountId: zod.z.number().optional(),
+  accountCode: zod.z.string().optional(),
+  taxRateId: zod.z.number().optional(),
+  taxRateName: zod.z.string().nullable()
+});
+var PriceDetailsSchema = zod.z.object({
+  countryCurrencyCode: zod.z.string().optional(),
+  taxPolicy: zod.z.string().optional()
+});
+var SalesOrderSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  invoiceDate: zod.z.number().nullable(),
+  invoiceDateAsText: zod.z.string(),
+  customerId: zod.z.number().optional(),
+  customerName: zod.z.string().optional(),
+  sendTo: SendToAddressSchema.optional(),
+  salesType: zod.z.string().optional(),
+  salesPriceListId: zod.z.number().nullable(),
+  salesPriceListName: zod.z.string().nullable(),
+  priceDetails: PriceDetailsSchema.optional(),
+  salesOrderStatus: zod.z.string().optional(),
+  salesOrderItems: SalesOrderItemSchema.array().optional(),
+  code: zod.z.string().optional(),
+  description: zod.z.string().nullable(),
+  reference: zod.z.string().nullable(),
+  orderDate: zod.z.number().optional(),
+  orderDateAsText: zod.z.string(),
+  wineryId: zod.z.number().nullable(),
+  wineryName: zod.z.string().nullable(),
+  fulfillment: zod.z.string().optional(),
+  fulfillmentDate: zod.z.number().nullable(),
+  fulfillmentDateAsText: zod.z.string(),
+  salesRegionId: zod.z.number().nullable(),
+  salesRegionCode: zod.z.string().nullable(),
+  notes: zod.z.string().nullable(),
+  customerPickup: zod.z.boolean().optional(),
+  disableAccountsSync: zod.z.boolean().optional(),
+  subTotal: zod.z.number().optional(),
+  taxBreakdown: TaxBreakdownSchema.array().optional(),
+  total: zod.z.number().optional(),
+  acctReference: zod.z.string().nullable(),
+  posSaleReference: zod.z.string().nullable(),
+  ignoreStockError: zod.z.boolean().optional()
+});
+var SalesOrderResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable(),
+  salesOrders: SalesOrderSchema.array(),
+  totalResultCount: zod.z.number().optional(),
+  firstResult: zod.z.number().optional(),
+  maxResult: zod.z.number().optional(),
+  nextURLPath: zod.z.string().nullable().optional(),
+  prevURLPath: zod.z.string().nullable().optional()
+});
+var SalesOrderUpdateResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable(),
+  salesOrder: SalesOrderSchema.optional()
+});
+var RefundLineItemSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  itemId: zod.z.number().optional(),
+  itemName: zod.z.string().optional(),
+  unitPrice: zod.z.number().optional(),
+  returnQuantity: zod.z.number().optional(),
+  returnTotal: zod.z.number().optional(),
+  taxAmount: zod.z.number().optional()
+});
+var RefundSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string().optional(),
+  refundDate: zod.z.number().optional(),
+  refundDateAsText: zod.z.string(),
+  reference: zod.z.string().nullable(),
+  stockReturned: zod.z.boolean().optional(),
+  storageAreaId: zod.z.number().nullable(),
+  storageAreaName: zod.z.string().nullable(),
+  customerId: zod.z.number().optional(),
+  customerName: zod.z.string().optional(),
+  refundStatus: zod.z.string().optional(),
+  notes: zod.z.string().nullable(),
+  salesOrderId: zod.z.number().optional(),
+  salesOrderName: zod.z.string().optional(),
+  subTotal: zod.z.number().optional(),
+  total: zod.z.number().optional(),
+  taxBreakdown: TaxBreakdownSchema.array().optional(),
+  refundLineItems: RefundLineItemSchema.array().optional(),
+  posSaleReference: zod.z.string().nullable(),
+  disableAccountsSync: zod.z.boolean().optional(),
+  acctReference: zod.z.string().nullable()
+});
+var RefundResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable(),
+  refunds: RefundSchema.array(),
+  totalResultCount: zod.z.number().optional(),
+  firstResult: zod.z.number().optional(),
+  maxResult: zod.z.number().optional(),
+  nextURLPath: zod.z.string().nullable().optional(),
+  prevURLPath: zod.z.string().nullable().optional()
+});
+var RefundUpdateResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable(),
+  refund: RefundSchema.optional()
+});
+var PartySchema = zod.z.object({
+  id: zod.z.number().optional(),
+  primeName: zod.z.string().optional(),
+  givenName: zod.z.string().nullable(),
+  phone: zod.z.string().nullable(),
+  email: zod.z.string().nullable(),
+  address: AddressSchema.optional(),
+  isOrganization: zod.z.boolean().optional()
+});
+var PartyResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable(),
+  parties: PartySchema.array(),
+  totalResultCount: zod.z.number().optional(),
+  firstResult: zod.z.number().optional(),
+  maxResult: zod.z.number().optional(),
+  nextURLPath: zod.z.string().nullable().optional(),
+  prevURLPath: zod.z.string().nullable().optional()
+});
+var WorkOrderJobDetailSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  code: zod.z.string().optional(),
+  scheduledDate: zod.z.number().nullable(),
+  finishedDate: zod.z.number().nullable(),
+  scheduledDateAsText: zod.z.string(),
+  finishedDateAsText: zod.z.string(),
+  status: zod.z.string().optional(),
+  assignedBy: zod.z.string().optional(),
+  assignedTo: zod.z.string().optional(),
+  summaryText: zod.z.string().optional(),
+  miniSummaryText: zod.z.string().optional(),
+  jobColour: zod.z.string().optional(),
+  jobNumber: zod.z.number().optional(),
+  stepText: zod.z.string().nullable(),
+  steps: zod.z.array(zod.z.unknown()).optional(),
+  endpointURL: zod.z.string().optional(),
+  jobVersion: zod.z.number().optional(),
+  workOrderId: zod.z.number().optional()
+});
+var WorkOrderDetailSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  code: zod.z.string().optional(),
+  jobCount: zod.z.number().optional(),
+  jobCountText: zod.z.string().optional(),
+  status: zod.z.string().optional(),
+  assignedTo: zod.z.string().optional(),
+  assignedBy: zod.z.string().optional(),
+  assignedDate: zod.z.number().optional(),
+  scheduledDate: zod.z.number().nullable(),
+  assignedDateAsText: zod.z.string(),
+  scheduledDateAsText: zod.z.string(),
+  canAssign: zod.z.boolean().optional(),
+  summary: zod.z.string().optional(),
+  indicators: zod.z.array(zod.z.string()).optional(),
+  bond: zod.z.string().nullable(),
+  winery: zod.z.string().nullable(),
+  jobs: WorkOrderJobDetailSchema.array().optional(),
+  colourCode: zod.z.string().optional(),
+  endpointURL: zod.z.string().optional()
+});
+var WorkOrderSearchResponseSchema = zod.z.object({
+  firstResult: zod.z.number().optional(),
+  maxResult: zod.z.number().optional(),
+  totalResultCount: zod.z.number().optional(),
+  nextURLPath: zod.z.string().nullable(),
+  prevURLPath: zod.z.string().nullable(),
+  listText: zod.z.string().optional(),
+  workOrders: WorkOrderDetailSchema.array().optional()
+});
+var AssignWorkDataSchema = zod.z.object({
+  workOrderId: zod.z.number().optional()
+});
+var AssignWorkResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable(),
+  jobEndpointURL: zod.z.string().nullable(),
+  workOrderEndpointURL: zod.z.string().optional()
+});
+var SubmitJobFieldSchema = zod.z.object({
+  fieldId: zod.z.string(),
+  value: zod.z.string().optional()
+});
+var SubmitJobRequestSchema = zod.z.object({
+  jobId: zod.z.number().optional(),
+  submitType: zod.z.string().optional(),
+  fields: SubmitJobFieldSchema.array().optional()
+});
+var SubmitWorkOrderStepsResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().optional()
+});
+var PartyUpdateResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable(),
+  party: PartySchema.optional()
+});
+var SalesOrderWriteSchema = SalesOrderSchema.partial();
+var RefundWriteSchema = RefundSchema.partial();
+var PartyWriteSchema = PartySchema.partial();
+zod.z.object({
+  dateFrom: zod.z.string().optional(),
+  dateTo: zod.z.string().optional(),
+  ownerName: zod.z.string().optional(),
+  batchName: zod.z.string().optional(),
+  wineryName: zod.z.string().optional(),
+  maxResults: zod.z.number().optional(),
+  firstResult: zod.z.number().optional()
+});
+zod.z.object({
+  modifiedSince: zod.z.string().optional(),
+  operationId: zod.z.number().optional(),
+  processId: zod.z.number().optional(),
+  deliveryDocket: zod.z.string().optional(),
+  intakeDocket: zod.z.string().optional(),
+  externalWeighTag: zod.z.string().optional(),
+  externalSystemBlocksOnly: zod.z.boolean().optional(),
+  externalBlockId: zod.z.string().optional(),
+  blockId: zod.z.number().optional(),
+  blockName: zod.z.string().optional(),
+  vineyardId: zod.z.number().optional(),
+  vineyardName: zod.z.string().optional(),
+  wineryId: zod.z.number().optional(),
+  wineryName: zod.z.string().optional(),
+  growerType: zod.z.string().optional(),
+  growerId: zod.z.number().optional(),
+  growerName: zod.z.string().optional(),
+  ownerId: zod.z.number().optional(),
+  ownerName: zod.z.string().optional(),
+  vintage: zod.z.string().optional(),
+  recordedAfter: zod.z.string().optional(),
+  recordedBefore: zod.z.string().optional(),
+  customAdapter: zod.z.string().optional(),
+  maxResults: zod.z.number().optional(),
+  firstResult: zod.z.number().optional()
+});
+zod.z.object({
+  modifiedSince: zod.z.string().optional(),
+  operationId: zod.z.number().optional(),
+  processId: zod.z.number().optional(),
+  externalSystemBlocksOnly: zod.z.boolean().optional(),
+  externalBlockId: zod.z.string().optional(),
+  blockId: zod.z.number().optional(),
+  blockName: zod.z.string().optional(),
+  vineyardId: zod.z.number().optional(),
+  vineyardName: zod.z.string().optional(),
+  growerId: zod.z.number().optional(),
+  growerName: zod.z.string().optional(),
+  ownerId: zod.z.number().optional(),
+  ownerName: zod.z.string().optional(),
+  vintage: zod.z.string().optional(),
+  recordedAfter: zod.z.string().optional(),
+  recordedBefore: zod.z.string().optional(),
+  customAdapter: zod.z.string().optional(),
+  maxResults: zod.z.number().optional(),
+  firstResult: zod.z.number().optional()
+});
+zod.z.object({
+  max: zod.z.string().optional(),
+  first: zod.z.string().optional(),
+  date: zod.z.string().optional(),
+  stockType: zod.z.string().optional(),
+  ownerName: zod.z.string().optional(),
+  showEquivalentType: zod.z.string().optional(),
+  breakoutCosting: zod.z.boolean().optional(),
+  disableCommitHeaders: zod.z.boolean().optional()
+});
+zod.z.object({
+  type: zod.z.string(),
+  first: zod.z.string().optional(),
+  startsWith: zod.z.string().optional(),
+  exactMatch: zod.z.boolean().optional(),
+  max: zod.z.string().optional()
+});
+zod.z.object({
+  firstResult: zod.z.number(),
+  maxResult: zod.z.number()
+});
+zod.z.object({
+  firstResult: zod.z.number().optional(),
+  maxResult: zod.z.number().optional()
+});
+var RateOfChangeSchema = zod.z.object({
+  value: zod.z.number().nullable(),
+  sign: zod.z.string().nullable(),
+  absValue: zod.z.number().nullable(),
+  unit: zod.z.string().nullable(),
+  description: zod.z.string().nullable()
+});
+var AnalysisMeasurementSchema = zod.z.object({
+  value: zod.z.string(),
+  rateOfChange: RateOfChangeSchema.nullable(),
+  measurementDateText: zod.z.string(),
+  measurementDate: zod.z.number(),
+  resultId: zod.z.number(),
+  processId: zod.z.number(),
+  canDelete: zod.z.boolean(),
+  canEdit: zod.z.boolean(),
+  canReverse: zod.z.boolean(),
+  measurementValidity: zod.z.string()
+});
+var AnalysisMetricDataSchema = zod.z.object({
+  id: zod.z.number(),
+  name: zod.z.string(),
+  unit: zod.z.string(),
+  dataType: zod.z.string(),
+  dataTypeValues: zod.z.unknown().nullable(),
+  minVal: zod.z.number().nullable(),
+  maxVal: zod.z.number().nullable(),
+  grouping: zod.z.unknown().nullable(),
+  canAddValue: zod.z.boolean(),
+  measurements: AnalysisMeasurementSchema.array(),
+  result: zod.z.unknown().nullable()
+});
+var ProductMetricDataSchema = zod.z.object({
+  id: zod.z.number(),
+  name: zod.z.string(),
+  nextURL: zod.z.string().nullable(),
+  metricDataList: AnalysisMetricDataSchema.array()
+});
+var ProductAnalysisResponseSchema = zod.z.object({
+  productId: zod.z.number(),
+  batchCode: zod.z.string(),
+  description: zod.z.string(),
+  canAddResult: zod.z.boolean(),
+  productMetricDataList: ProductMetricDataSchema.array()
+});
+zod.z.object({
+  startDate: zod.z.string().optional(),
+  endDate: zod.z.string().optional(),
+  metricId: zod.z.number().optional(),
+  weighting: zod.z.number().optional()
+});
+var CompositionComponentSchema = zod.z.object({
+  productId: zod.z.number().optional(),
+  batchCode: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  vintage: zod.z.string().nullable().optional(),
+  variety: zod.z.string().nullable().optional(),
+  region: zod.z.string().nullable().optional(),
+  percentage: zod.z.number().optional(),
+  volume: VolumeSchema.optional()
+});
+var ProductCompositionResponseSchema = zod.z.object({
+  productId: zod.z.number().optional(),
+  batchCode: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  components: CompositionComponentSchema.array().optional()
+});
+var PaginatedResponseSchema = (itemSchema) => zod.z.object({
+  totalResults: zod.z.number().optional(),
+  offset: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  first: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  next: zod.z.string().nullable().optional(),
+  last: zod.z.string().nullable().optional(),
+  results: zod.z.array(itemSchema).optional()
+});
+var BlockDataSchema = zod.z.object({
+  id: zod.z.number(),
+  code: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  extId: zod.z.string().optional(),
+  inactive: zod.z.boolean().optional()
+});
+var GetBlocksSuccessResponseSchema = PaginatedResponseSchema(BlockDataSchema);
+var V6PaginatedResponseSchema = zod.z.object({
+  totalResultCount: zod.z.number().optional(),
+  firstResult: zod.z.number().optional(),
+  maxResult: zod.z.number().optional(),
+  nextURLPath: zod.z.string().nullable().optional(),
+  prevURLPath: zod.z.string().nullable().optional(),
+  results: zod.z.array(zod.z.unknown()).optional()
+});
+var InventoryResponseSchema = V6PaginatedResponseSchema;
+var TransactionSearchResponseSchema = V6PaginatedResponseSchema;
+var IntakeOperationSearchResponseSchema = V6PaginatedResponseSchema;
+var SampleOperationSearchResponseSchema = V6PaginatedResponseSchema;
+var SearchListResponseSchema = V6PaginatedResponseSchema;
+var MeasurementSchema = zod.z.object({
+  value: zod.z.number().optional(),
+  unit: zod.z.string().optional()
+});
+var WinerySchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string().optional(),
+  businessUnit: zod.z.string().optional()
+});
+var GradingSchema = zod.z.object({
+  scaleId: zod.z.number().optional(),
+  scaleName: zod.z.string().optional(),
+  valueId: zod.z.number().optional(),
+  valueName: zod.z.string().optional()
+});
+var WineBatchDetailsSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  vintage: zod.z.string().optional(),
+  designatedRegion: CodedIdentifiableEntitySchema.optional(),
+  designatedSubRegion: CodedIdentifiableEntitySchema.optional(),
+  designatedVariety: CodedIdentifiableEntitySchema.optional(),
+  program: zod.z.string().optional(),
+  productCategory: CodedIdentifiableEntitySchema.optional(),
+  designatedProduct: CodedIdentifiableEntitySchema.optional(),
+  grading: GradingSchema.optional()
+});
+var ProductStateSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string().optional(),
+  expectedLossesPercentage: zod.z.number().optional()
+});
+var TaxDetailsSchema = zod.z.object({
+  bond: IdentifiableEntitySchema.optional(),
+  name: zod.z.string().optional(),
+  taxState: zod.z.string().optional(),
+  taxClass: IdentifiableEntitySchema.optional(),
+  federalName: zod.z.string().optional(),
+  stateName: zod.z.string().optional()
+});
+var AllocationSliceSchema = zod.z.object({
+  product: CodedIdentifiableEntitySchema.optional(),
+  vintage: zod.z.string().optional(),
+  itemCode: zod.z.string().optional(),
+  allocationVolume: MeasurementSchema.optional(),
+  allocationPercentageOfVessel: zod.z.number().optional()
+});
+var CompositionSliceSchema = zod.z.object({
+  vintage: zod.z.string().optional(),
+  variety: CodedIdentifiableEntitySchema.optional(),
+  region: CodedIdentifiableEntitySchema.optional(),
+  subRegion: CodedIdentifiableEntitySchema.optional(),
+  weighting: zod.z.number().optional(),
+  percentage: zod.z.number().optional(),
+  componentVolume: MeasurementSchema.optional()
+});
+var CostBreakdownSchema = zod.z.object({
+  total: zod.z.number().optional(),
+  fruit: zod.z.number().optional(),
+  overhead: zod.z.number().optional(),
+  storage: zod.z.number().optional(),
+  additive: zod.z.number().optional(),
+  bulk: zod.z.number().optional(),
+  packaging: zod.z.number().optional(),
+  operation: zod.z.number().optional(),
+  freight: zod.z.number().optional(),
+  other: zod.z.number().optional()
+});
+var LiveMetricSchema = zod.z.object({
+  name: zod.z.string().optional(),
+  value: zod.z.number().optional(),
+  interfaceMappedName: zod.z.string().optional()
+});
+var SparklingInfoSchema = zod.z.object({
+  state: zod.z.string().optional()
+});
+var BulkWineDetailsSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  productId: zod.z.number().optional(),
+  name: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  vesselType: zod.z.string().optional(),
+  detailsAsAt: zod.z.number().optional(),
+  sparklingInfo: SparklingInfoSchema.optional(),
+  beverageType: IdentifiableEntitySchema.optional(),
+  owner: ExtIdentifiableEntitySchema.optional(),
+  winery: WinerySchema.optional(),
+  wineBatch: WineBatchDetailsSchema.optional(),
+  productState: ProductStateSchema.optional(),
+  volume: MeasurementSchema.optional(),
+  capacity: MeasurementSchema.optional(),
+  ullage: MeasurementSchema.optional(),
+  ttbDetails: TaxDetailsSchema.optional(),
+  liveMetrics: zod.z.array(LiveMetricSchema).optional(),
+  cost: CostBreakdownSchema.optional(),
+  composition: zod.z.array(CompositionSliceSchema).optional(),
+  allocations: zod.z.array(AllocationSliceSchema).optional(),
+  unallocatedVolume: MeasurementSchema.optional(),
+  unallocatedPercentageOfVessel: zod.z.number().optional()
+});
+var GetBulkWineDetailsReportResponseSchema = zod.z.object({
+  totalResults: zod.z.number().optional(),
+  offset: zod.z.number().optional(),
+  limit: zod.z.number().optional(),
+  first: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  next: zod.z.string().nullable().optional(),
+  last: zod.z.string().nullable().optional(),
+  results: zod.z.array(BulkWineDetailsSchema).optional()
+});
+var ProductJobAttachmentSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  name: zod.z.string().optional(),
+  url: zod.z.string().optional()
+});
+var ProductJobSchema = zod.z.object({
+  operationId: zod.z.number(),
+  processId: zod.z.number(),
+  operatorName: zod.z.string().optional(),
+  completedDate: zod.z.number().optional(),
+  completedDateText: zod.z.string().optional(),
+  summary: zod.z.string().optional(),
+  operationName: zod.z.string().optional(),
+  workOrderNumber: zod.z.string().nullable().optional(),
+  reversible: zod.z.boolean().optional(),
+  attachments: ProductJobAttachmentSchema.array().optional()
+});
+var ProductJobDetailsSchema = zod.z.object({
+  productId: zod.z.number(),
+  batchId: zod.z.number().optional(),
+  vesselId: zod.z.number().optional(),
+  batchCode: zod.z.string().nullable().optional(),
+  vesselCode: zod.z.string().nullable().optional(),
+  canReverseJobs: zod.z.boolean().optional(),
+  jobs: ProductJobSchema.array().optional()
+});
+var ProductJobResponseSchema = zod.z.object({
+  status: zod.z.string(),
+  message: zod.z.string().nullable().optional(),
+  jobDetails: ProductJobDetailsSchema
+});
+
 // src/client/VintraceClient.ts
 var VintraceClient = class {
+  /**
+   * Creates a new VintraceClient instance.
+   *
+   * @param config - The client configuration containing baseUrl, organization, and token.
+   */
   constructor(config) {
     this.baseUrl = config.baseUrl;
     this.organization = config.organization;
@@ -295,6 +1014,15 @@ var VintraceClient = class {
     this.v6 = new VintraceV6Api(this);
     this.v7 = new VintraceV7Api(this);
   }
+  /**
+   * Makes a request to the Vintrace API.
+   *
+   * @param endpoint - The API endpoint path (e.g., 'v6/workorders/list')
+   * @param method - The HTTP method (GET, POST, PUT, PATCH, DELETE)
+   * @param options - Request options including timeout, maxRetries, and validation settings
+   * @param body - Optional request body for POST, PUT, PATCH requests
+   * @returns A promise that resolves to a VintraceResult tuple [data, error]
+   */
   request(endpoint, method, options, body) {
     return vintraceFetch(
       this.baseUrl,
@@ -317,46 +1045,49 @@ var VintraceV6Api = class {
     this.client = client;
   }
   get workOrders() {
-    return new WorkOrdersClient(this.client);
+    return this._workOrders ?? (this._workOrders = new WorkOrdersClient(this.client));
   }
   get salesOrders() {
-    return new SalesOrdersClient(this.client);
+    return this._salesOrders ?? (this._salesOrders = new SalesOrdersClient(this.client));
   }
   get refunds() {
-    return new RefundsClient(this.client);
+    return this._refunds ?? (this._refunds = new RefundsClient(this.client));
   }
   get parties() {
-    return new PartiesClient(this.client);
+    return this._parties ?? (this._parties = new PartiesClient(this.client));
   }
   get products() {
-    return new ProductsClient(this.client);
+    return this._products ?? (this._products = new ProductsClient(this.client));
   }
   get transactions() {
-    return new TransactionsClient(this.client);
+    return this._transactions ?? (this._transactions = new TransactionsClient(this.client));
   }
   get intakeOperations() {
-    return new IntakeOperationsClient(this.client);
+    return this._intakeOperations ?? (this._intakeOperations = new IntakeOperationsClient(this.client));
   }
   get sampleOperations() {
-    return new SampleOperationsClient(this.client);
+    return this._sampleOperations ?? (this._sampleOperations = new SampleOperationsClient(this.client));
   }
   get blockAssessments() {
-    return new BlockAssessmentsClient(this.client);
+    return this._blockAssessments ?? (this._blockAssessments = new BlockAssessmentsClient(this.client));
   }
   get mrpStock() {
-    return new MrpStockClient(this.client);
+    return this._mrpStock ?? (this._mrpStock = new MrpStockClient(this.client));
   }
   get inventory() {
-    return new InventoryClient(this.client);
+    return this._inventory ?? (this._inventory = new InventoryClient(this.client));
   }
   get search() {
-    return new SearchClient(this.client);
+    return this._search ?? (this._search = new SearchClient(this.client));
   }
   get productAnalysis() {
-    return new ProductAnalysisClient(this.client);
+    return this._productAnalysis ?? (this._productAnalysis = new ProductAnalysisClient(this.client));
   }
   get productComposition() {
-    return new ProductCompositionClient(this.client);
+    return this._productComposition ?? (this._productComposition = new ProductCompositionClient(this.client));
+  }
+  get productJobs() {
+    return this._productJobs ?? (this._productJobs = new ProductJobsClient(this.client));
   }
 };
 var VintraceV7Api = class {
@@ -364,224 +1095,436 @@ var VintraceV7Api = class {
     this.client = client;
   }
   get blocks() {
-    return new BlocksClient(this.client);
+    return this._blocks ?? (this._blocks = new BlocksClient(this.client));
   }
   get bookings() {
-    return new BookingsClient(this.client);
+    return this._bookings ?? (this._bookings = new BookingsClient(this.client));
   }
   get vesselDetailsReport() {
-    return new VesselDetailsReportClient(this.client);
+    return this._vesselDetailsReport ?? (this._vesselDetailsReport = new VesselDetailsReportClient(this.client));
   }
 };
 var WorkOrdersClient = class {
   constructor(client) {
     this.client = client;
   }
-  getAll(params) {
-    return this.client.request("v6/workorders/list", "GET", {}, params);
+  /**
+   * List available work orders.
+   *
+   * By default returns a list of all work orders that are in "Ready",
+   * "In progress", or "Submitted" states and are assigned to me or unassigned
+   * with a date range from 7 days ago to 3 days from now.
+   */
+  async getAll(params) {
+    const limit = params?.max ? parseInt(params.max, 10) : 100;
+    const firstResponse = await this.client.request(
+      "v6/workorders/list",
+      "GET",
+      { responseSchema: WorkOrderSearchResponseSchema },
+      { ...params, max: String(limit), first: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.workOrders?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.workOrders ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.workOrders ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/workorders/list",
+            "GET",
+            { responseSchema: WorkOrderSearchResponseSchema },
+            { ...params, max: String(limit), first: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.workOrders) {
+          allResults.push(...pageData.workOrders);
+        }
+      }
+    }
+    return [allResults, null];
   }
   get(id) {
-    return this.client.request(`v6/workorders/${id}`, "GET");
+    return this.client.request(`v6/workorders/${id}`, "GET", {
+      responseSchema: WorkOrderDetailSchema
+    });
   }
   getByCode(code) {
-    return this.client.request("v6/workorders", "GET", {}, { code });
+    return this.client.request(
+      "v6/workorders",
+      "GET",
+      { responseSchema: WorkOrderDetailSchema },
+      { code }
+    );
   }
   getJob(jobId) {
     return this.client.request(`v6/workorders/jobs/${jobId}`, "GET");
   }
   assign(workOrderId) {
-    return this.client.request("v6/workorders/assign", "POST", {}, { workOrderId });
+    return this.client.request(
+      "v6/workorders/assign",
+      "POST",
+      { responseSchema: AssignWorkResponseSchema, requestSchema: AssignWorkDataSchema },
+      { workOrderId }
+    );
   }
   submit(data) {
-    return this.client.request("v6/workorders/submit", "POST", {}, data);
+    return this.client.request(
+      "v6/workorders/submit",
+      "POST",
+      { responseSchema: SubmitWorkOrderStepsResponseSchema, requestSchema: SubmitJobRequestSchema },
+      data
+    );
   }
   getMany(ids) {
-    return this.batchGet(ids, (id) => this.get(id));
-  }
-  async batchGet(ids, fetchFn) {
-    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
-    const errors = [];
-    const data = [];
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        const [item, error] = result.value;
-        if (error) {
-          errors.push(error);
-        } else if (item !== null) {
-          data.push(item);
-        }
-      } else {
-        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
-      }
-    }
-    if (errors.length > 0) {
-      return [null, new VintraceAggregateError(errors)];
-    }
-    return [data, null];
+    return batchFetch(ids, (id) => this.get(id));
   }
 };
 var SalesOrdersClient = class {
   constructor(client) {
     this.client = client;
   }
-  getAll(params) {
-    return this.client.request("v6/sales-order/list", "GET", {}, params);
+  /**
+   * List available sales orders.
+   *
+   * Returns a list of the first 100 sales orders.
+   */
+  async getAll(params) {
+    const limit = params?.max ? parseInt(params.max, 10) : 100;
+    const firstResponse = await this.client.request(
+      "v6/sales-order/list",
+      "GET",
+      { responseSchema: SalesOrderResponseSchema },
+      { ...params, max: String(limit), first: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.salesOrders?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.salesOrders ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.salesOrders ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/sales-order/list",
+            "GET",
+            { responseSchema: SalesOrderResponseSchema },
+            { ...params, max: String(limit), first: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.salesOrders) {
+          allResults.push(...pageData.salesOrders);
+        }
+      }
+    }
+    return [allResults, null];
   }
   get(id) {
-    return this.client.request(`v6/sales-order/${id}`, "GET");
+    return this.client.request(`v6/sales-order/${id}`, "GET", {
+      responseSchema: SalesOrderSchema
+    });
   }
   getByCode(code) {
-    return this.client.request("v6/sales-order", "GET", {}, { code });
+    return this.client.request(
+      "v6/sales-order",
+      "GET",
+      { responseSchema: SalesOrderSchema },
+      { code }
+    );
   }
   create(data) {
-    return this.client.request("v6/sales-order", "POST", {}, data);
+    return this.client.request(
+      "v6/sales-order",
+      "POST",
+      { responseSchema: SalesOrderUpdateResponseSchema, requestSchema: SalesOrderWriteSchema },
+      data
+    );
   }
   update(id, data) {
-    return this.client.request(`v6/sales-order/${id}`, "PUT", {}, data);
+    return this.client.request(
+      `v6/sales-order/${id}`,
+      "PUT",
+      { responseSchema: SalesOrderUpdateResponseSchema, requestSchema: SalesOrderWriteSchema },
+      data
+    );
   }
   getMany(ids) {
-    return this.batchGet(ids, (id) => this.get(id));
-  }
-  async batchGet(ids, fetchFn) {
-    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
-    const errors = [];
-    const data = [];
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        const [item, error] = result.value;
-        if (error) {
-          errors.push(error);
-        } else if (item !== null) {
-          data.push(item);
-        }
-      } else {
-        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
-      }
-    }
-    if (errors.length > 0) {
-      return [null, new VintraceAggregateError(errors)];
-    }
-    return [data, null];
+    return batchFetch(ids, (id) => this.get(id));
   }
 };
 var RefundsClient = class {
   constructor(client) {
     this.client = client;
   }
-  getAll(params) {
-    return this.client.request("v6/refund/list", "GET", {}, params);
+  /**
+   * List available refunds.
+   *
+   * Returns a list of the first 100 refunds.
+   */
+  async getAll(params) {
+    const limit = params?.max ? parseInt(params.max, 10) : 100;
+    const firstResponse = await this.client.request(
+      "v6/refund/list",
+      "GET",
+      { responseSchema: RefundResponseSchema },
+      { ...params, max: String(limit), first: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.refunds?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.refunds ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.refunds ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/refund/list",
+            "GET",
+            { responseSchema: RefundResponseSchema },
+            { ...params, max: String(limit), first: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.refunds) {
+          allResults.push(...pageData.refunds);
+        }
+      }
+    }
+    return [allResults, null];
   }
   get(id) {
-    return this.client.request(`v6/refund/${id}`, "GET");
+    return this.client.request(`v6/refund/${id}`, "GET", { responseSchema: RefundSchema });
   }
   getByCode(code) {
-    return this.client.request("v6/refund", "GET", {}, { code });
+    return this.client.request(
+      "v6/refund",
+      "GET",
+      { responseSchema: RefundSchema },
+      { code }
+    );
   }
   create(data) {
-    return this.client.request("v6/refund", "POST", {}, data);
+    return this.client.request(
+      "v6/refund",
+      "POST",
+      { responseSchema: RefundUpdateResponseSchema, requestSchema: RefundWriteSchema },
+      data
+    );
   }
   update(id, data) {
-    return this.client.request(`v6/refund/${id}`, "PUT", {}, data);
+    return this.client.request(
+      `v6/refund/${id}`,
+      "PUT",
+      { responseSchema: RefundUpdateResponseSchema, requestSchema: RefundWriteSchema },
+      data
+    );
   }
   getMany(ids) {
-    return this.batchGet(ids, (id) => this.get(id));
-  }
-  async batchGet(ids, fetchFn) {
-    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
-    const errors = [];
-    const data = [];
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        const [item, error] = result.value;
-        if (error) {
-          errors.push(error);
-        } else if (item !== null) {
-          data.push(item);
-        }
-      } else {
-        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
-      }
-    }
-    if (errors.length > 0) {
-      return [null, new VintraceAggregateError(errors)];
-    }
-    return [data, null];
+    return batchFetch(ids, (id) => this.get(id));
   }
 };
 var PartiesClient = class {
   constructor(client) {
     this.client = client;
   }
-  getAll(params) {
-    return this.client.request("v6/party/list", "GET", {}, params);
+  /**
+   * List parties.
+   *
+   * Returns a list of the first 100 parties.
+   */
+  async getAll(params) {
+    const limit = params?.max ? parseInt(params.max, 10) : 100;
+    const firstResponse = await this.client.request(
+      "v6/party/list",
+      "GET",
+      { responseSchema: PartyResponseSchema },
+      { ...params, max: String(limit), first: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.parties?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.parties ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.parties ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/party/list",
+            "GET",
+            { responseSchema: PartyResponseSchema },
+            { ...params, max: String(limit), first: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.parties) {
+          allResults.push(...pageData.parties);
+        }
+      }
+    }
+    return [allResults, null];
   }
   get(id) {
-    return this.client.request(`v6/party/${id}`, "GET");
+    return this.client.request(`v6/party/${id}`, "GET", { responseSchema: PartySchema });
   }
   getByName(name) {
-    return this.client.request("v6/party", "GET", {}, { name });
+    return this.client.request("v6/party", "GET", { responseSchema: PartySchema }, { name });
   }
   create(data) {
-    return this.client.request("v6/party", "POST", {}, data);
+    return this.client.request(
+      "v6/party",
+      "POST",
+      { responseSchema: PartyUpdateResponseSchema, requestSchema: PartyWriteSchema },
+      data
+    );
   }
   getMany(ids) {
-    return this.batchGet(ids, (id) => this.get(id));
-  }
-  async batchGet(ids, fetchFn) {
-    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
-    const errors = [];
-    const data = [];
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        const [item, error] = result.value;
-        if (error) {
-          errors.push(error);
-        } else if (item !== null) {
-          data.push(item);
-        }
-      } else {
-        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
-      }
-    }
-    if (errors.length > 0) {
-      return [null, new VintraceAggregateError(errors)];
-    }
-    return [data, null];
+    return batchFetch(ids, (id) => this.get(id));
   }
 };
 var ProductsClient = class {
   constructor(client) {
     this.client = client;
   }
-  getAll(params) {
-    return this.client.request("v6/products/list", "GET", {}, params);
+  /**
+   * List available products.
+   *
+   * Returns a list of all active products.
+   */
+  async getAll(params) {
+    const limit = params?.max ? parseInt(params.max, 10) : 100;
+    const firstResponse = await this.client.request(
+      "v6/products/list",
+      "GET",
+      { responseSchema: ProductListResponseSchema },
+      { ...params, max: String(limit), first: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.products?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.products ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.products ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/products/list",
+            "GET",
+            { responseSchema: ProductListResponseSchema },
+            { ...params, max: String(limit), first: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.products) {
+          allResults.push(...pageData.products);
+        }
+      }
+    }
+    return [allResults, null];
   }
   get(id) {
-    return this.client.request(`v6/products/${id}`, "GET");
-  }
-  getMany(ids) {
-    return this.batchGet(ids, (id) => this.get(id));
+    return this.client.request(`v6/products/${id}`, "GET", {
+      responseSchema: ProductResponseSchema
+    });
   }
-  create(data) {
-    return this.client.request("v6/products", "POST", {}, data);
-  }
-  update(id, data) {
-    return this.client.request(`v6/products/${id}`, "PUT", {}, data);
-  }
-  updateFields(data) {
-    return this.client.request("v6/product-update", "POST", {}, data);
-  }
-  async batchGet(ids, fetchFn) {
-    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
+  async getMany(ids) {
+    const results = await Promise.allSettled(ids.map((id) => this.get(id)));
     const errors = [];
     const data = [];
     for (const result of results) {
       if (result.status === "fulfilled") {
-        const [item, error] = result.value;
+        const [envelope, error] = result.value;
         if (error) {
           errors.push(error);
-        } else if (item !== null) {
-          data.push(item);
+        } else if (envelope?.product) {
+          data.push(envelope.product);
         }
       } else {
         errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
@@ -592,19 +1535,98 @@ var ProductsClient = class {
     }
     return [data, null];
   }
+  create(data) {
+    return this.client.request(
+      "v6/products",
+      "POST",
+      { responseSchema: ProductResponseSchema, requestSchema: ProductSchema },
+      data
+    );
+  }
+  update(id, data) {
+    return this.client.request(
+      `v6/products/${id}`,
+      "PUT",
+      { responseSchema: ProductUpdateResponseSchema, requestSchema: ProductSchema },
+      data
+    );
+  }
+  updateFields(data) {
+    return this.client.request(
+      "v6/product-update",
+      "POST",
+      { responseSchema: ProductUpdateResponseSchema, requestSchema: ProductUpdateDataSchema },
+      data
+    );
+  }
 };
 var BlocksClient = class {
   constructor(client) {
     this.client = client;
   }
-  getAll(params) {
-    return this.client.request("v7/harvest/blocks", "GET", {}, params);
+  /**
+   * Get all blocks in the system.
+   *
+   * Get all the blocks that matches the provided query params in the system.
+   * By default, the block data returned in this endpoint only includes:
+   * id, code, name, description, grower, vineyard, region, subRegion, varietal,
+   * rowNumbers, estate, intendedUse, grading, externalId, inactive
+   *
+   * API consumer can use the include and vintage query params to request including more information in the response.
+   */
+  async getAll(params) {
+    const limit = params?.limit ? parseInt(String(params.limit), 10) : 100;
+    const firstResponse = await this.client.request(
+      "v7/harvest/blocks",
+      "GET",
+      { responseSchema: GetBlocksSuccessResponseSchema },
+      { ...params, limit: String(limit), offset: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResults ?? 0;
+    if (totalCount <= limit) {
+      return [response.results ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.results ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v7/harvest/blocks",
+            "GET",
+            { responseSchema: GetBlocksSuccessResponseSchema },
+            { ...params, limit: String(limit), offset: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.results) {
+          allResults.push(...pageData.results);
+        }
+      }
+    }
+    return [allResults, null];
   }
   get(id) {
     return this.client.request(`v7/harvest/blocks/${id}`, "GET");
   }
   getMany(ids) {
-    return this.batchGet(ids, (id) => this.get(id));
+    return batchFetch(ids, (id) => this.get(id));
   }
   post(data) {
     return this.client.request("v7/harvest/blocks", "POST", {}, data);
@@ -612,27 +1634,6 @@ var BlocksClient = class {
   patch(id, data) {
     return this.client.request(`v7/harvest/blocks/${id}`, "PATCH", {}, data);
   }
-  async batchGet(ids, fetchFn) {
-    const results = await Promise.allSettled(ids.map((id) => fetchFn(id)));
-    const errors = [];
-    const data = [];
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        const [item, error] = result.value;
-        if (error) {
-          errors.push(error);
-        } else if (item !== null) {
-          data.push(item);
-        }
-      } else {
-        errors.push(new VintraceError(result.reason?.message ?? "Unknown error", 0));
-      }
-    }
-    if (errors.length > 0) {
-      return [null, new VintraceAggregateError(errors)];
-    }
-    return [data, null];
-  }
 };
 var BookingsClient = class {
   constructor(client) {
@@ -649,38 +1650,203 @@ var VesselDetailsReportClient = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Get vessel details report.
+   *
+   * Returns a vessel details report based on the provided parameters.
+   */
   get(params) {
-    return this.client.request("v7/report/vessel-details-report", "GET", {}, params);
+    return this.client.request(
+      "v7/report/vessel-details-report",
+      "GET",
+      { responseSchema: GetBulkWineDetailsReportResponseSchema },
+      params
+    );
   }
 };
 var TransactionsClient = class {
   constructor(client) {
     this.client = client;
   }
-  search(params) {
-    return this.client.request("v6/transaction/search", "GET", {}, params);
+  /**
+   * Transaction search.
+   *
+   * Returns a list of transactions matching search criteria.
+   */
+  async search(params) {
+    const limit = params?.maxResults ? params.maxResults : 100;
+    const firstResponse = await this.client.request(
+      "v6/transaction/search",
+      "GET",
+      { responseSchema: TransactionSearchResponseSchema },
+      { ...params, maxResults: limit, firstResult: 0 }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.results?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.results ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.results ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/transaction/search",
+            "GET",
+            { responseSchema: TransactionSearchResponseSchema },
+            { ...params, maxResults: limit, firstResult: offset }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.results) {
+          allResults.push(...pageData.results);
+        }
+      }
+    }
+    return [allResults, null];
   }
 };
 var IntakeOperationsClient = class {
   constructor(client) {
     this.client = client;
   }
-  search(params) {
-    return this.client.request("v6/intake-operations/search", "GET", {}, params);
+  /**
+   * Fruit intake operation search.
+   *
+   * Returns a list of fruit intake operations matching search criteria.
+   */
+  async search(params) {
+    const limit = params?.maxResults ? params.maxResults : 100;
+    const firstResponse = await this.client.request(
+      "v6/intake-operations/search",
+      "GET",
+      { responseSchema: IntakeOperationSearchResponseSchema },
+      { ...params, maxResults: limit, firstResult: 0 }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.results?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.results ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.results ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/intake-operations/search",
+            "GET",
+            { responseSchema: IntakeOperationSearchResponseSchema },
+            { ...params, maxResults: limit, firstResult: offset }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.results) {
+          allResults.push(...pageData.results);
+        }
+      }
+    }
+    return [allResults, null];
   }
 };
 var SampleOperationsClient = class {
   constructor(client) {
     this.client = client;
   }
-  search(params) {
-    return this.client.request("v6/sample-operations/search", "GET", {}, params);
+  /**
+   * Maturity samples search.
+   *
+   * Returns a list of maturity samples matching search criteria.
+   */
+  async search(params) {
+    const limit = params?.maxResults ? params.maxResults : 100;
+    const firstResponse = await this.client.request(
+      "v6/sample-operations/search",
+      "GET",
+      { responseSchema: SampleOperationSearchResponseSchema },
+      { ...params, maxResults: limit, firstResult: 0 }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.results?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.results ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.results ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/sample-operations/search",
+            "GET",
+            { responseSchema: SampleOperationSearchResponseSchema },
+            { ...params, maxResults: limit, firstResult: offset }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.results) {
+          allResults.push(...pageData.results);
+        }
+      }
+    }
+    return [allResults, null];
   }
 };
 var BlockAssessmentsClient = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * Create a block assessment.
+   *
+   * Upsert the assessment data for a block.
+   */
   create(data) {
     return this.client.request("v6/block-assessments/create", "POST", {}, data);
   }
@@ -689,8 +1855,18 @@ var MrpStockClient = class {
   constructor(client) {
     this.client = client;
   }
+  /**
+   * View a single stock item.
+   *
+   * Get a single stock item by ID with optional expand parameter.
+   */
   get(id, expand) {
-    return this.client.request(`v6/mrp/stock/${id}`, "GET", {}, expand ? { expand } : void 0);
+    return this.client.request(
+      `v6/mrp/stock/${id}`,
+      "GET",
+      {},
+      expand ? { expand } : void 0
+    );
   }
   getFields(id) {
     return this.client.request(`v6/mrp/stock/${id}/fields`, "GET");
@@ -714,7 +1890,12 @@ var MrpStockClient = class {
     return this.client.request(`v6/mrp/stock/${id}/notes/${noteId}`, "GET");
   }
   updateNote(id, noteId, data) {
-    return this.client.request(`v6/mrp/stock/${id}/notes/${noteId}/updates`, "POST", {}, data);
+    return this.client.request(
+      `v6/mrp/stock/${id}/notes/${noteId}/updates`,
+      "POST",
+      {},
+      data
+    );
   }
   getBulkInfo(id) {
     return this.client.request(`v6/mrp/stock/${id}/bulk-info`, "GET");
@@ -724,16 +1905,119 @@ var InventoryClient = class {
   constructor(client) {
     this.client = client;
   }
-  getAll(params) {
-    return this.client.request("v6/inventory", "GET", {}, params);
+  /**
+   * List available stock.
+   *
+   * Returns a list of all stock items.
+   */
+  async getAll(params) {
+    const limit = params?.max ? parseInt(params.max, 10) : 100;
+    const firstResponse = await this.client.request(
+      "v6/inventory",
+      "GET",
+      { responseSchema: InventoryResponseSchema },
+      { ...params, max: String(limit), first: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.results?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.results ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.results ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/inventory",
+            "GET",
+            { responseSchema: InventoryResponseSchema },
+            { ...params, max: String(limit), first: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.results) {
+          allResults.push(...pageData.results);
+        }
+      }
+    }
+    return [allResults, null];
   }
 };
 var SearchClient = class {
   constructor(client) {
     this.client = client;
   }
-  list(params) {
-    return this.client.request("v6/search/list", "GET", {}, params);
+  /**
+   * List results for item type.
+   *
+   * Returns search results for a specific item type.
+   * Supported types are grading, owner, program, varietal, vintage,
+   * productState, region, block, grower, productCategory, batch, product, tank,
+   * vessel, containerEquipment, barrel, bin.
+   */
+  async list(params) {
+    const limit = params?.max ? parseInt(params.max, 10) : 100;
+    const firstResponse = await this.client.request(
+      "v6/search/list",
+      "GET",
+      { responseSchema: SearchListResponseSchema },
+      { ...params, max: String(limit), first: "0" }
+    );
+    if (firstResponse[1]) {
+      return [null, firstResponse[1]];
+    }
+    const response = firstResponse[0];
+    if (!response) {
+      return [[], null];
+    }
+    const totalCount = response.totalResultCount ?? response.results?.length ?? 0;
+    if (totalCount <= limit) {
+      return [response.results ?? [], null];
+    }
+    const pagesNeeded = Math.ceil(totalCount / limit);
+    const parallelLimit = this.client.options.parallelLimit;
+    const allResults = [...response.results ?? []];
+    for (let i = 1; i < pagesNeeded; i += parallelLimit) {
+      const batchSize = Math.min(parallelLimit, pagesNeeded - i);
+      const batchPromises = [];
+      for (let j = 0; j < batchSize; j++) {
+        const offset = (i + j) * limit;
+        batchPromises.push(
+          this.client.request(
+            "v6/search/list",
+            "GET",
+            { responseSchema: SearchListResponseSchema },
+            { ...params, max: String(limit), first: String(offset) }
+          )
+        );
+      }
+      const batchResults = await Promise.all(batchPromises);
+      for (const [pageData, pageError] of batchResults) {
+        if (pageError) {
+          return [null, pageError];
+        }
+        if (pageData?.results) {
+          allResults.push(...pageData.results);
+        }
+      }
+    }
+    return [allResults, null];
   }
 };
 var ProductAnalysisClient = class {
@@ -749,7 +2033,7 @@ var ProductAnalysisClient = class {
     return this.client.request(
       `v6/product-analysis/${productId}`,
       "GET",
-      {},
+      { responseSchema: ProductAnalysisResponseSchema },
       params
     );
   }
@@ -799,7 +2083,26 @@ var ProductCompositionClient = class {
   get(productId) {
     return this.client.request(
       `v6/product-composition/${productId}`,
-      "GET"
+      "GET",
+      { responseSchema: ProductCompositionResponseSchema }
+    );
+  }
+};
+var ProductJobsClient = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Get job history for a product by its numeric ID.
+   * Returns the job details and history for a product including transfers,
+   * treatments, and other operations performed on it.
+   * e.g. GET v6/product-jobs/{productId}
+   */
+  get(productId) {
+    return this.client.request(
+      `v6/product-jobs/${productId}`,
+      "GET",
+      { responseSchema: ProductJobResponseSchema }
     );
   }
 };