@flowio/types 8.0.6 → 8.0.7

package/src/api-internal.ts

@@ -1,296 +1,3 @@
-declare namespace io.flow.ratecard.v0.models {
-  interface CrossdockRatecardFee {
-    readonly discriminator: 'crossdock_ratecard_fee';
-    readonly amount: io.flow.common.v0.models.Money;
-  }
-
-  interface DdpRatecardFee {
-    readonly discriminator: 'ddp_ratecard_fee';
-    readonly amount: number;
-  }
-
-  interface DimensionEstimate {
-    readonly id: string;
-    readonly q: string;
-    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
-    readonly position: number;
-  }
-
-  interface DimensionEstimateForm {
-    readonly q: string;
-    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
-    readonly position?: number;
-  }
-
-  interface DimensionEstimateVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly dimension_estimate: io.flow.ratecard.v0.models.DimensionEstimate;
-  }
-
-  interface EstimatedDimensions {
-    readonly depth: io.flow.common.v0.models.Measurement;
-    readonly length: io.flow.common.v0.models.Measurement;
-    readonly weight: io.flow.common.v0.models.Measurement;
-    readonly width: io.flow.common.v0.models.Measurement;
-  }
-
-  interface FuelSurchargeRatecardFee {
-    readonly discriminator: 'fuel_surcharge_ratecard_fee';
-    readonly amount: io.flow.common.v0.models.Money;
-  }
-
-  interface FuelSurchargeServiceFee {
-    readonly discriminator: 'fuel_surcharge_service_fee';
-    readonly percent: number;
-  }
-
-  interface Hop {
-    readonly hop_number: number;
-    readonly hop_estimate: io.flow.ratecard.v0.models.HopEstimate;
-  }
-
-  interface HopEstimate {
-    readonly origin_address: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly destination_address: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
-    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
-    readonly currency: string;
-    readonly amount: number;
-    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
-    readonly total: number;
-  }
-
-  interface OversizedShipmentRatecardFee {
-    readonly discriminator: 'oversized_shipment_ratecard_fee';
-    readonly weight_threshold: number;
-    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly margin?: number;
-    readonly amount?: number;
-  }
-
-  interface Ratecard {
-    readonly id: string;
-    readonly number: string;
-    readonly direction: io.flow.label.v0.enums.Direction;
-    readonly effective_at: string;
-    readonly origination_zones: io.flow.common.v0.models.Zone[];
-    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
-    readonly published_at?: string;
-    readonly ratecard_owner: io.flow.fulfillment.v0.enums.RatecardOwner;
-  }
-
-  interface RatecardCarrierSummary {
-    readonly id: string;
-    readonly name: string;
-  }
-
-  interface RatecardEstimateFormV1 {
-    readonly discriminator: 'ratecard_estimate_form_v1';
-    readonly origin?: string;
-    readonly destination?: string;
-    readonly weight_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly distance_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly service?: string;
-    readonly weight?: number;
-    readonly length?: number;
-    readonly width?: number;
-    readonly depth?: number;
-    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
-    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
-  }
-
-  interface RatecardEstimateFormV2 {
-    readonly discriminator: 'ratecard_estimate_form_v2';
-    readonly origin_address: io.flow.common.v0.models.Address;
-    readonly destination_address: io.flow.common.v0.models.Address;
-    readonly weight_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly distance_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly service?: string;
-    readonly weight?: number;
-    readonly length?: number;
-    readonly width?: number;
-    readonly depth?: number;
-    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
-    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
-    readonly center_id?: string;
-  }
-
-  interface RatecardEstimateSummaryForm {
-    readonly origin?: string;
-    readonly destination?: string;
-    readonly service?: string;
-    readonly center_key?: string;
-  }
-
-  interface RatecardEstimateV1 {
-    readonly discriminator: 'ratecard_estimate_v1';
-    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
-    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
-    readonly currency: string;
-    readonly amount: number;
-    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
-    readonly total: number;
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
-    readonly dimensional_weight?: io.flow.common.v0.models.Measurement;
-    readonly gravitational_weight?: io.flow.common.v0.models.Measurement;
-    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
-  }
-
-  interface RatecardEstimateV2 {
-    readonly discriminator: 'ratecard_estimate_v2';
-    readonly hops: io.flow.ratecard.v0.models.Hop[];
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
-    readonly dimensional_weight?: io.flow.common.v0.models.Measurement;
-    readonly gravitational_weight?: io.flow.common.v0.models.Measurement;
-    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
-    readonly ratecard_owner?: io.flow.fulfillment.v0.enums.RatecardOwner;
-  }
-
-  interface RatecardForm {
-    readonly direction: io.flow.label.v0.enums.Direction;
-    readonly effective_at: string;
-    readonly origination_zones: io.flow.common.v0.models.Zone[];
-    readonly service: string;
-    readonly number?: string;
-    readonly ratecard_owner?: io.flow.fulfillment.v0.enums.RatecardOwner;
-  }
-
-  interface RatecardLane {
-    readonly id: string;
-    readonly ratecard: io.flow.ratecard.v0.models.RatecardReference;
-    readonly currency: string;
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
-    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
-    readonly destination: io.flow.common.v0.models.Zone;
-    readonly dim_factor: number;
-    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
-    readonly origin: io.flow.common.v0.models.Zone;
-    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
-    readonly rates: io.flow.ratecard.v0.models.RatecardRate[];
-    readonly rounding: io.flow.common.v0.models.Rounding;
-    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly distance_unit: io.flow.common.v0.enums.UnitOfMeasurement;
-  }
-
-  interface RatecardLaneForm {
-    readonly ratecard_id: string;
-    readonly currency: string;
-    readonly destination: io.flow.common.v0.models.Zone;
-    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
-    readonly dim_factor: number;
-    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
-    readonly origin: io.flow.common.v0.models.Zone;
-    readonly rounding: io.flow.common.v0.models.Rounding;
-    readonly rates: io.flow.ratecard.v0.models.RatecardRateForm[];
-    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly distance_unit: io.flow.common.v0.enums.UnitOfMeasurement;
-  }
-
-  interface RatecardLaneImportForm {
-    readonly ratecard_owner: io.flow.fulfillment.v0.enums.RatecardOwner;
-    readonly service: string;
-    readonly currency: string;
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
-    readonly origin: io.flow.common.v0.models.Zone;
-    readonly destination: io.flow.common.v0.models.Zone;
-    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
-    readonly dim_factor: number;
-    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly distance_unit: io.flow.common.v0.enums.UnitOfMeasurement;
-    readonly rates: io.flow.ratecard.v0.models.RatecardRateForm[];
-  }
-
-  interface RatecardLaneVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly ratecard_lane: io.flow.ratecard.v0.models.RatecardLane;
-  }
-
-  interface RatecardLanesImportRequestData {
-    readonly id: string;
-    readonly source_url: string;
-    readonly filename?: string;
-  }
-
-  interface RatecardRate {
-    readonly id: string;
-    readonly amount: number;
-    readonly weight: number;
-  }
-
-  interface RatecardRateForm {
-    readonly amount: number;
-    readonly weight: number;
-  }
-
-  interface RatecardRateVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly ratecard_rate: io.flow.ratecard.v0.models.RatecardRate;
-  }
-
-  interface RatecardReference {
-    readonly id: string;
-  }
-
-  interface RatecardServiceSummary {
-    readonly id: string;
-    readonly name: string;
-    readonly carrier: io.flow.ratecard.v0.models.RatecardCarrierSummary;
-  }
-
-  interface RatecardVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly ratecard: io.flow.ratecard.v0.models.Ratecard;
-  }
-
-  interface RemoteAreaRatecardFee {
-    readonly discriminator: 'remote_area_ratecard_fee';
-    readonly amount: io.flow.common.v0.models.Money;
-  }
-
-  interface RemoteAreaServiceFee {
-    readonly discriminator: 'remote_area_service_fee';
-    readonly amount: io.flow.common.v0.models.Money;
-  }
-
-  interface ReturnPackageRatecardFee {
-    readonly discriminator: 'return_package_ratecard_fee';
-    readonly amount: number;
-  }
-
-  interface ShipmentWindow {
-    readonly from: number;
-    readonly to: number;
-  }
-}
-
-declare namespace io.flow.ratecard.v0.unions {
-  type RatecardEstimate =
-    | io.flow.ratecard.v0.models.RatecardEstimateV1
-    | io.flow.ratecard.v0.models.RatecardEstimateV2;
-  type RatecardEstimateForm =
-    | io.flow.ratecard.v0.models.RatecardEstimateFormV1
-    | io.flow.ratecard.v0.models.RatecardEstimateFormV2;
-  type RatecardFee =
-    | io.flow.ratecard.v0.models.DdpRatecardFee
-    | io.flow.ratecard.v0.models.FuelSurchargeRatecardFee
-    | io.flow.ratecard.v0.models.OversizedShipmentRatecardFee
-    | io.flow.ratecard.v0.models.ReturnPackageRatecardFee
-    | io.flow.ratecard.v0.models.CrossdockRatecardFee
-    | io.flow.ratecard.v0.models.RemoteAreaRatecardFee;
-  type ServiceFee =
-    | io.flow.ratecard.v0.models.FuelSurchargeServiceFee
-    | io.flow.ratecard.v0.models.RemoteAreaServiceFee;
-}
-
 declare namespace io.flow.bundle.checkout.v0.enums {
   type CheckoutErrorCode =
     | 'generic_error'
@@ -1139,594 +846,841 @@ declare namespace io.flow.experience.v0.models {
     readonly contact?: io.flow.common.v0.models.Contact;
   }
 
-  interface OrderBuilder {
-    readonly order?: io.flow.experience.v0.models.Order;
-    readonly errors?: io.flow.experience.v0.models.OrderError[];
+  interface OrderBuilder {
+    readonly order?: io.flow.experience.v0.models.Order;
+    readonly errors?: io.flow.experience.v0.models.OrderError[];
+  }
+
+  interface OrderBuilderAttributesForm {
+    readonly attributes: Record<string, string>;
+  }
+
+  interface OrderBuilderCustomerInvoiceAddressForm {
+    readonly address: io.flow.common.v0.models.BillingAddress;
+  }
+
+  interface OrderBuilderDeliveredDutyForm {
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+  }
+
+  interface OrderBuilderDestinationCountryForm {
+    readonly country: string;
+  }
+
+  interface OrderBuilderDestinationForm {
+    readonly destination: io.flow.experience.v0.models.OrderAddress;
+  }
+
+  interface OrderDestinationPutForm {
+    readonly destination: io.flow.experience.v0.models.OrderAddress;
+  }
+
+  interface OrderError {
+    readonly code: io.flow.experience.v0.enums.OrderErrorCode;
+    readonly messages: string[];
+    readonly numbers?: string[];
+    readonly destination_country?: io.flow.reference.v0.models.Country;
+    readonly threshold?: io.flow.experience.v0.models.ValueThresholdExceededDetails;
+  }
+
+  interface OrderEstimate {
+    readonly id: string;
+    readonly items: io.flow.experience.v0.models.LocalizedLineItem[];
+    readonly destination: io.flow.experience.v0.models.OrderAddress;
+    readonly deliveries: io.flow.fulfillment.v0.unions.Delivery[];
+    readonly prices: io.flow.order.price.v0.models.OrderPriceDetail[];
+    readonly selections: string[];
+    readonly total: io.flow.catalog.v0.models.LocalizedTotal;
+    readonly lines?: io.flow.experience.v0.models.Line[];
+    readonly promotions?: io.flow.experience.v0.models.Promotions;
+  }
+
+  interface OrderEstimateForm {
+    readonly items: io.flow.common.v0.models.LineItemForm[];
+    readonly destination?: io.flow.experience.v0.models.OrderAddress;
+    readonly selections?: string[];
+  }
+
+  interface OrderForm {
+    readonly customer?: io.flow.common.v0.models.OrderCustomerForm;
+    readonly items: io.flow.common.v0.models.LineItemForm[];
+    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
+    readonly number?: string;
+    readonly destination?: io.flow.experience.v0.models.OrderAddress;
+    readonly discount?: io.flow.common.v0.models.Money;
+    readonly discounts?: io.flow.common.v0.models.DiscountsForm;
+    readonly attributes?: Record<string, string>;
+    readonly authorization_keys?: string[];
+    readonly options?: io.flow.experience.v0.models.OrderOptions;
+  }
+
+  interface OrderGeo {
+    readonly ip?: string;
+    readonly country: string;
+    readonly currency?: string;
+    readonly language?: string;
+  }
+
+  interface OrderIdentifier {
+    readonly id: string;
+    readonly order: io.flow.experience.v0.models.OrderReference;
+    readonly name: string;
+    readonly identifier: string;
+    readonly primary: boolean;
+    readonly number?: string;
+  }
+
+  interface OrderIdentifierForm {
+    readonly order: string;
+    readonly name?: string;
+    readonly identifier?: string;
+    readonly number?: string;
+    readonly primary?: boolean;
+  }
+
+  interface OrderIdentifierPutForm {
+    readonly order: string;
+    readonly name?: string;
+    readonly primary?: boolean;
+  }
+
+  interface OrderIdentifierVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly order_identifier: io.flow.experience.v0.models.OrderIdentifier;
+  }
+
+  interface OrderNumberGeneratorDefaults {
+    readonly starts_with: number;
+    readonly min_hex_length: number;
+    readonly min_starts_with: number;
+  }
+
+  interface OrderNumberGeneratorFixedLength {
+    readonly length: number;
+    readonly padding: string;
+  }
+
+  interface OrderNumberGeneratorHexadecimal {
+    readonly discriminator: 'hexadecimal';
+    readonly length: number;
+  }
+
+  interface OrderNumberGeneratorPrefixSuffix {
+    readonly discriminator: 'prefix_suffix';
+    readonly prefix?: string;
+    readonly starts_with?: number;
+    readonly suffix?: string;
+    readonly fixed_length?: io.flow.experience.v0.models.OrderNumberGeneratorFixedLength;
+  }
+
+  interface OrderNumberGeneratorUuid {
+    readonly discriminator: 'uuid';
+    readonly prefix?: string;
+  }
+
+  interface OrderNumberReference {
+    readonly number: string;
+  }
+
+  interface OrderOptions {
+    readonly storage: io.flow.experience.v0.enums.OrderStorage;
+  }
+
+  interface OrderPayment {
+    readonly id: string;
+    readonly type: io.flow.experience.v0.enums.OrderPaymentType;
+    readonly merchant_of_record?: io.flow.common.v0.enums.MerchantOfRecord;
+    readonly reference: string;
+    readonly description: string;
+    readonly total: io.flow.common.v0.models.PriceWithBase;
+    readonly address?: io.flow.common.v0.models.BillingAddress;
+    readonly date?: string;
+    readonly attributes?: Record<string, string>;
+  }
+
+  interface OrderPromotionTrigger {
+    readonly type: io.flow.experience.v0.enums.PromotionTriggerType;
+    readonly min?: io.flow.common.v0.models.Price;
+  }
+
+  interface OrderPutForm {
+    readonly items: io.flow.common.v0.models.LineItemForm[];
+    readonly customer?: io.flow.common.v0.models.OrderCustomerForm;
+    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
+    readonly selections?: string[];
+    readonly destination?: io.flow.experience.v0.models.OrderAddress;
+    readonly discount?: io.flow.common.v0.models.Money;
+    readonly discounts?: io.flow.common.v0.models.DiscountsForm;
+    readonly attributes?: Record<string, string>;
+    readonly authorization_keys?: string[];
+    readonly options?: io.flow.experience.v0.models.OrderOptions;
+  }
+
+  interface OrderReference {
+    readonly discriminator: 'order_reference';
+    readonly id: string;
+    readonly number: string;
+  }
+
+  interface OrderRuleReference {
+    readonly id: string;
+    readonly key: string;
+  }
+
+  interface OrderRulesSummary {
+    readonly applied: io.flow.experience.v0.models.OrderRuleReference[];
+  }
+
+  interface OrderServiceChange {
+    readonly id: string;
+    readonly from: io.flow.reference.v0.models.CarrierService;
+    readonly to: io.flow.reference.v0.models.CarrierService;
+  }
+
+  interface OrderServiceChangeForm {
+    readonly from_service_id: string;
+    readonly to_service_id: string;
+  }
+
+  interface OrderServiceChangeRequestData {
+    readonly id: string;
+    readonly source_url: string;
+    readonly filename?: string;
+  }
+
+  interface OrderSubmissionForm {
+    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
+  }
+
+  interface OrderSubmissionIdentifierForm {
+    readonly identifier: string;
+    readonly name?: string;
+    readonly primary?: boolean;
+  }
+
+  interface OrderSummary {
+    readonly number: string;
+    readonly subtotal: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly shipping?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly tax?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly duty?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly insurance?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly discount?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly surcharges?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly adjustment?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly total: io.flow.experience.v0.models.OrderSummaryPriceDetail;
+    readonly lines: io.flow.experience.v0.models.OrderSummaryLineItem[];
+    readonly identifiers?: Record<string, string>;
+  }
+
+  interface OrderSummaryImage {
+    readonly url: string;
+  }
+
+  interface OrderSummaryItem {
+    readonly number: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly attributes: io.flow.experience.v0.models.CheckoutItemContentAttribute[];
+    readonly image?: io.flow.experience.v0.models.OrderSummaryImage;
+    readonly price: io.flow.common.v0.models.Price;
+    readonly discount?: io.flow.common.v0.models.Price;
+    readonly tax?: io.flow.experience.v0.models.OrderSummaryLevy;
+    readonly duty?: io.flow.experience.v0.models.OrderSummaryLevy;
+    readonly price_attributes: Record<string, io.flow.common.v0.models.Price>;
+  }
+
+  interface OrderSummaryLevy {
+    readonly rate: number;
+    readonly rate_label?: string;
+    readonly value: io.flow.common.v0.models.Price;
+  }
+
+  interface OrderSummaryLineItem {
+    readonly item: io.flow.experience.v0.models.OrderSummaryItem;
+    readonly quantity: number;
+    readonly discount?: io.flow.common.v0.models.Price;
+    readonly tax?: io.flow.experience.v0.models.OrderSummaryLevy;
+    readonly duty?: io.flow.experience.v0.models.OrderSummaryLevy;
+    readonly total: io.flow.common.v0.models.Price;
+    readonly price_attributes: Record<string, io.flow.common.v0.models.Price>;
   }
 
-  interface OrderBuilderAttributesForm {
-    readonly attributes: Record<string, string>;
+  interface OrderSummaryPriceDetail {
+    readonly price: io.flow.common.v0.models.Price;
+    readonly name?: string;
+    readonly rate?: number;
+    readonly rate_label?: string;
   }
 
-  interface OrderBuilderCustomerInvoiceAddressForm {
-    readonly address: io.flow.common.v0.models.BillingAddress;
+  interface OrderVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly order: io.flow.experience.v0.models.Order;
   }
 
-  interface OrderBuilderDeliveredDutyForm {
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+  interface OrderWithDiscountsForm {
+    readonly order: io.flow.experience.v0.models.OrderForm;
+    readonly discounts: string[];
   }
 
-  interface OrderBuilderDestinationCountryForm {
-    readonly country: string;
+  interface OriginalPrices {
+    readonly value: io.flow.common.v0.models.Price;
+    readonly max: io.flow.common.v0.models.Price;
   }
 
-  interface OrderBuilderDestinationForm {
-    readonly destination: io.flow.experience.v0.models.OrderAddress;
+  interface PaymentMethodIssuer {
+    readonly id: string;
+    readonly name: string;
   }
 
-  interface OrderDestinationPutForm {
-    readonly destination: io.flow.experience.v0.models.OrderAddress;
+  interface PaymentMethodRule {
+    readonly tags: io.flow.experience.v0.unions.PaymentMethodTag[];
+    readonly payment_method: io.flow.reference.v0.models.PaymentMethod;
+    readonly display_position: number;
+    readonly content?: io.flow.experience.v0.models.PaymentMethodRuleContent[];
+    readonly issuers?: io.flow.experience.v0.models.PaymentMethodIssuer[];
+    readonly programs?: any /*object*/[];
+    readonly q?: io.flow.query.builder.v0.models.Query;
   }
 
-  interface OrderError {
-    readonly code: io.flow.experience.v0.enums.OrderErrorCode;
-    readonly messages: string[];
-    readonly numbers?: string[];
-    readonly destination_country?: io.flow.reference.v0.models.Country;
-    readonly threshold?: io.flow.experience.v0.models.ValueThresholdExceededDetails;
+  interface PaymentMethodRuleContent {
+    readonly key: io.flow.experience.v0.enums.PaymentMethodRuleContentKey;
+    readonly value: string;
   }
 
-  interface OrderEstimate {
-    readonly id: string;
-    readonly items: io.flow.experience.v0.models.LocalizedLineItem[];
-    readonly destination: io.flow.experience.v0.models.OrderAddress;
-    readonly deliveries: io.flow.fulfillment.v0.unions.Delivery[];
-    readonly prices: io.flow.order.price.v0.models.OrderPriceDetail[];
-    readonly selections: string[];
-    readonly total: io.flow.catalog.v0.models.LocalizedTotal;
-    readonly lines?: io.flow.experience.v0.models.Line[];
-    readonly promotions?: io.flow.experience.v0.models.Promotions;
+  interface PricingSettings {
+    readonly editable: boolean;
+    readonly default_tax_display: io.flow.price.v0.enums.PricingLevySetting;
+    readonly default_duty_display: io.flow.price.v0.enums.PricingLevySetting;
   }
 
-  interface OrderEstimateForm {
-    readonly items: io.flow.common.v0.models.LineItemForm[];
-    readonly destination?: io.flow.experience.v0.models.OrderAddress;
-    readonly selections?: string[];
+  interface PromotionTrigger {
+    readonly type: io.flow.experience.v0.enums.PromotionTriggerType;
+    readonly min: io.flow.common.v0.models.Price;
+    readonly remaining: io.flow.common.v0.models.Price;
   }
 
-  interface OrderForm {
-    readonly customer?: io.flow.common.v0.models.OrderCustomerForm;
-    readonly items: io.flow.common.v0.models.LineItemForm[];
-    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
-    readonly number?: string;
-    readonly destination?: io.flow.experience.v0.models.OrderAddress;
-    readonly discount?: io.flow.common.v0.models.Money;
-    readonly discounts?: io.flow.common.v0.models.DiscountsForm;
-    readonly attributes?: Record<string, string>;
-    readonly authorization_keys?: string[];
-    readonly options?: io.flow.experience.v0.models.OrderOptions;
+  interface PromotionTriggerForm {
+    readonly type: io.flow.experience.v0.enums.PromotionTriggerType;
+    readonly min?: io.flow.common.v0.models.PriceForm;
   }
 
-  interface OrderGeo {
-    readonly ip?: string;
-    readonly country: string;
-    readonly currency?: string;
-    readonly language?: string;
+  interface Promotions {
+    readonly applied: io.flow.experience.v0.unions.Promotion[];
+    readonly available: io.flow.experience.v0.unions.Promotion[];
   }
 
-  interface OrderIdentifier {
+  interface RegionReference {
     readonly id: string;
-    readonly order: io.flow.experience.v0.models.OrderReference;
-    readonly name: string;
-    readonly identifier: string;
-    readonly primary: boolean;
-    readonly number?: string;
   }
 
-  interface OrderIdentifierForm {
-    readonly order: string;
-    readonly name?: string;
-    readonly identifier?: string;
-    readonly number?: string;
-    readonly primary?: boolean;
+  interface ValueThresholdExceededDetails {
+    readonly local: io.flow.common.v0.models.Price;
+    readonly original: io.flow.common.v0.models.Price;
   }
+}
 
-  interface OrderIdentifierPutForm {
-    readonly order: string;
-    readonly name?: string;
-    readonly primary?: boolean;
-  }
+declare namespace io.flow.experience.v0.unions {
+  type AllocationComponent =
+    | io.flow.experience.v0.models.AllocationDetailComponent
+    | io.flow.experience.v0.models.AllocationLevyComponent;
+  type AllocationDetail =
+    | io.flow.experience.v0.models.AllocationLineDetail
+    | io.flow.experience.v0.models.AllocationOrderDetail;
+  type ExpandableExperience =
+    | io.flow.experience.v0.models.Experience
+    | io.flow.experience.v0.models.ExperienceReference;
+  type ExpandableOrder =
+    | io.flow.experience.v0.models.Order
+    | io.flow.experience.v0.models.OrderReference;
+  type OrderNumberGenerator =
+    | io.flow.experience.v0.models.OrderNumberGeneratorUuid
+    | io.flow.experience.v0.models.OrderNumberGeneratorHexadecimal
+    | io.flow.experience.v0.models.OrderNumberGeneratorPrefixSuffix;
+  type OrderPromotion = io.flow.experience.v0.models.FreeShippingOrderPromotion;
+  type OrderPromotionForm = io.flow.experience.v0.models.FreeShippingOrderPromotionForm;
 
-  interface OrderIdentifierVersion {
+  type PaymentMethodTag =
+    | {
+        discriminator: 'organization_payment_method_tag';
+        value: io.flow.experience.v0.enums.OrganizationPaymentMethodTag;
+      }
+    | {
+        discriminator: 'experience_payment_method_tag';
+        value: io.flow.experience.v0.enums.ExperiencePaymentMethodTag;
+      };
+
+  type Promotion =
+    | io.flow.experience.v0.models.FreeShipping
+    | io.flow.experience.v0.models.Discount;
+}
+
+declare namespace io.flow.RESERVED_WORD_return.v0.enums {
+  type ReturnStatus = 'open' | 'refunded';
+}
+
+declare namespace io.flow.RESERVED_WORD_return.v0.models {
+  interface Return {
     readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly order_identifier: io.flow.experience.v0.models.OrderIdentifier;
+    readonly key: string;
+    readonly items: io.flow.RESERVED_WORD_return.v0.models.ReturnLineItem[];
+    readonly labels: io.flow.label.v0.models.ShippingLabel[];
   }
 
-  interface OrderNumberGeneratorDefaults {
-    readonly starts_with: number;
-    readonly min_hex_length: number;
-    readonly min_starts_with: number;
+  interface ReturnForm {
+    readonly items: io.flow.RESERVED_WORD_return.v0.models.ReturnLineItem[];
+    readonly tier_id?: string;
+    readonly order_number?: string;
+    readonly service?: string;
+    readonly destination?: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly key?: string;
+    readonly origin?: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly center_key?: string;
   }
 
-  interface OrderNumberGeneratorFixedLength {
-    readonly length: number;
-    readonly padding: string;
+  interface ReturnItemReference {
+    readonly number: string;
   }
 
-  interface OrderNumberGeneratorHexadecimal {
-    readonly discriminator: 'hexadecimal';
-    readonly length: number;
+  interface ReturnLineItem {
+    readonly item_number: string;
+    readonly order_number?: string;
+    readonly quantity: number;
+    readonly reason?: io.flow.RESERVED_WORD_return.v0.models.ReturnReason;
+    readonly notes?: string;
   }
 
-  interface OrderNumberGeneratorPrefixSuffix {
-    readonly discriminator: 'prefix_suffix';
-    readonly prefix?: string;
-    readonly starts_with?: number;
-    readonly suffix?: string;
-    readonly fixed_length?: io.flow.experience.v0.models.OrderNumberGeneratorFixedLength;
+  interface ReturnOrderReference {
+    readonly number: string;
   }
 
-  interface OrderNumberGeneratorUuid {
-    readonly discriminator: 'uuid';
-    readonly prefix?: string;
+  interface ReturnReason {
+    readonly key: string;
+    readonly name: string;
   }
 
-  interface OrderNumberReference {
-    readonly number: string;
+  interface ReturnReasonForm {
+    readonly key?: string;
+    readonly name?: string;
   }
 
-  interface OrderOptions {
-    readonly storage: io.flow.experience.v0.enums.OrderStorage;
+  interface ReturnReasonPutForm {
+    readonly name?: string;
   }
 
-  interface OrderPayment {
+  interface ReturnVersion {
     readonly id: string;
-    readonly type: io.flow.experience.v0.enums.OrderPaymentType;
-    readonly merchant_of_record?: io.flow.common.v0.enums.MerchantOfRecord;
-    readonly reference: string;
-    readonly description: string;
-    readonly total: io.flow.common.v0.models.PriceWithBase;
-    readonly address?: io.flow.common.v0.models.BillingAddress;
-    readonly date?: string;
-    readonly attributes?: Record<string, string>;
-  }
-
-  interface OrderPromotionTrigger {
-    readonly type: io.flow.experience.v0.enums.PromotionTriggerType;
-    readonly min?: io.flow.common.v0.models.Price;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly return: io.flow.RESERVED_WORD_return.v0.models.Return;
   }
+}
 
-  interface OrderPutForm {
-    readonly items: io.flow.common.v0.models.LineItemForm[];
-    readonly customer?: io.flow.common.v0.models.OrderCustomerForm;
-    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
-    readonly selections?: string[];
-    readonly destination?: io.flow.experience.v0.models.OrderAddress;
-    readonly discount?: io.flow.common.v0.models.Money;
-    readonly discounts?: io.flow.common.v0.models.DiscountsForm;
-    readonly attributes?: Record<string, string>;
-    readonly authorization_keys?: string[];
-    readonly options?: io.flow.experience.v0.models.OrderOptions;
+declare namespace io.flow.field.validation.v0.models {
+  interface FieldValidationMax {
+    readonly discriminator: 'max';
+    readonly length: number;
   }
 
-  interface OrderReference {
-    readonly discriminator: 'order_reference';
-    readonly id: string;
-    readonly number: string;
+  interface FieldValidationMin {
+    readonly discriminator: 'min';
+    readonly length: number;
   }
 
-  interface OrderRuleReference {
-    readonly id: string;
-    readonly key: string;
+  interface FieldValidationPattern {
+    readonly discriminator: 'pattern';
+    readonly pattern: string;
   }
 
-  interface OrderRulesSummary {
-    readonly applied: io.flow.experience.v0.models.OrderRuleReference[];
+  interface FieldValidationRequired {
+    readonly discriminator: 'required';
+    readonly unused: string;
   }
+}
 
-  interface OrderServiceChange {
-    readonly id: string;
-    readonly from: io.flow.reference.v0.models.CarrierService;
-    readonly to: io.flow.reference.v0.models.CarrierService;
-  }
+declare namespace io.flow.field.validation.v0.unions {
+  type FieldValidationRule =
+    | io.flow.field.validation.v0.models.FieldValidationRequired
+    | io.flow.field.validation.v0.models.FieldValidationMin
+    | io.flow.field.validation.v0.models.FieldValidationMax
+    | io.flow.field.validation.v0.models.FieldValidationPattern;
+}
 
-  interface OrderServiceChangeForm {
-    readonly from_service_id: string;
-    readonly to_service_id: string;
-  }
+declare namespace io.flow.tracking.internal.v0.enums {
+  type CrossdockTrackingStatus = 'notified' | 'received' | 'shipped';
+}
 
-  interface OrderServiceChangeRequestData {
-    readonly id: string;
-    readonly source_url: string;
-    readonly filename?: string;
+declare namespace io.flow.tracking.internal.v0.models {
+  interface Dhl {
+    readonly discriminator: 'dhl';
+    readonly export_account_number: string;
+    readonly import_account_number: string;
+    readonly password: string;
+    readonly site_id: string;
   }
 
-  interface OrderSubmissionForm {
-    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
+  interface DhlEcommerce {
+    readonly discriminator: 'dhl_ecommerce';
+    readonly username: string;
+    readonly password: string;
+    readonly client_id: string;
+    readonly pickup_account_number: string;
+    readonly distribution_center: string;
+    readonly pickup_name: string;
   }
 
-  interface OrderSubmissionIdentifierForm {
-    readonly identifier: string;
-    readonly name?: string;
-    readonly primary?: boolean;
+  interface FedexCrossborder {
+    readonly discriminator: 'fedex_crossborder';
+    readonly api_key: string;
+    readonly api_url: string;
   }
 
-  interface OrderSummary {
-    readonly number: string;
-    readonly subtotal: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly shipping?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly tax?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly duty?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly insurance?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly discount?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly surcharges?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly adjustment?: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly total: io.flow.experience.v0.models.OrderSummaryPriceDetail;
-    readonly lines: io.flow.experience.v0.models.OrderSummaryLineItem[];
-    readonly identifiers?: Record<string, string>;
+  interface Landmark {
+    readonly discriminator: 'landmark';
+    readonly username: string;
+    readonly password: string;
+    readonly client_id: string;
+    readonly region: string;
   }
 
-  interface OrderSummaryImage {
-    readonly url: string;
+  interface SfExpress {
+    readonly discriminator: 'sf_express';
+    readonly checkword: string;
+    readonly customer_code: string;
+    readonly product_code: string;
+    readonly customer_id: string;
   }
 
-  interface OrderSummaryItem {
-    readonly number: string;
-    readonly name: string;
+  interface TrackingEvent {
+    readonly timestamp: string;
+    readonly carrier_status_code: string;
+    readonly location?: string;
     readonly description?: string;
-    readonly attributes: io.flow.experience.v0.models.CheckoutItemContentAttribute[];
-    readonly image?: io.flow.experience.v0.models.OrderSummaryImage;
-    readonly price: io.flow.common.v0.models.Price;
-    readonly discount?: io.flow.common.v0.models.Price;
-    readonly tax?: io.flow.experience.v0.models.OrderSummaryLevy;
-    readonly duty?: io.flow.experience.v0.models.OrderSummaryLevy;
-    readonly price_attributes: Record<string, io.flow.common.v0.models.Price>;
   }
 
-  interface OrderSummaryLevy {
-    readonly rate: number;
-    readonly rate_label?: string;
-    readonly value: io.flow.common.v0.models.Price;
+  interface TrackingRequest {
+    readonly carrier: string;
+    readonly carrier_tracking_number: string;
+    readonly flow_tracking_number: string;
+    readonly credentials: io.flow.tracking.internal.v0.unions.CarrierCredentials;
   }
 
-  interface OrderSummaryLineItem {
-    readonly item: io.flow.experience.v0.models.OrderSummaryItem;
-    readonly quantity: number;
-    readonly discount?: io.flow.common.v0.models.Price;
-    readonly tax?: io.flow.experience.v0.models.OrderSummaryLevy;
-    readonly duty?: io.flow.experience.v0.models.OrderSummaryLevy;
-    readonly total: io.flow.common.v0.models.Price;
-    readonly price_attributes: Record<string, io.flow.common.v0.models.Price>;
+  interface TrackingResponse {
+    readonly carrier: string;
+    readonly carrier_tracking_number: string;
+    readonly flow_tracking_number: string;
+    readonly tracking_events: io.flow.tracking.internal.v0.models.TrackingEvent[];
   }
 
-  interface OrderSummaryPriceDetail {
-    readonly price: io.flow.common.v0.models.Price;
-    readonly name?: string;
-    readonly rate?: number;
-    readonly rate_label?: string;
+  interface Ups {
+    readonly discriminator: 'ups';
+    readonly username: string;
+    readonly password: string;
+    readonly access_license_number: string;
   }
+}
 
-  interface OrderVersion {
+declare namespace io.flow.tracking.internal.v0.unions {
+  type CarrierCredentials =
+    | io.flow.tracking.internal.v0.models.SfExpress
+    | io.flow.tracking.internal.v0.models.DhlEcommerce
+    | io.flow.tracking.internal.v0.models.Landmark
+    | io.flow.tracking.internal.v0.models.Dhl
+    | io.flow.tracking.internal.v0.models.FedexCrossborder
+    | io.flow.tracking.internal.v0.models.Ups;
+}
+
+declare namespace io.flow.item.v0.models {
+  interface LocalItem {
     readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly order: io.flow.experience.v0.models.Order;
+    readonly experience: io.flow.common.v0.models.ExperienceSummary;
+    readonly center?: io.flow.fulfillment.v0.models.CenterSummary;
+    readonly item: io.flow.common.v0.models.CatalogItemReference;
+    readonly pricing: io.flow.item.v0.models.LocalItemPricing;
+    readonly status: io.flow.catalog.v0.enums.SubcatalogItemStatus;
   }
 
-  interface OrderWithDiscountsForm {
-    readonly order: io.flow.experience.v0.models.OrderForm;
-    readonly discounts: string[];
+  interface LocalItemPricing {
+    readonly price: io.flow.catalog.v0.models.LocalizedItemPrice;
+    readonly vat?: io.flow.catalog.v0.models.LocalizedItemVat;
+    readonly duty?: io.flow.catalog.v0.models.LocalizedItemDuty;
+    readonly attributes: Record<string, io.flow.common.v0.models.PriceWithBase>;
   }
+}
 
-  interface OriginalPrices {
-    readonly value: io.flow.common.v0.models.Price;
-    readonly max: io.flow.common.v0.models.Price;
-  }
+declare namespace io.flow.flexe.v0.enums {
+  type FlexeAttachmentType =
+    | 'shipping_label'
+    | 'packing_slip'
+    | 'packing_slip_letter';
+  type FlexeNotification = 'receipt' | 'shipment';
+  type FlexeShipmentType =
+    | 'fulfillment_order'
+    | 'retail_fulfillment_order'
+    | 'carton_pick_delivery'
+    | 'delivery'
+    | 'container_delivery';
+  type FlexeStatus = 'in_transit' | 'completed';
+}
 
-  interface PaymentMethodIssuer {
-    readonly id: string;
-    readonly name: string;
+declare namespace io.flow.flexe.v0.models {
+  interface BillOfLading {
+    readonly type: string;
+    readonly gs1us?: io.flow.flexe.v0.models.Gs1Us;
   }
 
-  interface PaymentMethodRule {
-    readonly tags: io.flow.experience.v0.unions.PaymentMethodTag[];
-    readonly payment_method: io.flow.reference.v0.models.PaymentMethod;
-    readonly display_position: number;
-    readonly content?: io.flow.experience.v0.models.PaymentMethodRuleContent[];
-    readonly issuers?: io.flow.experience.v0.models.PaymentMethodIssuer[];
-    readonly programs?: any /*object*/[];
-    readonly q?: io.flow.query.builder.v0.models.Query;
+  interface BillTo {
+    readonly name: string;
+    readonly address_1: string;
+    readonly locality: string;
+    readonly region: string;
+    readonly postal_code: string;
+    readonly country: string;
+    readonly address_2?: string;
+    readonly address_3?: string;
   }
 
-  interface PaymentMethodRuleContent {
-    readonly key: io.flow.experience.v0.enums.PaymentMethodRuleContentKey;
-    readonly value: string;
+  interface CartonPickDeliveryDetails {
+    readonly shipment_uuid?: string;
+    readonly carrier?: string;
+    readonly carrier_id?: string;
   }
 
-  interface PricingSettings {
-    readonly editable: boolean;
-    readonly default_tax_display: io.flow.price.v0.enums.PricingLevySetting;
-    readonly default_duty_display: io.flow.price.v0.enums.PricingLevySetting;
+  interface ContainerDeliveryDetails {
+    readonly purchase_order: string;
+    readonly container_number?: string;
+    readonly seal_number?: string;
+    readonly vendor?: string;
+    readonly expected_inventory: io.flow.flexe.v0.models.InventoryDetails[];
+    readonly received_inventory: io.flow.flexe.v0.models.InventoryDetails[];
+    readonly damaged_inventory: io.flow.flexe.v0.models.InventoryDetails[];
+    readonly quantities_by_inventory: Record<
+      string,
+      io.flow.flexe.v0.models.QuantityByInventory
+    >;
   }
 
-  interface PromotionTrigger {
-    readonly type: io.flow.experience.v0.enums.PromotionTriggerType;
-    readonly min: io.flow.common.v0.models.Price;
-    readonly remaining: io.flow.common.v0.models.Price;
+  interface DeliveryDetails {
+    readonly shipment_uuid?: string;
+    readonly trailer_number?: string;
+    readonly pallets: io.flow.flexe.v0.models.Pallet[];
+    readonly quantities_by_inventory: Record<
+      string,
+      io.flow.flexe.v0.models.QuantityByInventory
+    >;
   }
 
-  interface PromotionTriggerForm {
-    readonly type: io.flow.experience.v0.enums.PromotionTriggerType;
-    readonly min?: io.flow.common.v0.models.PriceForm;
+  interface Error {
+    readonly url: string;
+    readonly client_request_id: string;
+    readonly generated_at: string;
+    readonly error: string;
   }
 
-  interface Promotions {
-    readonly applied: io.flow.experience.v0.unions.Promotion[];
-    readonly available: io.flow.experience.v0.unions.Promotion[];
+  interface FlexeAttachment {
+    readonly type: io.flow.flexe.v0.enums.FlexeAttachmentType;
+    readonly display_name: string;
+    readonly url: string;
   }
 
-  interface RegionReference {
-    readonly id: string;
+  interface FlexeEcommerceFulfillment {
+    readonly url: string;
+    readonly client_request_id: string;
+    readonly generated_at: string;
+    readonly data: io.flow.flexe.v0.models.FlexeEcommerceFulfillmentData;
+    readonly errors: io.flow.flexe.v0.models.FlexeEcommerceFulfillmentErrors[];
   }
 
-  interface ValueThresholdExceededDetails {
-    readonly local: io.flow.common.v0.models.Price;
-    readonly original: io.flow.common.v0.models.Price;
+  interface FlexeEcommerceFulfillmentData {
+    readonly import_id: string;
+    readonly succeeded_uuids: string[];
+    readonly failed_uuids: string[];
+    readonly errors: string[];
   }
-}
-
-declare namespace io.flow.experience.v0.unions {
-  type AllocationComponent =
-    | io.flow.experience.v0.models.AllocationDetailComponent
-    | io.flow.experience.v0.models.AllocationLevyComponent;
-  type AllocationDetail =
-    | io.flow.experience.v0.models.AllocationLineDetail
-    | io.flow.experience.v0.models.AllocationOrderDetail;
-  type ExpandableExperience =
-    | io.flow.experience.v0.models.Experience
-    | io.flow.experience.v0.models.ExperienceReference;
-  type ExpandableOrder =
-    | io.flow.experience.v0.models.Order
-    | io.flow.experience.v0.models.OrderReference;
-  type OrderNumberGenerator =
-    | io.flow.experience.v0.models.OrderNumberGeneratorUuid
-    | io.flow.experience.v0.models.OrderNumberGeneratorHexadecimal
-    | io.flow.experience.v0.models.OrderNumberGeneratorPrefixSuffix;
-  type OrderPromotion = io.flow.experience.v0.models.FreeShippingOrderPromotion;
-  type OrderPromotionForm = io.flow.experience.v0.models.FreeShippingOrderPromotionForm;
-
-  type PaymentMethodTag =
-    | {
-        discriminator: 'organization_payment_method_tag';
-        value: io.flow.experience.v0.enums.OrganizationPaymentMethodTag;
-      }
-    | {
-        discriminator: 'experience_payment_method_tag';
-        value: io.flow.experience.v0.enums.ExperiencePaymentMethodTag;
-      };
-
-  type Promotion =
-    | io.flow.experience.v0.models.FreeShipping
-    | io.flow.experience.v0.models.Discount;
-}
-
-declare namespace io.flow.RESERVED_WORD_return.v0.enums {
-  type ReturnStatus = 'open' | 'refunded';
-}
 
-declare namespace io.flow.RESERVED_WORD_return.v0.models {
-  interface Return {
-    readonly id: string;
-    readonly key: string;
-    readonly items: io.flow.RESERVED_WORD_return.v0.models.ReturnLineItem[];
-    readonly labels: io.flow.label.v0.models.ShippingLabel[];
+  interface FlexeEcommerceFulfillmentErrors {
+    readonly status: string;
+    readonly title: string;
+    readonly detail: string;
+    readonly source?: string;
   }
 
-  interface ReturnForm {
-    readonly items: io.flow.RESERVED_WORD_return.v0.models.ReturnLineItem[];
-    readonly tier_id?: string;
-    readonly order_number?: string;
-    readonly service?: string;
-    readonly destination?: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly key?: string;
-    readonly origin?: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly center_key?: string;
+  interface FlexeEcommerceFulfillmentForm {
+    readonly reservation_id: number;
+    readonly client_request_id: string;
+    readonly request: io.flow.flexe.v0.models.Orders;
   }
 
-  interface ReturnItemReference {
-    readonly number: string;
+  interface FlexeInventoryData {
+    readonly sku: string;
+    readonly quantity: string;
+    readonly unit: string;
   }
 
-  interface ReturnLineItem {
-    readonly item_number: string;
-    readonly order_number?: string;
-    readonly quantity: number;
-    readonly reason?: io.flow.RESERVED_WORD_return.v0.models.ReturnReason;
-    readonly notes?: string;
+  interface FlexeRetailAttachment {
+    readonly display_name: string;
+    readonly url: string;
   }
 
-  interface ReturnOrderReference {
-    readonly number: string;
+  interface FlexeRetailFulfillment {
+    readonly url: string;
+    readonly client_request_id: string;
+    readonly generated_at: string;
+    readonly data: io.flow.flexe.v0.models.FlexeRetailFulfillmentData;
+    readonly errors?: io.flow.flexe.v0.models.FlexeRetailFulfillmentErrors[];
   }
 
-  interface ReturnReason {
-    readonly key: string;
-    readonly name: string;
+  interface FlexeRetailFulfillmentData {
+    readonly id: string;
+    readonly purchase_order_uuid: string;
+    readonly status: string;
   }
 
-  interface ReturnReasonForm {
-    readonly key?: string;
-    readonly name?: string;
+  interface FlexeRetailFulfillmentErrors {
+    readonly type: string;
+    readonly message: string;
   }
 
-  interface ReturnReasonPutForm {
-    readonly name?: string;
+  interface FlexeRetailFulfillmentForm {
+    readonly reservation_id: number;
+    readonly client_request_id?: string;
+    readonly request: io.flow.flexe.v0.models.RetailOrder;
   }
 
-  interface ReturnVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly return: io.flow.RESERVED_WORD_return.v0.models.Return;
+  interface FulfillmentOrderDetails {
+    readonly shipment_uuid: string;
+    readonly carrier?: string;
+    readonly carrier_id?: string;
   }
-}
 
-declare namespace io.flow.field.validation.v0.models {
-  interface FieldValidationMax {
-    readonly discriminator: 'max';
-    readonly length: number;
+  interface Gs1Us {
+    readonly number: string;
+    readonly ship_to?: io.flow.flexe.v0.models.Gs1UsShipTo;
+    readonly bill_to?: io.flow.flexe.v0.models.BillTo;
   }
 
-  interface FieldValidationMin {
-    readonly discriminator: 'min';
-    readonly length: number;
+  interface Gs1UsShipTo {
+    readonly cid_number?: string;
+    readonly location_number?: string;
+    readonly free_on_board?: boolean;
   }
 
-  interface FieldValidationPattern {
-    readonly discriminator: 'pattern';
-    readonly pattern: string;
+  interface Inventory {
+    readonly url: string;
+    readonly client_request_id: string;
+    readonly generated_at: string;
+    readonly data: Record<string, io.flow.flexe.v0.models.InventoryDetails>;
   }
 
-  interface FieldValidationRequired {
-    readonly discriminator: 'required';
-    readonly unused: string;
+  interface InventoryCount {
+    readonly amount: number;
+    readonly unit: string;
   }
-}
-
-declare namespace io.flow.field.validation.v0.unions {
-  type FieldValidationRule =
-    | io.flow.field.validation.v0.models.FieldValidationRequired
-    | io.flow.field.validation.v0.models.FieldValidationMin
-    | io.flow.field.validation.v0.models.FieldValidationMax
-    | io.flow.field.validation.v0.models.FieldValidationPattern;
-}
 
-declare namespace io.flow.tracking.internal.v0.enums {
-  type CrossdockTrackingStatus = 'notified' | 'received' | 'shipped';
-}
+  interface InventoryData {
+    readonly pallet: io.flow.flexe.v0.models.InventoryCount;
+    readonly carton?: io.flow.flexe.v0.models.InventoryCount;
+    readonly each?: io.flow.flexe.v0.models.InventoryCount;
+  }
 
-declare namespace io.flow.tracking.internal.v0.models {
-  interface Dhl {
-    readonly discriminator: 'dhl';
-    readonly export_account_number: string;
-    readonly import_account_number: string;
-    readonly password: string;
-    readonly site_id: string;
+  interface InventoryDetails {
+    readonly key: Record<string, io.flow.flexe.v0.models.Sku>;
   }
 
-  interface DhlEcommerce {
-    readonly discriminator: 'dhl_ecommerce';
-    readonly username: string;
-    readonly password: string;
-    readonly client_id: string;
-    readonly pickup_account_number: string;
-    readonly distribution_center: string;
-    readonly pickup_name: string;
+  interface LadingQuantity {
+    readonly num_pallets: number;
   }
 
-  interface FedexCrossborder {
-    readonly discriminator: 'fedex_crossborder';
-    readonly api_key: string;
-    readonly api_url: string;
+  interface Order {
+    readonly shipment_uuid: string;
+    readonly purchase_order: string;
+    readonly carrier: string;
+    readonly service_type: string;
+    readonly carrier_assigned_id: string;
+    readonly name: string;
+    readonly address_1: string;
+    readonly address_2?: string;
+    readonly address_3?: string;
+    readonly city: string;
+    readonly state: string;
+    readonly postal_code: string;
+    readonly phone?: string;
+    readonly instructions?: string;
+    readonly inventory_data: io.flow.flexe.v0.models.FlexeInventoryData[];
+    readonly attachments: io.flow.flexe.v0.models.FlexeAttachment[];
   }
 
-  interface Landmark {
-    readonly discriminator: 'landmark';
-    readonly username: string;
-    readonly password: string;
-    readonly client_id: string;
-    readonly region: string;
+  interface Orders {
+    readonly orders: io.flow.flexe.v0.models.Order[];
   }
 
-  interface SfExpress {
-    readonly discriminator: 'sf_express';
-    readonly checkword: string;
-    readonly customer_code: string;
-    readonly product_code: string;
-    readonly customer_id: string;
+  interface Pallet {
+    readonly pallet_id: string;
+    readonly sku: string;
+    readonly quantity: number;
+    readonly packaging: string;
   }
 
-  interface TrackingEvent {
-    readonly timestamp: string;
-    readonly carrier_status_code: string;
-    readonly location?: string;
-    readonly description?: string;
+  interface PurchaseOrder {
+    readonly retail_fulfillment_order_id: string;
+    readonly bill_of_lading_number: string;
+    readonly purchase_order_uuid: string;
+    readonly pickup_window_start: string;
+    readonly pickup_window_end: string;
+    readonly tags: string[];
   }
 
-  interface TrackingRequest {
-    readonly carrier: string;
-    readonly carrier_tracking_number: string;
-    readonly flow_tracking_number: string;
-    readonly credentials: io.flow.tracking.internal.v0.unions.CarrierCredentials;
+  interface QuantityByInventory {
+    readonly received: io.flow.flexe.v0.models.InventoryData;
+    readonly expected?: io.flow.flexe.v0.models.InventoryData;
+    readonly damaged?: io.flow.flexe.v0.models.InventoryData;
   }
 
-  interface TrackingResponse {
-    readonly carrier: string;
-    readonly carrier_tracking_number: string;
-    readonly flow_tracking_number: string;
-    readonly tracking_events: io.flow.tracking.internal.v0.models.TrackingEvent[];
+  interface ReceiptNotification {
+    readonly shipment_id: string;
+    readonly shipment_type: io.flow.flexe.v0.enums.FlexeShipmentType;
+    readonly reservation_id: string;
+    readonly status: io.flow.flexe.v0.enums.FlexeStatus;
+    readonly delivery_details?: io.flow.flexe.v0.models.DeliveryDetails;
+    readonly container_delivery_details?: io.flow.flexe.v0.models.ContainerDeliveryDetails;
   }
 
-  interface Ups {
-    readonly discriminator: 'ups';
-    readonly username: string;
-    readonly password: string;
-    readonly access_license_number: string;
+  interface RetailFulfillmentOrderDetails {
+    readonly master_bill_of_lading_number: string;
+    readonly scac: string;
+    readonly pro_number: string;
+    readonly purchase_orders: io.flow.flexe.v0.models.PurchaseOrder[];
+    readonly lading_quantity: io.flow.flexe.v0.models.LadingQuantity;
   }
-}
-
-declare namespace io.flow.tracking.internal.v0.unions {
-  type CarrierCredentials =
-    | io.flow.tracking.internal.v0.models.SfExpress
-    | io.flow.tracking.internal.v0.models.DhlEcommerce
-    | io.flow.tracking.internal.v0.models.Landmark
-    | io.flow.tracking.internal.v0.models.Dhl
-    | io.flow.tracking.internal.v0.models.FedexCrossborder
-    | io.flow.tracking.internal.v0.models.Ups;
-}
 
-declare namespace io.flow.item.v0.models {
-  interface LocalItem {
-    readonly id: string;
-    readonly experience: io.flow.common.v0.models.ExperienceSummary;
-    readonly center?: io.flow.fulfillment.v0.models.CenterSummary;
-    readonly item: io.flow.common.v0.models.CatalogItemReference;
-    readonly pricing: io.flow.item.v0.models.LocalItemPricing;
-    readonly status: io.flow.catalog.v0.enums.SubcatalogItemStatus;
+  interface RetailInventoryData {
+    readonly sku: string;
+    readonly quantity: number;
+    readonly unit: string;
+    readonly attachments?: io.flow.flexe.v0.models.FlexeRetailAttachment[];
   }
 
-  interface LocalItemPricing {
-    readonly price: io.flow.catalog.v0.models.LocalizedItemPrice;
-    readonly vat?: io.flow.catalog.v0.models.LocalizedItemVat;
-    readonly duty?: io.flow.catalog.v0.models.LocalizedItemDuty;
-    readonly attributes: Record<string, io.flow.common.v0.models.PriceWithBase>;
+  interface RetailOrder {
+    readonly order: io.flow.flexe.v0.models.RetailOrderData;
   }
-}
 
-declare namespace io.flow.flexe.v0.enums {
-  type FlexeAttachmentType =
-    | 'shipping_label'
-    | 'packing_slip'
-    | 'packing_slip_letter';
-  type FlexeNotification = 'receipt' | 'shipment';
-  type FlexeShipmentType =
-    | 'fulfillment_order'
-    | 'retail_fulfillment_order'
-    | 'carton_pick_delivery'
-    | 'delivery'
-    | 'container_delivery';
-  type FlexeStatus = 'in_transit' | 'completed';
-}
-
-declare namespace io.flow.flexe.v0.models {
-  interface BillOfLading {
-    readonly type: string;
-    readonly gs1us?: io.flow.flexe.v0.models.Gs1Us;
+  interface RetailOrderData {
+    readonly purchase_order_uuid: string;
+    readonly bill_of_lading: io.flow.flexe.v0.models.BillOfLading;
+    readonly inventory_data: io.flow.flexe.v0.models.RetailInventoryData[];
+    readonly ship_within: io.flow.flexe.v0.models.ShipWithin;
+    readonly ship_to: io.flow.flexe.v0.models.ShipTo;
+    readonly build_by?: string;
+    readonly instrunctions?: string;
+    readonly routing_details_id?: string;
+    readonly destination_type?: string;
   }
 
-  interface BillTo {
+  interface ShipTo {
     readonly name: string;
     readonly address_1: string;
     readonly locality: string;
@@ -1737,748 +1691,818 @@ declare namespace io.flow.flexe.v0.models {
     readonly address_3?: string;
   }
 
-  interface CartonPickDeliveryDetails {
+  interface ShipWithin {
+    readonly start: string;
+    readonly end: string;
+  }
+
+  interface ShipmentDeliveryDetails {
     readonly shipment_uuid?: string;
-    readonly carrier?: string;
-    readonly carrier_id?: string;
   }
 
-  interface ContainerDeliveryDetails {
-    readonly purchase_order: string;
-    readonly container_number?: string;
-    readonly seal_number?: string;
-    readonly vendor?: string;
-    readonly expected_inventory: io.flow.flexe.v0.models.InventoryDetails[];
-    readonly received_inventory: io.flow.flexe.v0.models.InventoryDetails[];
-    readonly damaged_inventory: io.flow.flexe.v0.models.InventoryDetails[];
-    readonly quantities_by_inventory: Record<
-      string,
-      io.flow.flexe.v0.models.QuantityByInventory
-    >;
+  interface ShipmentNotification {
+    readonly shipment_id: string;
+    readonly shipment_type: io.flow.flexe.v0.enums.FlexeShipmentType;
+    readonly reservation_id: string;
+    readonly status: io.flow.flexe.v0.enums.FlexeStatus;
+    readonly fulfillment_order_details?: io.flow.flexe.v0.models.FulfillmentOrderDetails;
+    readonly retail_fulfillment_order_details?: io.flow.flexe.v0.models.RetailFulfillmentOrderDetails;
+    readonly delivery_details?: io.flow.flexe.v0.models.ShipmentDeliveryDetails;
+    readonly carton_pick_delivery_details?: io.flow.flexe.v0.models.CartonPickDeliveryDetails;
   }
 
-  interface DeliveryDetails {
-    readonly shipment_uuid?: string;
-    readonly trailer_number?: string;
-    readonly pallets: io.flow.flexe.v0.models.Pallet[];
-    readonly quantities_by_inventory: Record<
-      string,
-      io.flow.flexe.v0.models.QuantityByInventory
-    >;
+  interface Sku {
+    readonly sku: string;
+    readonly description: string;
+    readonly summary: Record<string, io.flow.flexe.v0.models.SkuSummary>;
   }
 
-  interface Error {
-    readonly url: string;
-    readonly client_request_id: string;
-    readonly generated_at: string;
-    readonly error: string;
+  interface SkuSummary {
+    readonly key: string;
+    readonly quantity: number;
+    readonly unit: string;
   }
+}
 
-  interface FlexeAttachment {
-    readonly type: io.flow.flexe.v0.enums.FlexeAttachmentType;
-    readonly display_name: string;
-    readonly url: string;
+declare namespace io.flow.harmonization.internal.event.v0.enums {
+  type SuggestionAction = 'accept' | 'validate' | 'review';
+}
+
+declare namespace io.flow.harmonization.internal.event.v0.models {
+  interface AllItemsExport {
+    readonly discriminator: 'all_items_export';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly export_id: string;
   }
 
-  interface FlexeEcommerceFulfillment {
-    readonly url: string;
-    readonly client_request_id: string;
-    readonly generated_at: string;
-    readonly data: io.flow.flexe.v0.models.FlexeEcommerceFulfillmentData;
-    readonly errors: io.flow.flexe.v0.models.FlexeEcommerceFulfillmentErrors[];
+  interface BatchRateRefillRequest {
+    readonly discriminator: 'batch_rate_refill_request';
+    readonly requests: io.flow.harmonization.internal.event.v0.models.RateRefillRequest[];
   }
 
-  interface FlexeEcommerceFulfillmentData {
-    readonly import_id: string;
-    readonly succeeded_uuids: string[];
-    readonly failed_uuids: string[];
-    readonly errors: string[];
+  interface BlacklistedItemCreated {
+    readonly discriminator: 'blacklisted_item_created';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly blacklisted_item: io.flow.harmonization.internal.v0.models.BlacklistedItem;
   }
 
-  interface FlexeEcommerceFulfillmentErrors {
-    readonly status: string;
-    readonly title: string;
-    readonly detail: string;
-    readonly source?: string;
+  interface BlacklistedItemDeleted {
+    readonly discriminator: 'blacklisted_item_deleted';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly id: string;
   }
 
-  interface FlexeEcommerceFulfillmentForm {
-    readonly reservation_id: number;
-    readonly client_request_id: string;
-    readonly request: io.flow.flexe.v0.models.Orders;
+  interface BlacklistedItemUpdated {
+    readonly discriminator: 'blacklisted_item_updated';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly blacklisted_item: io.flow.harmonization.internal.v0.models.BlacklistedItem;
   }
 
-  interface FlexeInventoryData {
-    readonly sku: string;
-    readonly quantity: string;
-    readonly unit: string;
+  interface CustomsDescriptionImport {
+    readonly discriminator: 'customs_description_import';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly import_id: string;
+    readonly source_url: string;
+    readonly filename?: string;
   }
 
-  interface FlexeRetailAttachment {
-    readonly display_name: string;
-    readonly url: string;
+  interface CustomsDescriptionSugestion {
+    readonly value: number;
+    readonly customs_description: string;
+    readonly action?: io.flow.harmonization.internal.event.v0.enums.SuggestionAction;
   }
 
-  interface FlexeRetailFulfillment {
-    readonly url: string;
-    readonly client_request_id: string;
-    readonly generated_at: string;
-    readonly data: io.flow.flexe.v0.models.FlexeRetailFulfillmentData;
-    readonly errors?: io.flow.flexe.v0.models.FlexeRetailFulfillmentErrors[];
+  interface CustomsDescriptionSugestionCreated {
+    readonly discriminator: 'customs_description_sugestion_created';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly item_id: string;
+    readonly suggestions: io.flow.harmonization.internal.event.v0.models.CustomsDescriptionSugestion[];
+    readonly model_id: string;
+  }
+
+  interface CustomsDescriptionTariffsImport {
+    readonly discriminator: 'customs_description_tariffs_import';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly import_id: string;
+    readonly source_url: string;
+    readonly filename?: string;
+  }
+
+  interface DutiedItemsExport {
+    readonly discriminator: 'dutied_items_export';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly export_id: string;
+    readonly origin?: string;
+    readonly destination: string;
+    readonly item_numbers?: string[];
   }
 
-  interface FlexeRetailFulfillmentData {
-    readonly id: string;
-    readonly purchase_order_uuid: string;
-    readonly status: string;
+  interface HarmonizationCodesImport {
+    readonly discriminator: 'harmonization_codes_import';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly import_id: string;
+    readonly source_url: string;
+    readonly filename?: string;
   }
 
-  interface FlexeRetailFulfillmentErrors {
-    readonly type: string;
-    readonly message: string;
+  interface HarmonizationPhraseSuggestionRequestImport {
+    readonly discriminator: 'harmonization_phrase_suggestion_request_import';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly import_id: string;
+    readonly source_url: string;
+    readonly filename?: string;
   }
 
-  interface FlexeRetailFulfillmentForm {
-    readonly reservation_id: number;
-    readonly client_request_id?: string;
-    readonly request: io.flow.flexe.v0.models.RetailOrder;
+  interface HarmonizeFullyRequest {
+    readonly discriminator: 'harmonize_fully_request';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly item_id: string;
   }
 
-  interface FulfillmentOrderDetails {
-    readonly shipment_uuid: string;
-    readonly carrier?: string;
-    readonly carrier_id?: string;
+  interface HarmonizeFullyWithRate {
+    readonly discriminator: 'harmonize_fully_with_rate';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly duty_rate: io.flow.duty.internal.v0.models.DutyRate;
   }
 
-  interface Gs1Us {
-    readonly number: string;
-    readonly ship_to?: io.flow.flexe.v0.models.Gs1UsShipTo;
-    readonly bill_to?: io.flow.flexe.v0.models.BillTo;
+  interface HarmonizedItemsHs6Export {
+    readonly discriminator: 'harmonized_items_hs6_export';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly export_id: string;
   }
 
-  interface Gs1UsShipTo {
-    readonly cid_number?: string;
-    readonly location_number?: string;
-    readonly free_on_board?: boolean;
+  interface ItemClassificationCreated {
+    readonly discriminator: 'item_classification_created';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly item_number: string;
+    readonly model_id: string;
+    readonly labels_prediction: io.flow.harmonization.internal.event.v0.models.LabelsPrediction;
+    readonly action: io.flow.harmonization.internal.event.v0.enums.SuggestionAction;
   }
 
-  interface Inventory {
-    readonly url: string;
-    readonly client_request_id: string;
-    readonly generated_at: string;
-    readonly data: Record<string, io.flow.flexe.v0.models.InventoryDetails>;
+  interface ItemHarmonized {
+    readonly discriminator: 'item_harmonized';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly item_number: string;
+    readonly product_id: string;
+    readonly customs_description: string;
+    readonly countries_of_origin: string[];
+    readonly hs_6: string;
+    readonly tariffs: Record<
+      string,
+      io.flow.harmonization.internal.v0.models.TariffCodeDuty
+    >;
   }
 
-  interface InventoryCount {
-    readonly amount: number;
-    readonly unit: string;
+  interface LabelsPrediction {
+    readonly main_material: Record<string, number>;
+    readonly gender: Record<string, number>;
+    readonly construction: Record<string, number>;
+    readonly product_type: Record<string, number>;
   }
 
-  interface InventoryData {
-    readonly pallet: io.flow.flexe.v0.models.InventoryCount;
-    readonly carton?: io.flow.flexe.v0.models.InventoryCount;
-    readonly each?: io.flow.flexe.v0.models.InventoryCount;
+  interface LandedCostExport {
+    readonly discriminator: 'landed_cost_export';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly export_id: string;
+    readonly items: io.flow.harmonization.internal.event.v0.models.LandedCostItem[];
   }
 
-  interface InventoryDetails {
-    readonly key: Record<string, io.flow.flexe.v0.models.Sku>;
+  interface LandedCostItem {
+    readonly number: string;
+    readonly origin: string;
+    readonly destination: string;
   }
 
-  interface LadingQuantity {
-    readonly num_pallets: number;
+  interface PhraseClassified {
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly phrase_id: string;
   }
 
-  interface Order {
-    readonly shipment_uuid: string;
-    readonly purchase_order: string;
-    readonly carrier: string;
-    readonly service_type: string;
-    readonly carrier_assigned_id: string;
-    readonly name: string;
-    readonly address_1: string;
-    readonly address_2?: string;
-    readonly address_3?: string;
-    readonly city: string;
-    readonly state: string;
-    readonly postal_code: string;
-    readonly phone?: string;
-    readonly instructions?: string;
-    readonly inventory_data: io.flow.flexe.v0.models.FlexeInventoryData[];
-    readonly attachments: io.flow.flexe.v0.models.FlexeAttachment[];
+  interface PhrasePropagated {
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly phrase_id: string;
   }
 
-  interface Orders {
-    readonly orders: io.flow.flexe.v0.models.Order[];
+  interface RateRefillRequest {
+    readonly discriminator: 'rate_refill_request';
+    readonly phrase_id: string;
+    readonly hs6_code: string;
+    readonly destinations: io.flow.reference.v0.models.Country[];
+    readonly origin: io.flow.reference.v0.models.Country;
+    readonly organization_id?: string;
   }
 
-  interface Pallet {
-    readonly pallet_id: string;
-    readonly sku: string;
-    readonly quantity: number;
-    readonly packaging: string;
+  interface UnharmonizedItemsExport {
+    readonly discriminator: 'unharmonized_items_export';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly export_id: string;
   }
+}
 
-  interface PurchaseOrder {
-    readonly retail_fulfillment_order_id: string;
-    readonly bill_of_lading_number: string;
-    readonly purchase_order_uuid: string;
-    readonly pickup_window_start: string;
-    readonly pickup_window_end: string;
-    readonly tags: string[];
-  }
+declare namespace io.flow.harmonization.internal.event.v0.unions {
+  type CustomsDescriptions =
+    | io.flow.harmonization.internal.event.v0.models.CustomsDescriptionImport
+    | io.flow.harmonization.internal.event.v0.models.CustomsDescriptionTariffsImport;
+  type HarmonizationEvent =
+    | io.flow.harmonization.internal.event.v0.models.BlacklistedItemCreated
+    | io.flow.harmonization.internal.event.v0.models.BlacklistedItemUpdated
+    | io.flow.harmonization.internal.event.v0.models.BlacklistedItemDeleted;
+  type HarmonizationExportRequest =
+    | io.flow.harmonization.internal.event.v0.models.AllItemsExport
+    | io.flow.harmonization.internal.event.v0.models.HarmonizedItemsHs6Export
+    | io.flow.harmonization.internal.event.v0.models.UnharmonizedItemsExport
+    | io.flow.harmonization.internal.event.v0.models.DutiedItemsExport
+    | io.flow.harmonization.internal.event.v0.models.LandedCostExport;
+  type HarmonizationImportPhraseSuggestionRequest = io.flow.harmonization.internal.event.v0.models.HarmonizationPhraseSuggestionRequestImport;
+  type HarmonizationImportRequest = io.flow.harmonization.internal.event.v0.models.HarmonizationCodesImport;
+  type HarmonizationSugestionEvent =
+    | io.flow.harmonization.internal.event.v0.models.CustomsDescriptionSugestionCreated
+    | io.flow.harmonization.internal.event.v0.models.ItemClassificationCreated;
+  type HarmonizeFully =
+    | io.flow.harmonization.internal.event.v0.models.HarmonizeFullyWithRate
+    | io.flow.harmonization.internal.event.v0.models.ItemHarmonized
+    | io.flow.harmonization.internal.event.v0.models.HarmonizeFullyRequest;
+  type RefillActorRequest =
+    | io.flow.harmonization.internal.event.v0.models.BatchRateRefillRequest
+    | io.flow.harmonization.internal.event.v0.models.RateRefillRequest;
+}
 
-  interface QuantityByInventory {
-    readonly received: io.flow.flexe.v0.models.InventoryData;
-    readonly expected?: io.flow.flexe.v0.models.InventoryData;
-    readonly damaged?: io.flow.flexe.v0.models.InventoryData;
-  }
+declare namespace io.flow.inventory.v0.enums {
+  type Aggregate = 'maximum' | 'minimum';
+  type InventoryStatus = 'has_inventory' | 'no_inventory';
+  type SerialStatus = 'available' | 'reserved' | 'sold';
+  type UpdateType = 'change' | 'set';
+}
 
-  interface ReceiptNotification {
-    readonly shipment_id: string;
-    readonly shipment_type: io.flow.flexe.v0.enums.FlexeShipmentType;
-    readonly reservation_id: string;
-    readonly status: io.flow.flexe.v0.enums.FlexeStatus;
-    readonly delivery_details?: io.flow.flexe.v0.models.DeliveryDetails;
-    readonly container_delivery_details?: io.flow.flexe.v0.models.ContainerDeliveryDetails;
+declare namespace io.flow.inventory.v0.models {
+  interface ExternalApiTimeoutReservationError {
+    readonly code: 'external_api_timeout';
+    readonly messages: string[];
   }
 
-  interface RetailFulfillmentOrderDetails {
-    readonly master_bill_of_lading_number: string;
-    readonly scac: string;
-    readonly pro_number: string;
-    readonly purchase_orders: io.flow.flexe.v0.models.PurchaseOrder[];
-    readonly lading_quantity: io.flow.flexe.v0.models.LadingQuantity;
+  interface GenericReservationError {
+    readonly code: 'generic_reservation_error';
+    readonly messages: string[];
   }
 
-  interface RetailInventoryData {
-    readonly sku: string;
+  interface InventoryBackorder {
+    readonly discriminator: 'inventory_backorder';
     readonly quantity: number;
-    readonly unit: string;
-    readonly attachments?: io.flow.flexe.v0.models.FlexeRetailAttachment[];
-  }
-
-  interface RetailOrder {
-    readonly order: io.flow.flexe.v0.models.RetailOrderData;
   }
 
-  interface RetailOrderData {
-    readonly purchase_order_uuid: string;
-    readonly bill_of_lading: io.flow.flexe.v0.models.BillOfLading;
-    readonly inventory_data: io.flow.flexe.v0.models.RetailInventoryData[];
-    readonly ship_within: io.flow.flexe.v0.models.ShipWithin;
-    readonly ship_to: io.flow.flexe.v0.models.ShipTo;
-    readonly build_by?: string;
-    readonly instrunctions?: string;
-    readonly routing_details_id?: string;
-    readonly destination_type?: string;
+  interface InventoryCenterReference {
+    readonly key: string;
   }
 
-  interface ShipTo {
-    readonly name: string;
-    readonly address_1: string;
-    readonly locality: string;
-    readonly region: string;
-    readonly postal_code: string;
-    readonly country: string;
-    readonly address_2?: string;
-    readonly address_3?: string;
+  interface InventoryCheckResponse {
+    readonly items: io.flow.inventory.v0.models.InventoryCheckResponseItem[];
   }
 
-  interface ShipWithin {
-    readonly start: string;
-    readonly end: string;
+  interface InventoryCheckResponseItem {
+    readonly number: string;
+    readonly quantity: number;
+    readonly inventory_status: io.flow.inventory.v0.enums.InventoryStatus;
   }
 
-  interface ShipmentDeliveryDetails {
-    readonly shipment_uuid?: string;
+  interface InventoryExperienceReference {
+    readonly key: string;
   }
 
-  interface ShipmentNotification {
-    readonly shipment_id: string;
-    readonly shipment_type: io.flow.flexe.v0.enums.FlexeShipmentType;
-    readonly reservation_id: string;
-    readonly status: io.flow.flexe.v0.enums.FlexeStatus;
-    readonly fulfillment_order_details?: io.flow.flexe.v0.models.FulfillmentOrderDetails;
-    readonly retail_fulfillment_order_details?: io.flow.flexe.v0.models.RetailFulfillmentOrderDetails;
-    readonly delivery_details?: io.flow.flexe.v0.models.ShipmentDeliveryDetails;
-    readonly carton_pick_delivery_details?: io.flow.flexe.v0.models.CartonPickDeliveryDetails;
+  interface InventoryItemReference {
+    readonly number: string;
   }
 
-  interface Sku {
-    readonly sku: string;
-    readonly description: string;
-    readonly summary: Record<string, io.flow.flexe.v0.models.SkuSummary>;
+  interface InventoryRequest {
+    readonly items: io.flow.inventory.v0.models.InventoryRequestItem[];
   }
 
-  interface SkuSummary {
-    readonly key: string;
+  interface InventoryRequestItem {
+    readonly number: string;
     readonly quantity: number;
-    readonly unit: string;
   }
-}
 
-declare namespace io.flow.harmonization.internal.event.v0.enums {
-  type SuggestionAction = 'accept' | 'validate' | 'review';
-}
+  interface InventoryRule {
+    readonly id: string;
+    readonly position: number;
+    readonly query: string;
+    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+  }
 
-declare namespace io.flow.harmonization.internal.event.v0.models {
-  interface AllItemsExport {
-    readonly discriminator: 'all_items_export';
-    readonly event_id: string;
+  interface InventoryRuleForm {
+    readonly position: number;
+    readonly query: string;
+    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+  }
+
+  interface InventoryRuleVersion {
+    readonly id: string;
     readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly inventory_rule: io.flow.inventory.v0.models.InventoryRule;
   }
 
-  interface BatchRateRefillRequest {
-    readonly discriminator: 'batch_rate_refill_request';
-    readonly requests: io.flow.harmonization.internal.event.v0.models.RateRefillRequest[];
+  interface InventorySnapshot {
+    readonly id: string;
+    readonly available: number;
+    readonly center: io.flow.inventory.v0.models.InventoryCenterReference;
+    readonly item: io.flow.inventory.v0.models.InventoryItemReference;
+    readonly quantity: number;
   }
 
-  interface BlacklistedItemCreated {
-    readonly discriminator: 'blacklisted_item_created';
-    readonly event_id: string;
+  interface InventorySnapshotVersion {
+    readonly id: string;
     readonly timestamp: string;
-    readonly organization: string;
-    readonly blacklisted_item: io.flow.harmonization.internal.v0.models.BlacklistedItem;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly inventory_snapshot: io.flow.inventory.v0.models.InventorySnapshot;
   }
 
-  interface BlacklistedItemDeleted {
-    readonly discriminator: 'blacklisted_item_deleted';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
+  interface InventoryStock {
+    readonly discriminator: 'inventory_stock';
+    readonly quantity: number;
+  }
+
+  interface InventoryUnlimited {
+    readonly discriminator: 'inventory_unlimited';
+    readonly quantity: string;
+  }
+
+  interface InventoryUpdate {
     readonly id: string;
+    readonly idempotency_key: string;
+    readonly center: io.flow.inventory.v0.models.InventoryCenterReference;
+    readonly item: io.flow.inventory.v0.models.InventoryItemReference;
+    readonly notes: any /*object*/;
+    readonly quantity: number;
+    readonly type: io.flow.inventory.v0.enums.UpdateType;
   }
 
-  interface BlacklistedItemUpdated {
-    readonly discriminator: 'blacklisted_item_updated';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly blacklisted_item: io.flow.harmonization.internal.v0.models.BlacklistedItem;
+  interface InventoryUpdateForm {
+    readonly center: string;
+    readonly idempotency_key: string;
+    readonly item_number: string;
+    readonly quantity: number;
+    readonly type: io.flow.inventory.v0.enums.UpdateType;
+    readonly notes?: any /*object*/;
   }
 
-  interface CustomsDescriptionImport {
-    readonly discriminator: 'customs_description_import';
-    readonly event_id: string;
+  interface InventoryUpdateVersion {
+    readonly id: string;
     readonly timestamp: string;
-    readonly organization: string;
-    readonly import_id: string;
-    readonly source_url: string;
-    readonly filename?: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly inventory_update: io.flow.inventory.v0.models.InventoryUpdate;
   }
 
-  interface CustomsDescriptionSugestion {
-    readonly value: number;
-    readonly customs_description: string;
-    readonly action?: io.flow.harmonization.internal.event.v0.enums.SuggestionAction;
+  interface NoInventoryReservationError {
+    readonly code: 'no_inventory';
+    readonly messages: string[];
+    readonly items: io.flow.inventory.v0.models.NoInventoryReservationErrorItem[];
   }
 
-  interface CustomsDescriptionSugestionCreated {
-    readonly discriminator: 'customs_description_sugestion_created';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly item_id: string;
-    readonly suggestions: io.flow.harmonization.internal.event.v0.models.CustomsDescriptionSugestion[];
-    readonly model_id: string;
+  interface NoInventoryReservationErrorItem {
+    readonly number: string;
+    readonly requested_quantity: number;
+    readonly available_quantity: number;
   }
 
-  interface CustomsDescriptionTariffsImport {
-    readonly discriminator: 'customs_description_tariffs_import';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly import_id: string;
-    readonly source_url: string;
-    readonly filename?: string;
+  interface PfsInventoryCheckResponse {
+    readonly items: Record<
+      string,
+      io.flow.inventory.v0.models.PfsInventoryCheckResponseItem
+    >;
   }
 
-  interface DutiedItemsExport {
-    readonly discriminator: 'dutied_items_export';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
-    readonly origin?: string;
-    readonly destination: string;
-    readonly item_numbers?: string[];
+  interface PfsInventoryCheckResponseItem {
+    readonly number: string;
+    readonly ats: number;
+    readonly in_stock: boolean;
   }
 
-  interface HarmonizationCodesImport {
-    readonly discriminator: 'harmonization_codes_import';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly import_id: string;
-    readonly source_url: string;
-    readonly filename?: string;
+  interface PfsInventoryStatus {
+    readonly status: string;
   }
 
-  interface HarmonizationPhraseSuggestionRequestImport {
-    readonly discriminator: 'harmonization_phrase_suggestion_request_import';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly import_id: string;
-    readonly source_url: string;
-    readonly filename?: string;
+  interface Reservation {
+    readonly id: string;
+    readonly key: string;
+    readonly order?: io.flow.inventory.v0.models.ReservationOrderReference;
+    readonly items: io.flow.inventory.v0.models.ReservationItem[];
+    readonly reserved_until?: string;
   }
 
-  interface HarmonizeFullyRequest {
-    readonly discriminator: 'harmonize_fully_request';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly item_id: string;
+  interface ReservationForm {
+    readonly order_number?: string;
+    readonly items: io.flow.inventory.v0.models.ReservationItemForm[];
   }
 
-  interface HarmonizeFullyWithRate {
-    readonly discriminator: 'harmonize_fully_with_rate';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly duty_rate: io.flow.duty.internal.v0.models.DutyRate;
+  interface ReservationItem {
+    readonly item: io.flow.inventory.v0.models.ReservationItemReference;
+    readonly quantity: number;
   }
 
-  interface HarmonizedItemsHs6Export {
-    readonly discriminator: 'harmonized_items_hs6_export';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
+  interface ReservationItemForm {
+    readonly item_number: string;
+    readonly quantity: number;
   }
 
-  interface ItemClassificationCreated {
-    readonly discriminator: 'item_classification_created';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
+  interface ReservationItemReference {
+    readonly number: string;
+  }
+
+  interface ReservationOrderReference {
+    readonly number: string;
+  }
+
+  interface Serial {
+    readonly id: string;
+    readonly number: string;
     readonly item_number: string;
-    readonly model_id: string;
-    readonly labels_prediction: io.flow.harmonization.internal.event.v0.models.LabelsPrediction;
-    readonly action: io.flow.harmonization.internal.event.v0.enums.SuggestionAction;
+    readonly item_price: io.flow.common.v0.models.Price;
+    readonly status: io.flow.inventory.v0.enums.SerialStatus;
+    readonly center: io.flow.fulfillment.v0.models.CenterReference;
+    readonly attributes: Record<string, string>;
+  }
+
+  interface SerialForm {
+    readonly number: string;
+    readonly item_number: string;
+    readonly item_price: number;
+    readonly item_currency: string;
+    readonly status: io.flow.inventory.v0.enums.SerialStatus;
+    readonly center_key?: string;
+    readonly attributes?: Record<string, string>;
+  }
+
+  interface SerialVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly serial: io.flow.inventory.v0.models.Serial;
   }
+}
 
-  interface ItemHarmonized {
-    readonly discriminator: 'item_harmonized';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly item_number: string;
-    readonly product_id: string;
-    readonly customs_description: string;
-    readonly countries_of_origin: string[];
-    readonly hs_6: string;
-    readonly tariffs: Record<
-      string,
-      io.flow.harmonization.internal.v0.models.TariffCodeDuty
-    >;
+declare namespace io.flow.inventory.v0.unions {
+  type InventoryStrategy =
+    | io.flow.inventory.v0.models.InventoryBackorder
+    | io.flow.inventory.v0.models.InventoryStock
+    | io.flow.inventory.v0.models.InventoryUnlimited;
+  type ReservationError =
+    | io.flow.inventory.v0.models.NoInventoryReservationError
+    | io.flow.inventory.v0.models.ExternalApiTimeoutReservationError
+    | io.flow.inventory.v0.models.GenericReservationError;
+}
+
+declare namespace io.flow.ratecard.v0.models {
+  interface CrossdockRatecardFee {
+    readonly discriminator: 'crossdock_ratecard_fee';
+    readonly amount: io.flow.common.v0.models.Money;
   }
 
-  interface LabelsPrediction {
-    readonly main_material: Record<string, number>;
-    readonly gender: Record<string, number>;
-    readonly construction: Record<string, number>;
-    readonly product_type: Record<string, number>;
+  interface DdpRatecardFee {
+    readonly discriminator: 'ddp_ratecard_fee';
+    readonly amount: number;
   }
 
-  interface LandedCostExport {
-    readonly discriminator: 'landed_cost_export';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
-    readonly items: io.flow.harmonization.internal.event.v0.models.LandedCostItem[];
+  interface DimensionEstimate {
+    readonly id: string;
+    readonly q: string;
+    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
+    readonly position: number;
   }
 
-  interface LandedCostItem {
-    readonly number: string;
-    readonly origin: string;
-    readonly destination: string;
+  interface DimensionEstimateForm {
+    readonly q: string;
+    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
+    readonly position?: number;
   }
 
-  interface PhraseClassified {
-    readonly event_id: string;
+  interface DimensionEstimateVersion {
+    readonly id: string;
     readonly timestamp: string;
-    readonly phrase_id: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly dimension_estimate: io.flow.ratecard.v0.models.DimensionEstimate;
   }
 
-  interface PhrasePropagated {
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly phrase_id: string;
+  interface EstimatedDimensions {
+    readonly depth: io.flow.common.v0.models.Measurement;
+    readonly length: io.flow.common.v0.models.Measurement;
+    readonly weight: io.flow.common.v0.models.Measurement;
+    readonly width: io.flow.common.v0.models.Measurement;
   }
 
-  interface RateRefillRequest {
-    readonly discriminator: 'rate_refill_request';
-    readonly phrase_id: string;
-    readonly hs6_code: string;
-    readonly destinations: io.flow.reference.v0.models.Country[];
-    readonly origin: io.flow.reference.v0.models.Country;
-    readonly organization_id?: string;
+  interface FuelSurchargeRatecardFee {
+    readonly discriminator: 'fuel_surcharge_ratecard_fee';
+    readonly amount: io.flow.common.v0.models.Money;
   }
 
-  interface UnharmonizedItemsExport {
-    readonly discriminator: 'unharmonized_items_export';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
+  interface FuelSurchargeServiceFee {
+    readonly discriminator: 'fuel_surcharge_service_fee';
+    readonly percent: number;
   }
-}
 
-declare namespace io.flow.harmonization.internal.event.v0.unions {
-  type CustomsDescriptions =
-    | io.flow.harmonization.internal.event.v0.models.CustomsDescriptionImport
-    | io.flow.harmonization.internal.event.v0.models.CustomsDescriptionTariffsImport;
-  type HarmonizationEvent =
-    | io.flow.harmonization.internal.event.v0.models.BlacklistedItemCreated
-    | io.flow.harmonization.internal.event.v0.models.BlacklistedItemUpdated
-    | io.flow.harmonization.internal.event.v0.models.BlacklistedItemDeleted;
-  type HarmonizationExportRequest =
-    | io.flow.harmonization.internal.event.v0.models.AllItemsExport
-    | io.flow.harmonization.internal.event.v0.models.HarmonizedItemsHs6Export
-    | io.flow.harmonization.internal.event.v0.models.UnharmonizedItemsExport
-    | io.flow.harmonization.internal.event.v0.models.DutiedItemsExport
-    | io.flow.harmonization.internal.event.v0.models.LandedCostExport;
-  type HarmonizationImportPhraseSuggestionRequest = io.flow.harmonization.internal.event.v0.models.HarmonizationPhraseSuggestionRequestImport;
-  type HarmonizationImportRequest = io.flow.harmonization.internal.event.v0.models.HarmonizationCodesImport;
-  type HarmonizationSugestionEvent =
-    | io.flow.harmonization.internal.event.v0.models.CustomsDescriptionSugestionCreated
-    | io.flow.harmonization.internal.event.v0.models.ItemClassificationCreated;
-  type HarmonizeFully =
-    | io.flow.harmonization.internal.event.v0.models.HarmonizeFullyWithRate
-    | io.flow.harmonization.internal.event.v0.models.ItemHarmonized
-    | io.flow.harmonization.internal.event.v0.models.HarmonizeFullyRequest;
-  type RefillActorRequest =
-    | io.flow.harmonization.internal.event.v0.models.BatchRateRefillRequest
-    | io.flow.harmonization.internal.event.v0.models.RateRefillRequest;
-}
+  interface Hop {
+    readonly hop_number: number;
+    readonly hop_estimate: io.flow.ratecard.v0.models.HopEstimate;
+  }
 
-declare namespace io.flow.inventory.v0.enums {
-  type Aggregate = 'maximum' | 'minimum';
-  type InventoryStatus = 'has_inventory' | 'no_inventory';
-  type SerialStatus = 'available' | 'reserved' | 'sold';
-  type UpdateType = 'change' | 'set';
-}
+  interface HopEstimate {
+    readonly origin_address: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly destination_address: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
+    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
+    readonly currency: string;
+    readonly amount: number;
+    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
+    readonly total: number;
+  }
 
-declare namespace io.flow.inventory.v0.models {
-  interface ExternalApiTimeoutReservationError {
-    readonly code: 'external_api_timeout';
-    readonly messages: string[];
+  interface OversizedShipmentRatecardFee {
+    readonly discriminator: 'oversized_shipment_ratecard_fee';
+    readonly weight_threshold: number;
+    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly margin?: number;
+    readonly amount?: number;
   }
 
-  interface GenericReservationError {
-    readonly code: 'generic_reservation_error';
-    readonly messages: string[];
+  interface Ratecard {
+    readonly id: string;
+    readonly number: string;
+    readonly direction: io.flow.label.v0.enums.Direction;
+    readonly effective_at: string;
+    readonly origination_zones: io.flow.common.v0.models.Zone[];
+    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
+    readonly published_at?: string;
+    readonly ratecard_owner: io.flow.fulfillment.v0.enums.RatecardOwner;
   }
 
-  interface InventoryBackorder {
-    readonly discriminator: 'inventory_backorder';
-    readonly quantity: number;
+  interface RatecardCarrierSummary {
+    readonly id: string;
+    readonly name: string;
   }
 
-  interface InventoryCenterReference {
-    readonly key: string;
+  interface RatecardEstimateFormV1 {
+    readonly discriminator: 'ratecard_estimate_form_v1';
+    readonly origin?: string;
+    readonly destination?: string;
+    readonly weight_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly distance_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly service?: string;
+    readonly weight?: number;
+    readonly length?: number;
+    readonly width?: number;
+    readonly depth?: number;
+    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
+    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
   }
 
-  interface InventoryCheckResponse {
-    readonly items: io.flow.inventory.v0.models.InventoryCheckResponseItem[];
+  interface RatecardEstimateFormV2 {
+    readonly discriminator: 'ratecard_estimate_form_v2';
+    readonly origin_address: io.flow.common.v0.models.Address;
+    readonly destination_address: io.flow.common.v0.models.Address;
+    readonly weight_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly distance_unit?: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly service?: string;
+    readonly weight?: number;
+    readonly length?: number;
+    readonly width?: number;
+    readonly depth?: number;
+    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
+    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
+    readonly center_id?: string;
   }
 
-  interface InventoryCheckResponseItem {
-    readonly number: string;
-    readonly quantity: number;
-    readonly inventory_status: io.flow.inventory.v0.enums.InventoryStatus;
+  interface RatecardEstimateSummaryForm {
+    readonly origin?: string;
+    readonly destination?: string;
+    readonly service?: string;
+    readonly center_key?: string;
   }
 
-  interface InventoryExperienceReference {
-    readonly key: string;
+  interface RatecardEstimateV1 {
+    readonly discriminator: 'ratecard_estimate_v1';
+    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
+    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
+    readonly currency: string;
+    readonly amount: number;
+    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
+    readonly total: number;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly dimensional_weight?: io.flow.common.v0.models.Measurement;
+    readonly gravitational_weight?: io.flow.common.v0.models.Measurement;
+    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
   }
 
-  interface InventoryItemReference {
-    readonly number: string;
+  interface RatecardEstimateV2 {
+    readonly discriminator: 'ratecard_estimate_v2';
+    readonly hops: io.flow.ratecard.v0.models.Hop[];
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly dimensional_weight?: io.flow.common.v0.models.Measurement;
+    readonly gravitational_weight?: io.flow.common.v0.models.Measurement;
+    readonly line_items?: io.flow.common.v0.models.LineItemForm[];
+    readonly ratecard_owner?: io.flow.fulfillment.v0.enums.RatecardOwner;
   }
 
-  interface InventoryRequest {
-    readonly items: io.flow.inventory.v0.models.InventoryRequestItem[];
+  interface RatecardForm {
+    readonly direction: io.flow.label.v0.enums.Direction;
+    readonly effective_at: string;
+    readonly origination_zones: io.flow.common.v0.models.Zone[];
+    readonly service: string;
+    readonly number?: string;
+    readonly ratecard_owner?: io.flow.fulfillment.v0.enums.RatecardOwner;
   }
 
-  interface InventoryRequestItem {
-    readonly number: string;
-    readonly quantity: number;
+  interface RatecardLane {
+    readonly id: string;
+    readonly ratecard: io.flow.ratecard.v0.models.RatecardReference;
+    readonly currency: string;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
+    readonly destination: io.flow.common.v0.models.Zone;
+    readonly dim_factor: number;
+    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
+    readonly origin: io.flow.common.v0.models.Zone;
+    readonly service: io.flow.ratecard.v0.models.RatecardServiceSummary;
+    readonly rates: io.flow.ratecard.v0.models.RatecardRate[];
+    readonly rounding: io.flow.common.v0.models.Rounding;
+    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly distance_unit: io.flow.common.v0.enums.UnitOfMeasurement;
   }
 
-  interface InventoryRule {
-    readonly id: string;
-    readonly position: number;
-    readonly query: string;
-    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+  interface RatecardLaneForm {
+    readonly ratecard_id: string;
+    readonly currency: string;
+    readonly destination: io.flow.common.v0.models.Zone;
+    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly dim_factor: number;
+    readonly fees: io.flow.ratecard.v0.unions.RatecardFee[];
+    readonly origin: io.flow.common.v0.models.Zone;
+    readonly rounding: io.flow.common.v0.models.Rounding;
+    readonly rates: io.flow.ratecard.v0.models.RatecardRateForm[];
+    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly distance_unit: io.flow.common.v0.enums.UnitOfMeasurement;
   }
 
-  interface InventoryRuleForm {
-    readonly position: number;
-    readonly query: string;
-    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+  interface RatecardLaneImportForm {
+    readonly ratecard_owner: io.flow.fulfillment.v0.enums.RatecardOwner;
+    readonly service: string;
+    readonly currency: string;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly origin: io.flow.common.v0.models.Zone;
+    readonly destination: io.flow.common.v0.models.Zone;
+    readonly shipment_window: io.flow.ratecard.v0.models.ShipmentWindow;
+    readonly dim_factor: number;
+    readonly weight_unit: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly distance_unit: io.flow.common.v0.enums.UnitOfMeasurement;
+    readonly rates: io.flow.ratecard.v0.models.RatecardRateForm[];
   }
 
-  interface InventoryRuleVersion {
+  interface RatecardLaneVersion {
     readonly id: string;
     readonly timestamp: string;
     readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly inventory_rule: io.flow.inventory.v0.models.InventoryRule;
+    readonly ratecard_lane: io.flow.ratecard.v0.models.RatecardLane;
   }
 
-  interface InventorySnapshot {
+  interface RatecardLanesImportRequestData {
     readonly id: string;
-    readonly available: number;
-    readonly center: io.flow.inventory.v0.models.InventoryCenterReference;
-    readonly item: io.flow.inventory.v0.models.InventoryItemReference;
-    readonly quantity: number;
+    readonly source_url: string;
+    readonly filename?: string;
   }
 
-  interface InventorySnapshotVersion {
+  interface RatecardRate {
     readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly inventory_snapshot: io.flow.inventory.v0.models.InventorySnapshot;
+    readonly amount: number;
+    readonly weight: number;
   }
 
-  interface InventoryStock {
-    readonly discriminator: 'inventory_stock';
-    readonly quantity: number;
+  interface RatecardRateForm {
+    readonly amount: number;
+    readonly weight: number;
   }
 
-  interface InventoryUnlimited {
-    readonly discriminator: 'inventory_unlimited';
-    readonly quantity: string;
+  interface RatecardRateVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly ratecard_rate: io.flow.ratecard.v0.models.RatecardRate;
   }
 
-  interface InventoryUpdate {
+  interface RatecardReference {
     readonly id: string;
-    readonly idempotency_key: string;
-    readonly center: io.flow.inventory.v0.models.InventoryCenterReference;
-    readonly item: io.flow.inventory.v0.models.InventoryItemReference;
-    readonly notes: any /*object*/;
-    readonly quantity: number;
-    readonly type: io.flow.inventory.v0.enums.UpdateType;
   }
 
-  interface InventoryUpdateForm {
-    readonly center: string;
-    readonly idempotency_key: string;
-    readonly item_number: string;
-    readonly quantity: number;
-    readonly type: io.flow.inventory.v0.enums.UpdateType;
-    readonly notes?: any /*object*/;
+  interface RatecardServiceSummary {
+    readonly id: string;
+    readonly name: string;
+    readonly carrier: io.flow.ratecard.v0.models.RatecardCarrierSummary;
   }
 
-  interface InventoryUpdateVersion {
+  interface RatecardVersion {
     readonly id: string;
     readonly timestamp: string;
     readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly inventory_update: io.flow.inventory.v0.models.InventoryUpdate;
+    readonly ratecard: io.flow.ratecard.v0.models.Ratecard;
   }
 
-  interface NoInventoryReservationError {
-    readonly code: 'no_inventory';
-    readonly messages: string[];
-    readonly items: io.flow.inventory.v0.models.NoInventoryReservationErrorItem[];
+  interface RemoteAreaRatecardFee {
+    readonly discriminator: 'remote_area_ratecard_fee';
+    readonly amount: io.flow.common.v0.models.Money;
   }
 
-  interface NoInventoryReservationErrorItem {
-    readonly number: string;
-    readonly requested_quantity: number;
-    readonly available_quantity: number;
+  interface RemoteAreaServiceFee {
+    readonly discriminator: 'remote_area_service_fee';
+    readonly amount: io.flow.common.v0.models.Money;
   }
 
-  interface PfsInventoryCheckResponse {
-    readonly items: Record<
-      string,
-      io.flow.inventory.v0.models.PfsInventoryCheckResponseItem
-    >;
+  interface ReturnPackageRatecardFee {
+    readonly discriminator: 'return_package_ratecard_fee';
+    readonly amount: number;
   }
 
-  interface PfsInventoryCheckResponseItem {
-    readonly number: string;
-    readonly ats: number;
-    readonly in_stock: boolean;
+  interface ShipmentWindow {
+    readonly from: number;
+    readonly to: number;
   }
+}
 
-  interface PfsInventoryStatus {
-    readonly status: string;
-  }
+declare namespace io.flow.ratecard.v0.unions {
+  type RatecardEstimate =
+    | io.flow.ratecard.v0.models.RatecardEstimateV1
+    | io.flow.ratecard.v0.models.RatecardEstimateV2;
+  type RatecardEstimateForm =
+    | io.flow.ratecard.v0.models.RatecardEstimateFormV1
+    | io.flow.ratecard.v0.models.RatecardEstimateFormV2;
+  type RatecardFee =
+    | io.flow.ratecard.v0.models.DdpRatecardFee
+    | io.flow.ratecard.v0.models.FuelSurchargeRatecardFee
+    | io.flow.ratecard.v0.models.OversizedShipmentRatecardFee
+    | io.flow.ratecard.v0.models.ReturnPackageRatecardFee
+    | io.flow.ratecard.v0.models.CrossdockRatecardFee
+    | io.flow.ratecard.v0.models.RemoteAreaRatecardFee;
+  type ServiceFee =
+    | io.flow.ratecard.v0.models.FuelSurchargeServiceFee
+    | io.flow.ratecard.v0.models.RemoteAreaServiceFee;
+}
 
-  interface Reservation {
+declare namespace io.flow.session.context.v0.models {
+  interface Context {
     readonly id: string;
-    readonly key: string;
-    readonly order?: io.flow.inventory.v0.models.ReservationOrderReference;
-    readonly items: io.flow.inventory.v0.models.ReservationItem[];
-    readonly reserved_until?: string;
-  }
-
-  interface ReservationForm {
-    readonly order_number?: string;
-    readonly items: io.flow.inventory.v0.models.ReservationItemForm[];
-  }
-
-  interface ReservationItem {
-    readonly item: io.flow.inventory.v0.models.ReservationItemReference;
-    readonly quantity: number;
-  }
-
-  interface ReservationItemForm {
-    readonly item_number: string;
-    readonly quantity: number;
-  }
-
-  interface ReservationItemReference {
-    readonly number: string;
+    readonly experiments: io.flow.session.context.v0.models.Experiment[];
   }
 
-  interface ReservationOrderReference {
-    readonly number: string;
+  interface ContextForm {
+    readonly experiments: io.flow.session.context.v0.models.Experiment[];
   }
 
-  interface Serial {
+  interface ContextReference {
     readonly id: string;
-    readonly number: string;
-    readonly item_number: string;
-    readonly item_price: io.flow.common.v0.models.Price;
-    readonly status: io.flow.inventory.v0.enums.SerialStatus;
-    readonly center: io.flow.fulfillment.v0.models.CenterReference;
-    readonly attributes: Record<string, string>;
   }
 
-  interface SerialForm {
-    readonly number: string;
-    readonly item_number: string;
-    readonly item_price: number;
-    readonly item_currency: string;
-    readonly status: io.flow.inventory.v0.enums.SerialStatus;
-    readonly center_key?: string;
-    readonly attributes?: Record<string, string>;
+  interface Experiment {
+    readonly key: string;
+    readonly variant?: io.flow.session.context.v0.models.ExperimentVariant;
   }
 
-  interface SerialVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly serial: io.flow.inventory.v0.models.Serial;
+  interface ExperimentVariant {
+    readonly key: string;
   }
 }
 
-declare namespace io.flow.inventory.v0.unions {
-  type InventoryStrategy =
-    | io.flow.inventory.v0.models.InventoryBackorder
-    | io.flow.inventory.v0.models.InventoryStock
-    | io.flow.inventory.v0.models.InventoryUnlimited;
-  type ReservationError =
-    | io.flow.inventory.v0.models.NoInventoryReservationError
-    | io.flow.inventory.v0.models.ExternalApiTimeoutReservationError
-    | io.flow.inventory.v0.models.GenericReservationError;
-}
-
 declare namespace io.flow.optin.internal.v0.enums {
   type PromptAction = 'prompt_displayed' | 'consent_granted' | 'consent_denied';
   type PromptCheckoutDisplayPosition = 'email' | 'submission';
@@ -12671,6 +12695,7 @@ declare namespace io.flow.internal.v0.enums {
   type DutyCompoundExpressionType = 'sum' | 'max' | 'min';
   type DutyRateUnitOfMeasure = 'kg' | 'sq m' | 'item' | 'pair';
   type DutySimpleExpressionType = 'free' | 'percent' | 'per_uom' | 'flat';
+  type EmptyAttribute = 'irrelevant';
   type EventType =
     | 'adyen_authorization_deleted'
     | 'adyen_authorization_upserted'
@@ -12838,7 +12863,7 @@ declare namespace io.flow.internal.v0.enums {
   type ExperienceImportType = 'experience_with_settings';
   type ExperienceOrderAction = 'submit' | 'refund_gift_cards';
   type ExperienceOrderActionTrigger = 'zero_balance' | 'unsubmitted_order';
-  type ExperimentDiscriminatorValue = 'experience' | 'feature';
+  type ExperimentDiscriminatorKey = 'experience' | 'feature';
   type FeatureScope = 'global' | 'organization';
   type FeatureStatus = 'draft' | 'active' | 'archived';
   type FeatureType = 'boolean' | 'decimal' | 'string';
@@ -12954,6 +12979,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'flow_sandbox'
     | 'fiserv'
     | 'crypto';
+  type ProductClassificationAction = 'ACCEPT' | 'MANUAL';
   type PromptAction = 'prompt_displayed' | 'consent_granted' | 'consent_denied';
   type PromptCheckoutDisplayPosition = 'email' | 'submission';
   type PromptOptions = 'notice_only' | 'require_consent' | 'consent_by_default';
@@ -12991,6 +13017,7 @@ declare namespace io.flow.internal.v0.enums {
   type TimeseriesType = 'daily' | 'weekly' | 'monthly' | 'yearly';
   type TrackingIntegrationType = 'api' | 'bulk' | 'aftership';
   type TransferMethod = 'ach';
+  type UnclassifiedProductStatus = 'ignored' | 'escalated';
 }
 
 declare namespace io.flow.internal.v0.models {
@@ -13398,6 +13425,11 @@ declare namespace io.flow.internal.v0.models {
     readonly transactionId: string;
   }
 
+  interface AttributeLabel {
+    readonly value: string;
+    readonly estimated: boolean;
+  }
+
   interface AuthenticationForm {
     readonly password: string;
   }
@@ -14660,9 +14692,24 @@ declare namespace io.flow.internal.v0.models {
   }
 
   interface ExperimentFormDefault {
-    readonly discriminator: io.flow.internal.v0.enums.ExperimentDiscriminatorValue;
-    readonly values: io.flow.internal.v0.models.ExperimentVariantSummary[];
-    readonly variants?: io.flow.internal.v0.models.ExperimentVariantFormDefault[];
+    readonly discriminator: io.flow.internal.v0.models.ExperimentFormDefaultDiscriminator;
+    readonly variants?: io.flow.internal.v0.models.ExperimentFormDefaultVariant[];
+  }
+
+  interface ExperimentFormDefaultDiscriminator {
+    readonly key: io.flow.internal.v0.enums.ExperimentDiscriminatorKey;
+    readonly values: io.flow.internal.v0.models.ExperimentFormDefaultDiscriminatorValue[];
+  }
+
+  interface ExperimentFormDefaultDiscriminatorValue {
+    readonly key: string;
+    readonly name: string;
+  }
+
+  interface ExperimentFormDefaultVariant {
+    readonly key: string;
+    readonly name: string;
+    readonly traffic_percentage?: number;
   }
 
   interface ExperimentResults {
@@ -14706,12 +14753,6 @@ declare namespace io.flow.internal.v0.models {
     readonly experiment: io.flow.experiment.internal.v0.models.Experiment;
   }
 
-  interface ExperimentVariantFormDefault {
-    readonly key: string;
-    readonly name: string;
-    readonly traffic_percentage: number;
-  }
-
   interface ExperimentVariantSummary {
     readonly key: string;
     readonly name?: string;
@@ -15679,6 +15720,14 @@ declare namespace io.flow.internal.v0.models {
     readonly invoice?: io.flow.label.v0.models.ShippingLabelDocument;
   }
 
+  interface LabelTaxonomy {
+    readonly item_type: string;
+    readonly aliases: string[];
+    readonly construction: io.flow.internal.v0.unions.ClassificationLabelAttribute;
+    readonly gender: io.flow.internal.v0.unions.ClassificationLabelAttribute;
+    readonly material: io.flow.internal.v0.unions.ClassificationLabelAttribute;
+  }
+
   interface LabeledContent {
     readonly label: io.flow.internal.v0.models.Label;
     readonly contents: io.flow.internal.v0.unions.ContentItem[];
@@ -17038,6 +17087,27 @@ declare namespace io.flow.internal.v0.models {
     readonly processing_transaction: io.flow.billing.internal.v0.models.ProcessingTransaction;
   }
 
+  interface ProductClassification {
+    readonly organization_id: string;
+    readonly product_id: string;
+    readonly description: string;
+    readonly items: io.flow.internal.v0.models.ClassificationItem[];
+    readonly images: string[];
+    readonly categories: string[];
+    readonly attributes: Record<string, string>;
+    readonly labels: io.flow.internal.v0.models.ProductLabels;
+    readonly current_customs_description?: string;
+    readonly customs_description?: string;
+    readonly hs6_code?: string;
+    readonly hs6_description?: string;
+    readonly next_id?: io.flow.internal.v0.models.ClassificationProductId;
+  }
+
+  interface ProductClassificationForm {
+    readonly product_harmonization: io.flow.internal.v0.models.ProductHarmonization;
+    readonly action: io.flow.internal.v0.enums.ProductClassificationAction;
+  }
+
   interface ProductClassificationJudgementForm {
     readonly organization_id: string;
     readonly product_id: string;
@@ -17051,6 +17121,24 @@ declare namespace io.flow.internal.v0.models {
     readonly next_product?: io.flow.internal.v0.models.ClassificationProductId;
   }
 
+  interface ProductHarmonization {
+    readonly product_labels: io.flow.internal.v0.models.ProductLabels;
+    readonly customs_description: string;
+    readonly hs6_code: string;
+    readonly model_version: string;
+  }
+
+  interface ProductHarmonizationForm {
+    readonly product_labels: io.flow.internal.v0.models.ProductLabels;
+  }
+
+  interface ProductLabels {
+    readonly item_type: string;
+    readonly gender?: io.flow.internal.v0.models.AttributeLabel;
+    readonly material?: io.flow.internal.v0.models.AttributeLabel;
+    readonly construction?: io.flow.internal.v0.models.AttributeLabel;
+  }
+
   interface QuoteRequest {
     readonly id: string;
     readonly request_type: io.flow.internal.v0.enums.QuoteRequestType;
@@ -17895,6 +17983,11 @@ declare namespace io.flow.internal.v0.models {
     readonly period: io.flow.common.v0.models.DatetimeRange;
   }
 
+  interface SupportedLabels {
+    readonly discriminator: 'supported_labels';
+    readonly values: string[];
+  }
+
   interface SvbVirtualCardClearing {
     readonly id: string;
     readonly virtual_card_id: string;
@@ -18178,7 +18271,7 @@ declare namespace io.flow.internal.v0.models {
   interface UnclassifiedProductsForm {
     readonly organization_id: string;
     readonly product_id: string;
-    readonly ignore?: boolean;
+    readonly status?: io.flow.internal.v0.enums.UnclassifiedProductStatus;
   }
 
   interface UnharmonizedItemsExport {
@@ -18278,6 +18371,14 @@ declare namespace io.flow.internal.v0.unions {
     | io.flow.internal.v0.models.CheckoutOrderNumberForm;
   type CheckoutSubmitOrderBundles = io.flow.internal.v0.models.CheckoutSubmitOrderBundle;
   type CheckoutSubmitOrderForms = io.flow.internal.v0.models.CheckoutSubmitOrderForm;
+
+  type ClassificationLabelAttribute =
+    | {
+        discriminator: 'empty_attribute';
+        value: io.flow.internal.v0.enums.EmptyAttribute;
+      }
+    | io.flow.internal.v0.models.SupportedLabels;
+
   type ContentItem =
     | io.flow.internal.v0.models.Dict
     | io.flow.internal.v0.models.Href
@@ -18627,6 +18728,7 @@ export type AllocationItemReference = io.flow.internal.v0.models.AllocationItemR
 export type ApmContent = io.flow.internal.v0.models.ApmContent;
 export type ApplePaymentToken = io.flow.internal.v0.models.ApplePaymentToken;
 export type ApplePaymentTokenHeader = io.flow.internal.v0.models.ApplePaymentTokenHeader;
+export type AttributeLabel = io.flow.internal.v0.models.AttributeLabel;
 export type AuthenticationForm = io.flow.internal.v0.models.AuthenticationForm;
 export type Authorization = io.flow.internal.v0.models.Authorization;
 export type AuthorizationMetadata = io.flow.internal.v0.models.AuthorizationMetadata;
@@ -18758,6 +18860,7 @@ export type CipherForm = io.flow.internal.v0.models.CipherForm;
 export type CipherReference = io.flow.internal.v0.models.CipherReference;
 export type ClassicPaymentRedirectForm = io.flow.internal.v0.models.ClassicPaymentRedirectForm;
 export type ClassificationItem = io.flow.internal.v0.models.ClassificationItem;
+export type ClassificationLabelAttribute = io.flow.internal.v0.unions.ClassificationLabelAttribute;
 export type ClassificationProduct = io.flow.internal.v0.models.ClassificationProduct;
 export type ClassificationProductId = io.flow.internal.v0.models.ClassificationProductId;
 export type ClassificationProductSummary = io.flow.internal.v0.models.ClassificationProductSummary;
@@ -18826,6 +18929,7 @@ export type DutySimpleExpression = io.flow.internal.v0.models.DutySimpleExpressi
 export type DutySimpleExpressionType = io.flow.internal.v0.enums.DutySimpleExpressionType;
 export type EmailForm = io.flow.internal.v0.models.EmailForm;
 export type EmailModificationForm = io.flow.internal.v0.models.EmailModificationForm;
+export type EmptyAttribute = io.flow.internal.v0.enums.EmptyAttribute;
 export type Encryption = io.flow.internal.v0.models.Encryption;
 export type Event = io.flow.internal.v0.unions.Event;
 export type EventType = io.flow.internal.v0.enums.EventType;
@@ -18843,16 +18947,18 @@ export type ExperienceVariant = io.flow.internal.v0.models.ExperienceVariant;
 export type ExperienceVariantForm = io.flow.internal.v0.models.ExperienceVariantForm;
 export type Experiment = io.flow.internal.v0.unions.Experiment;
 export type ExperimentDeleted = io.flow.internal.v0.models.ExperimentDeleted;
-export type ExperimentDiscriminatorValue = io.flow.internal.v0.enums.ExperimentDiscriminatorValue;
+export type ExperimentDiscriminatorKey = io.flow.internal.v0.enums.ExperimentDiscriminatorKey;
 export type ExperimentEngineResults = io.flow.internal.v0.models.ExperimentEngineResults;
 export type ExperimentForm = io.flow.internal.v0.models.ExperimentForm;
 export type ExperimentFormDefault = io.flow.internal.v0.models.ExperimentFormDefault;
+export type ExperimentFormDefaultDiscriminator = io.flow.internal.v0.models.ExperimentFormDefaultDiscriminator;
+export type ExperimentFormDefaultDiscriminatorValue = io.flow.internal.v0.models.ExperimentFormDefaultDiscriminatorValue;
+export type ExperimentFormDefaultVariant = io.flow.internal.v0.models.ExperimentFormDefaultVariant;
 export type ExperimentResults = io.flow.internal.v0.models.ExperimentResults;
 export type ExperimentResultsDeleted = io.flow.internal.v0.models.ExperimentResultsDeleted;
 export type ExperimentResultsUpserted = io.flow.internal.v0.models.ExperimentResultsUpserted;
 export type ExperimentResultsWithTimestamp = io.flow.internal.v0.models.ExperimentResultsWithTimestamp;
 export type ExperimentUpserted = io.flow.internal.v0.models.ExperimentUpserted;
-export type ExperimentVariantFormDefault = io.flow.internal.v0.models.ExperimentVariantFormDefault;
 export type ExperimentVariantSummary = io.flow.internal.v0.models.ExperimentVariantSummary;
 export type ExperimentVersion = io.flow.internal.v0.models.ExperimentVersion;
 export type ExplicitStatementDate = io.flow.internal.v0.models.ExplicitStatementDate;
@@ -19017,6 +19123,7 @@ export type KeyReference = io.flow.internal.v0.models.KeyReference;
 export type Label = io.flow.internal.v0.models.Label;
 export type LabelBillingStrategy = io.flow.internal.v0.enums.LabelBillingStrategy;
 export type LabelSummary = io.flow.internal.v0.models.LabelSummary;
+export type LabelTaxonomy = io.flow.internal.v0.models.LabelTaxonomy;
 export type LabeledContent = io.flow.internal.v0.models.LabeledContent;
 export type LabelsPrediction = io.flow.internal.v0.models.LabelsPrediction;
 export type LandedCostExport = io.flow.internal.v0.models.LandedCostExport;
@@ -19238,8 +19345,14 @@ export type ProcessingTransactionDeleted = io.flow.internal.v0.models.Processing
 export type ProcessingTransactionType = io.flow.internal.v0.enums.ProcessingTransactionType;
 export type ProcessingTransactionUpserted = io.flow.internal.v0.models.ProcessingTransactionUpserted;
 export type Processor = io.flow.internal.v0.enums.Processor;
+export type ProductClassification = io.flow.internal.v0.models.ProductClassification;
+export type ProductClassificationAction = io.flow.internal.v0.enums.ProductClassificationAction;
+export type ProductClassificationForm = io.flow.internal.v0.models.ProductClassificationForm;
 export type ProductClassificationJudgementForm = io.flow.internal.v0.models.ProductClassificationJudgementForm;
 export type ProductClassificationResult = io.flow.internal.v0.models.ProductClassificationResult;
+export type ProductHarmonization = io.flow.internal.v0.models.ProductHarmonization;
+export type ProductHarmonizationForm = io.flow.internal.v0.models.ProductHarmonizationForm;
+export type ProductLabels = io.flow.internal.v0.models.ProductLabels;
 export type PromptAction = io.flow.internal.v0.enums.PromptAction;
 export type PromptCheckoutDisplayPosition = io.flow.internal.v0.enums.PromptCheckoutDisplayPosition;
 export type PromptOptions = io.flow.internal.v0.enums.PromptOptions;
@@ -19387,6 +19500,7 @@ export type Subscription = io.flow.internal.v0.models.Subscription;
 export type SubscriptionFrequency = io.flow.internal.v0.enums.SubscriptionFrequency;
 export type SubscriptionTransaction = io.flow.internal.v0.models.SubscriptionTransaction;
 export type SuggestionAction = io.flow.internal.v0.enums.SuggestionAction;
+export type SupportedLabels = io.flow.internal.v0.models.SupportedLabels;
 export type SvbVirtualCardClearing = io.flow.internal.v0.models.SvbVirtualCardClearing;
 export type SvbVirtualCardClearingDeleted = io.flow.internal.v0.models.SvbVirtualCardClearingDeleted;
 export type SvbVirtualCardClearingUpserted = io.flow.internal.v0.models.SvbVirtualCardClearingUpserted;
@@ -19431,6 +19545,7 @@ export type TransferTransaction = io.flow.internal.v0.models.TransferTransaction
 export type TransferTransactionDeleted = io.flow.internal.v0.models.TransferTransactionDeleted;
 export type TransferTransactionUpserted = io.flow.internal.v0.models.TransferTransactionUpserted;
 export type Tribe = io.flow.internal.v0.models.Tribe;
+export type UnclassifiedProductStatus = io.flow.internal.v0.enums.UnclassifiedProductStatus;
 export type UnclassifiedProductsForm = io.flow.internal.v0.models.UnclassifiedProductsForm;
 export type UnharmonizedItemsExport = io.flow.internal.v0.models.UnharmonizedItemsExport;
 export type UnphrasedProductsExport = io.flow.internal.v0.models.UnphrasedProductsExport;