@flowio/types 8.0.6 → 9.0.0

package/src/api-internal.ts

@@ -1,944 +1,651 @@
-declare namespace io.flow.ratecard.v0.models {
-  interface CrossdockRatecardFee {
-    readonly discriminator: 'crossdock_ratecard_fee';
-    readonly amount: io.flow.common.v0.models.Money;
+declare namespace io.flow.bundle.checkout.v0.enums {
+  type CheckoutErrorCode =
+    | 'generic_error'
+    | 'order_identifier_invalid'
+    | 'url_invalid'
+    | 'organization_invalid'
+    | 'session_invalid'
+    | 'session_missing'
+    | 'session_organization_invalid'
+    | 'country_invalid'
+    | 'currency_invalid'
+    | 'language_invalid'
+    | 'checkout_invalid';
+  type CheckoutRedirectMethod = 'get' | 'post';
+}
+
+declare namespace io.flow.bundle.checkout.v0.models {
+  interface Checkout {
+    readonly id: string;
+    readonly organization: io.flow.common.v0.models.OrganizationSummary;
+    readonly builder: io.flow.experience.v0.models.OrderBuilder;
+    readonly platform: io.flow.bundle.checkout.v0.models.CheckoutPlatformData;
+    readonly content: io.flow.bundle.checkout.v0.models.CheckoutContent;
+    readonly destinations: io.flow.reference.v0.models.Country[];
+    readonly optins: io.flow.optin.internal.v0.models.OptinPrompt[];
+    readonly addresses: io.flow.experience.v0.models.AddressConfiguration[];
+    readonly features: io.flow.feature.v0.models.FeatureValueResult;
+    readonly configuration: io.flow.checkout.configuration.v0.models.CheckoutConfiguration;
+    readonly cart?: io.flow.shopify.v0.models.ShopifyCart;
+    readonly customer?: io.flow.customer.v0.models.Customer;
+    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBook;
+    readonly gift_card_program?: io.flow.experience.internal.v0.models.GiftCardProgram;
+    readonly loyalty_program?: io.flow.experience.internal.v0.models.LoyaltyProgram;
+    readonly payment: io.flow.bundle.checkout.v0.models.CheckoutPayment;
+    readonly customer_bundle?: io.flow.customer.v0.models.CustomerBundle;
   }
 
-  interface DdpRatecardFee {
-    readonly discriminator: 'ddp_ratecard_fee';
-    readonly amount: number;
+  interface CheckoutBundle {
+    readonly cart?: io.flow.shopify.v0.models.ShopifyCart;
+    readonly order: io.flow.experience.v0.models.Order;
+    readonly order_errors?: io.flow.experience.v0.models.OrderError[];
+    readonly checkout?: io.flow.content.internal.v0.models.CheckoutContentSummary;
+    readonly optins: io.flow.optin.internal.v0.models.OptinPrompt[];
+    readonly destinations: io.flow.reference.v0.models.Country[];
+    readonly features: io.flow.feature.v0.models.FeatureValueResult;
+    readonly provinces: io.flow.reference.v0.models.Province[];
+    readonly checkout_items: io.flow.experience.v0.models.CheckoutItemContent[];
+    readonly metadata?: io.flow.bundle.checkout.v0.models.CheckoutBundleMetadata;
+    readonly configuration?: io.flow.checkout.configuration.v0.models.CheckoutConfiguration;
+    readonly address_configurations?: io.flow.experience.v0.models.AddressConfiguration[];
+    readonly customer?: io.flow.customer.v0.models.Customer;
+    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBook;
+    readonly payment_sources?: io.flow.payment.v0.unions.PaymentSource[];
+    readonly customer_bundle?: io.flow.customer.v0.models.CustomerBundle;
   }
 
-  interface DimensionEstimate {
-    readonly id: string;
-    readonly q: string;
-    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
-    readonly position: number;
+  interface CheckoutBundleMetadata {
+    readonly organization: io.flow.common.v0.models.OrganizationSummary;
   }
 
-  interface DimensionEstimateForm {
-    readonly q: string;
-    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
-    readonly position?: number;
+  interface CheckoutContent {
+    readonly global?: io.flow.content.internal.v0.models.CheckoutContentSummary;
+    readonly items: io.flow.experience.v0.models.CheckoutItemContent[];
   }
 
-  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 CheckoutError {
+    readonly code: io.flow.bundle.checkout.v0.enums.CheckoutErrorCode;
+    readonly messages: string[];
+    readonly organization?: io.flow.common.v0.models.OrganizationReference;
+    readonly redirect?: io.flow.bundle.checkout.v0.models.CheckoutRedirect;
   }
 
-  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 CheckoutFinalizeOrderForm {
+    readonly expected_order_summary: io.flow.bundle.checkout.v0.models.ExpectedOrderSummary;
+    readonly order_put_form: io.flow.experience.v0.models.OrderPutForm;
   }
 
-  interface FuelSurchargeRatecardFee {
-    readonly discriminator: 'fuel_surcharge_ratecard_fee';
-    readonly amount: io.flow.common.v0.models.Money;
+  interface CheckoutOrderForm {
+    readonly discriminator: 'order';
+    readonly organization: string;
+    readonly order: io.flow.experience.v0.models.OrderForm;
+    readonly customer?: io.flow.customer.v0.models.CustomerForm;
+    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBookForm;
+    readonly payment_sources?: io.flow.payment.v0.unions.PaymentSourceForm[];
+    readonly urls?: io.flow.checkout.v0.models.CheckoutUrlsForm;
+    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
+    readonly feature_keys?: string[];
+    readonly order_parameters?: io.flow.bundle.checkout.v0.models.OrderParameters;
   }
 
-  interface FuelSurchargeServiceFee {
-    readonly discriminator: 'fuel_surcharge_service_fee';
-    readonly percent: number;
+  interface CheckoutOrderNumberForm {
+    readonly discriminator: 'order_number';
+    readonly organization: string;
+    readonly order_number: string;
+    readonly customer?: io.flow.customer.v0.models.CustomerForm;
+    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBookForm;
+    readonly payment_sources?: io.flow.payment.v0.unions.PaymentSourceForm[];
+    readonly urls?: io.flow.checkout.v0.models.CheckoutUrlsForm;
+    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
+    readonly feature_keys?: string[];
+    readonly order_parameters?: io.flow.bundle.checkout.v0.models.OrderParameters;
   }
 
-  interface Hop {
-    readonly hop_number: number;
-    readonly hop_estimate: io.flow.ratecard.v0.models.HopEstimate;
+  interface CheckoutOrderSummary {
+    readonly lines: io.flow.bundle.checkout.v0.models.CheckoutOrderSummaryLine[];
   }
 
-  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 CheckoutOrderSummaryLine {
+    readonly item: io.flow.common.v0.models.ItemReference;
+    readonly quantity: 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 CheckoutPayment {
+    readonly authorizations: io.flow.payment.v0.unions.Authorization[];
+    readonly sources: io.flow.payment.v0.unions.PaymentSource[];
+    readonly public_key: io.flow.payment.v0.models.PublicKey;
+    readonly method_types: io.flow.reference.v0.enums.PaymentMethodType[];
+    readonly method_rules: io.flow.experience.v0.models.PaymentMethodRule[];
+    readonly authorization_parameters: io.flow.payment.internal.v0.models.AuthorizationParameters[];
   }
 
-  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 CheckoutPlatformData {
+    readonly order_number?: string;
   }
 
-  interface RatecardCarrierSummary {
-    readonly id: string;
-    readonly name: string;
+  interface CheckoutRedirect {
+    readonly method: io.flow.bundle.checkout.v0.enums.CheckoutRedirectMethod;
+    readonly url: string;
+    readonly body?: 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 CheckoutReferenceForm {
+    readonly order_number: string;
+    readonly order_form: io.flow.experience.v0.models.OrderPutForm;
+    readonly order_geo: io.flow.experience.v0.models.OrderGeo;
+    readonly session_id: string;
+    readonly urls?: io.flow.checkout.v0.models.CheckoutUrlsForm;
+    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
   }
 
-  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 CheckoutSourceOrderForm {
+    readonly source_order_number: string;
+    readonly feature_q?: string;
   }
 
-  interface RatecardEstimateSummaryForm {
-    readonly origin?: string;
-    readonly destination?: string;
-    readonly service?: string;
-    readonly center_key?: string;
+  interface CheckoutSubmission {
+    readonly builder: io.flow.experience.v0.models.OrderBuilder;
+    readonly action?: io.flow.payment.v0.unions.AuthorizationResultAction;
   }
 
-  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 CheckoutSubmissionForm {
+    readonly authorization_form?: io.flow.payment.v0.unions.AuthorizationForm;
+    readonly expected_order_summary?: io.flow.bundle.checkout.v0.models.ExpectedOrderSummary;
+    readonly feature_keys?: 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 CheckoutSubmitOrderBundle {
+    readonly discriminator: 'checkout_submit_order_bundle';
+    readonly order?: io.flow.experience.v0.models.Order;
+    readonly redirect?: io.flow.payment.v0.unions.AuthorizationResultAction;
+    readonly errors?: io.flow.experience.v0.models.OrderError[];
   }
 
-  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 CheckoutSubmitOrderForm {
+    readonly discriminator: 'checkout_submit_order_form';
+    readonly authorization_form?: io.flow.payment.v0.unions.AuthorizationForm;
+    readonly expected_order_summary?: io.flow.bundle.checkout.v0.models.ExpectedOrderSummary;
   }
 
-  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 ExpectedOrderSummary {
+    readonly total?: io.flow.common.v0.models.Money;
   }
 
-  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 InvalidCheckoutData {
+    readonly order: io.flow.experience.v0.models.OrderPutForm;
   }
 
-  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 OrderParameters {
+    readonly experience?: string;
+    readonly country?: string;
+    readonly ip?: string;
+    readonly currency?: string;
+    readonly language?: string;
   }
+}
 
-  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;
-  }
+declare namespace io.flow.bundle.checkout.v0.unions {
+  type CheckoutForm =
+    | io.flow.bundle.checkout.v0.models.CheckoutOrderForm
+    | io.flow.bundle.checkout.v0.models.CheckoutOrderNumberForm;
+  type CheckoutSubmitOrderBundles = io.flow.bundle.checkout.v0.models.CheckoutSubmitOrderBundle;
+  type CheckoutSubmitOrderForms = io.flow.bundle.checkout.v0.models.CheckoutSubmitOrderForm;
+}
 
-  interface RatecardLanesImportRequestData {
+declare namespace io.flow.tracking.v0.enums {
+  type TrackingStatus =
+    | 'label_created'
+    | 'pending'
+    | 'info_received'
+    | 'picked_up'
+    | 'in_transit'
+    | 'out_for_delivery'
+    | 'attempt_fail'
+    | 'delivered'
+    | 'exception'
+    | 'returned'
+    | 'expired';
+}
+
+declare namespace io.flow.tracking.v0.models {
+  interface Tracking {
     readonly id: string;
-    readonly source_url: string;
-    readonly filename?: string;
+    readonly labels: io.flow.tracking.v0.models.TrackingLabel[];
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
+    readonly attributes: Record<string, string>;
+    readonly url: string;
+    readonly window?: io.flow.common.v0.models.DatetimeRange;
+    readonly order_number?: string;
   }
 
-  interface RatecardRate {
+  interface TrackingEvent {
     readonly id: string;
-    readonly amount: number;
-    readonly weight: number;
+    readonly address: io.flow.common.v0.models.Address;
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
+    readonly timestamp: string;
+    readonly description?: string;
   }
 
-  interface RatecardRateForm {
-    readonly amount: number;
-    readonly weight: number;
+  interface TrackingEventForm {
+    readonly tracking_label_id: string;
+    readonly timestamp: string;
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
+    readonly description?: string;
+    readonly address?: string;
   }
 
-  interface RatecardRateVersion {
+  interface TrackingEventSummary {
     readonly id: string;
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
     readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly ratecard_rate: io.flow.ratecard.v0.models.RatecardRate;
   }
 
-  interface RatecardReference {
+  interface TrackingEventVersion {
     readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly tracking_event: io.flow.tracking.v0.models.TrackingEventSummary;
   }
 
-  interface RatecardServiceSummary {
-    readonly id: string;
-    readonly name: string;
-    readonly carrier: io.flow.ratecard.v0.models.RatecardCarrierSummary;
+  interface TrackingForm {
+    readonly status?: io.flow.tracking.v0.enums.TrackingStatus;
+    readonly order_number?: string;
+    readonly attributes?: Record<string, string>;
+    readonly window?: io.flow.common.v0.models.DatetimeRange;
   }
 
-  interface RatecardVersion {
+  interface TrackingLabel {
     readonly id: string;
+    readonly carrier: string;
+    readonly carrier_tracking_number: string;
+    readonly events: io.flow.tracking.v0.models.TrackingEvent[];
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
     readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly ratecard: io.flow.ratecard.v0.models.Ratecard;
+    readonly delivery_estimate?: string;
+    readonly description?: string;
   }
 
-  interface RemoteAreaRatecardFee {
-    readonly discriminator: 'remote_area_ratecard_fee';
-    readonly amount: io.flow.common.v0.models.Money;
+  interface TrackingLabelForm {
+    readonly tracking_id: string;
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
+    readonly carrier: string;
+    readonly carrier_tracking_number: string;
+    readonly delivery_estimate?: string;
+    readonly description?: string;
+    readonly timestamp?: string;
+    readonly parent_id?: string;
   }
 
-  interface RemoteAreaServiceFee {
-    readonly discriminator: 'remote_area_service_fee';
-    readonly amount: io.flow.common.v0.models.Money;
+  interface TrackingLabelSummary {
+    readonly id: string;
+    readonly tracking: io.flow.tracking.v0.models.TrackingSummary;
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
+    readonly carrier: string;
+    readonly tracking_number: string;
   }
 
-  interface ReturnPackageRatecardFee {
-    readonly discriminator: 'return_package_ratecard_fee';
-    readonly amount: number;
+  interface TrackingLabelVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly tracking_label: io.flow.tracking.v0.models.TrackingLabelSummary;
   }
 
-  interface ShipmentWindow {
-    readonly from: number;
-    readonly to: number;
+  interface TrackingSummary {
+    readonly id: string;
+    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
+    readonly order_number?: 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 TrackingVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly tracking: io.flow.tracking.v0.models.TrackingSummary;
+  }
 }
 
-declare namespace io.flow.bundle.checkout.v0.enums {
-  type CheckoutErrorCode =
+declare namespace io.flow.experience.v0.enums {
+  type CreditPaymentErrorCode =
     | 'generic_error'
-    | 'order_identifier_invalid'
-    | 'url_invalid'
-    | 'organization_invalid'
-    | 'session_invalid'
-    | 'session_missing'
-    | 'session_organization_invalid'
-    | 'country_invalid'
-    | 'currency_invalid'
-    | 'language_invalid'
-    | 'checkout_invalid';
-  type CheckoutRedirectMethod = 'get' | 'post';
+    | 'invalid_order_number'
+    | 'invalid_currency'
+    | 'invalid_description'
+    | 'duplicate'
+    | 'amount_must_be_positive'
+    | 'amount_exceeds_balance'
+    | 'insufficient_amount';
+  type DeliveredDutyDisplayType = 'all' | 'single';
+  type ExperienceCloneStatus = 'pending' | 'updating' | 'completed' | 'failed';
+  type ExperiencePaymentMethodTag = 'display';
+  type ExperienceStatus = 'draft' | 'active' | 'archiving' | 'archived';
+  type OrderErrorCode =
+    | 'generic_error'
+    | 'order_item_not_available'
+    | 'order_identifier_error'
+    | 'authorization_invalid'
+    | 'domestic_shipping_unavailable'
+    | 'shipping_unavailable'
+    | 'value_threshold_exceeded'
+    | 'invalid_currency'
+    | 'invalid_country'
+    | 'invalid_region'
+    | 'invalid_language'
+    | 'item_out_of_stock'
+    | 'gift_card_not_accepted'
+    | 'total_changed';
+  type OrderPaymentType =
+    | 'card'
+    | 'online'
+    | 'credit'
+    | 'installment_plan'
+    | 'cash_on_delivery';
+  type OrderStatus = 'open' | 'submitted';
+  type OrderStorage = 'do_not_persist' | 'persist';
+  type OrganizationPaymentMethodTag = 'deny';
+  type PaymentMethodRuleContentKey = 'description';
+  type PriceFacetBoundary = 'min' | 'max';
+  type PromotionTriggerType = 'automatic' | 'order_subtotal';
 }
 
-declare namespace io.flow.bundle.checkout.v0.models {
-  interface Checkout {
-    readonly id: string;
-    readonly organization: io.flow.common.v0.models.OrganizationSummary;
-    readonly builder: io.flow.experience.v0.models.OrderBuilder;
-    readonly platform: io.flow.bundle.checkout.v0.models.CheckoutPlatformData;
-    readonly content: io.flow.bundle.checkout.v0.models.CheckoutContent;
-    readonly destinations: io.flow.reference.v0.models.Country[];
-    readonly optins: io.flow.optin.internal.v0.models.OptinPrompt[];
-    readonly addresses: io.flow.experience.v0.models.AddressConfiguration[];
-    readonly features: io.flow.feature.v0.models.FeatureValueResult;
-    readonly configuration: unknown /*io.flow.checkout.configuration.v0.models.checkout_configuration*/;
-    readonly cart?: io.flow.shopify.v0.models.ShopifyCart;
-    readonly customer?: io.flow.customer.v0.models.Customer;
-    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBook;
-    readonly gift_card_program?: io.flow.experience.internal.v0.models.GiftCardProgram;
-    readonly loyalty_program?: io.flow.experience.internal.v0.models.LoyaltyProgram;
-    readonly payment: io.flow.bundle.checkout.v0.models.CheckoutPayment;
-    readonly customer_bundle?: io.flow.customer.v0.models.CustomerBundle;
+declare namespace io.flow.experience.v0.models {
+  interface AddressConfiguration {
+    readonly country: string;
+    readonly field_validation: io.flow.experience.v0.models.AddressFieldValidation;
+    readonly provinces: io.flow.experience.v0.models.AddressConfigurationProvince[];
   }
 
-  interface CheckoutBundle {
-    readonly cart?: io.flow.shopify.v0.models.ShopifyCart;
-    readonly order: io.flow.experience.v0.models.Order;
-    readonly order_errors?: io.flow.experience.v0.models.OrderError[];
-    readonly checkout?: io.flow.content.internal.v0.models.CheckoutContentSummary;
-    readonly optins: io.flow.optin.internal.v0.models.OptinPrompt[];
-    readonly destinations: io.flow.reference.v0.models.Country[];
-    readonly features: io.flow.feature.v0.models.FeatureValueResult;
-    readonly provinces: io.flow.reference.v0.models.Province[];
-    readonly checkout_items: io.flow.experience.v0.models.CheckoutItemContent[];
-    readonly metadata?: io.flow.bundle.checkout.v0.models.CheckoutBundleMetadata;
-    readonly configuration?: unknown /*io.flow.checkout.configuration.v0.models.checkout_configuration*/;
-    readonly address_configurations?: io.flow.experience.v0.models.AddressConfiguration[];
-    readonly customer?: io.flow.customer.v0.models.Customer;
-    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBook;
-    readonly payment_sources?: io.flow.payment.v0.unions.PaymentSource[];
-    readonly customer_bundle?: io.flow.customer.v0.models.CustomerBundle;
+  interface AddressConfigurationProvince {
+    readonly value: string;
+    readonly name: string;
+    readonly translations?: io.flow.experience.v0.models.AddressConfigurationProvinceTranslation[];
   }
 
-  interface CheckoutBundleMetadata {
-    readonly organization: io.flow.common.v0.models.OrganizationSummary;
+  interface AddressConfigurationProvinceTranslation {
+    readonly locale: io.flow.experience.v0.models.AddressConfigurationProvinceTranslationLocale;
+    readonly name: string;
   }
 
-  interface CheckoutContent {
-    readonly global?: io.flow.content.internal.v0.models.CheckoutContentSummary;
-    readonly items: io.flow.experience.v0.models.CheckoutItemContent[];
+  interface AddressConfigurationProvinceTranslationLocale {
+    readonly id: string;
+    readonly name: string;
+    readonly language: string;
   }
 
-  interface CheckoutError {
-    readonly code: io.flow.bundle.checkout.v0.enums.CheckoutErrorCode;
-    readonly messages: string[];
-    readonly organization?: io.flow.common.v0.models.OrganizationReference;
-    readonly redirect?: io.flow.bundle.checkout.v0.models.CheckoutRedirect;
+  interface AddressFieldValidation {
+    readonly first_name: io.flow.field.validation.v0.unions.FieldValidationRule[];
+    readonly last_name: io.flow.field.validation.v0.unions.FieldValidationRule[];
+    readonly street_1: io.flow.field.validation.v0.unions.FieldValidationRule[];
+    readonly street_2: io.flow.field.validation.v0.unions.FieldValidationRule[];
+    readonly city: io.flow.field.validation.v0.unions.FieldValidationRule[];
+    readonly province: io.flow.field.validation.v0.unions.FieldValidationRule[];
+    readonly postal: io.flow.field.validation.v0.unions.FieldValidationRule[];
+    readonly phone: io.flow.field.validation.v0.unions.FieldValidationRule[];
   }
 
-  interface CheckoutFinalizeOrderForm {
-    readonly expected_order_summary: io.flow.bundle.checkout.v0.models.ExpectedOrderSummary;
-    readonly order_put_form: io.flow.experience.v0.models.OrderPutForm;
+  interface Allocation {
+    readonly order: io.flow.experience.v0.models.AllocationOrderSummary;
+    readonly details: io.flow.experience.v0.unions.AllocationDetail[];
   }
 
-  interface CheckoutOrderForm {
-    readonly discriminator: 'order';
-    readonly organization: string;
-    readonly order: io.flow.experience.v0.models.OrderForm;
-    readonly customer?: io.flow.customer.v0.models.CustomerForm;
-    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBookForm;
-    readonly payment_sources?: io.flow.payment.v0.unions.PaymentSourceForm[];
-    readonly urls?: io.flow.checkout.v0.models.CheckoutUrlsForm;
-    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
-    readonly feature_keys?: string[];
-    readonly order_parameters?: io.flow.bundle.checkout.v0.models.OrderParameters;
+  interface AllocationDetailComponent {
+    readonly discriminator: 'allocation_detail_component';
+    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailComponentKey;
+    readonly total: io.flow.common.v0.models.PriceWithBase;
+    readonly price?: io.flow.common.v0.models.PriceWithBase;
   }
 
-  interface CheckoutOrderNumberForm {
-    readonly discriminator: 'order_number';
-    readonly organization: string;
-    readonly order_number: string;
-    readonly customer?: io.flow.customer.v0.models.CustomerForm;
-    readonly address_book?: io.flow.customer.v0.models.CustomerAddressBookForm;
-    readonly payment_sources?: io.flow.payment.v0.unions.PaymentSourceForm[];
-    readonly urls?: io.flow.checkout.v0.models.CheckoutUrlsForm;
-    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
-    readonly feature_keys?: string[];
-    readonly order_parameters?: io.flow.bundle.checkout.v0.models.OrderParameters;
+  interface AllocationLevyComponent {
+    readonly discriminator: 'allocation_levy_component';
+    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailComponentKey;
+    readonly total: io.flow.common.v0.models.PriceWithBase;
+    readonly rate: number;
+    readonly name: string;
+    readonly price?: io.flow.common.v0.models.PriceWithBase;
+    readonly accuracy?: io.flow.price.v0.enums.PriceAccuracy;
+    readonly basis?: io.flow.common.v0.models.MoneyWithBase;
   }
 
-  interface CheckoutOrderSummary {
-    readonly lines: io.flow.bundle.checkout.v0.models.CheckoutOrderSummaryLine[];
+  interface AllocationLineDetail {
+    readonly discriminator: 'allocation_line_detail';
+    readonly number: string;
+    readonly quantity: number;
+    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailKey;
+    readonly price: io.flow.common.v0.models.PriceWithBase;
+    readonly total: io.flow.common.v0.models.PriceWithBase;
+    readonly included: io.flow.experience.v0.unions.AllocationComponent[];
+    readonly not_included: io.flow.experience.v0.unions.AllocationComponent[];
   }
 
-  interface CheckoutOrderSummaryLine {
-    readonly item: io.flow.common.v0.models.ItemReference;
-    readonly quantity: number;
+  interface AllocationOrderDetail {
+    readonly discriminator: 'allocation_order_detail';
+    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailKey;
+    readonly total: io.flow.common.v0.models.PriceWithBase;
+    readonly included: io.flow.experience.v0.unions.AllocationComponent[];
+    readonly not_included: io.flow.experience.v0.unions.AllocationComponent[];
   }
 
-  interface CheckoutPayment {
-    readonly authorizations: io.flow.payment.v0.unions.Authorization[];
-    readonly sources: io.flow.payment.v0.unions.PaymentSource[];
-    readonly public_key: io.flow.payment.v0.models.PublicKey;
-    readonly method_types: io.flow.reference.v0.enums.PaymentMethodType[];
-    readonly method_rules: io.flow.experience.v0.models.PaymentMethodRule[];
-    readonly authorization_parameters: io.flow.payment.internal.v0.models.AuthorizationParameters[];
+  interface AllocationOrderSummary {
+    readonly id: string;
+    readonly number: string;
+    readonly submitted_at?: string;
   }
 
-  interface CheckoutPlatformData {
-    readonly order_number?: string;
+  interface AllocationV2 {
+    readonly id: string;
+    readonly order: io.flow.experience.v0.models.AllocationOrderSummary;
+    readonly details: io.flow.experience.v0.unions.AllocationDetail[];
+    readonly total: io.flow.catalog.v0.models.LocalizedTotal;
   }
 
-  interface CheckoutRedirect {
-    readonly method: io.flow.bundle.checkout.v0.enums.CheckoutRedirectMethod;
-    readonly url: string;
-    readonly body?: string;
+  interface AvailablePromotion {
+    readonly id: string;
+    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfigurationReference;
+    readonly region: io.flow.experience.v0.models.RegionReference;
+    readonly promotions: io.flow.experience.v0.unions.Promotion[];
   }
 
-  interface CheckoutReferenceForm {
-    readonly order_number: string;
-    readonly order_form: io.flow.experience.v0.models.OrderPutForm;
-    readonly order_geo: io.flow.experience.v0.models.OrderGeo;
-    readonly session_id: string;
-    readonly urls?: io.flow.checkout.v0.models.CheckoutUrlsForm;
-    readonly identifiers?: io.flow.experience.v0.models.OrderSubmissionIdentifierForm[];
+  interface CheckoutAttribute {
+    readonly id: string;
+    readonly experience: io.flow.experience.v0.models.ExperienceReference;
+    readonly key: string;
+    readonly name: string;
+    readonly attribute_keys: string[];
+    readonly position: number;
   }
 
-  interface CheckoutSourceOrderForm {
-    readonly source_order_number: string;
-    readonly feature_q?: string;
+  interface CheckoutAttributeForm {
+    readonly key: string;
+    readonly name?: string;
+    readonly experience_key: string;
+    readonly attribute_keys: string[];
+    readonly position?: number;
   }
 
-  interface CheckoutSubmission {
-    readonly builder: io.flow.experience.v0.models.OrderBuilder;
-    readonly action?: io.flow.payment.v0.unions.AuthorizationResultAction;
+  interface CheckoutItemContent {
+    readonly item: io.flow.catalog.v0.models.Item;
+    readonly name: string;
+    readonly description?: string;
+    readonly attributes: io.flow.experience.v0.models.CheckoutItemContentAttribute[];
+    readonly image?: io.flow.catalog.v0.models.Image;
   }
 
-  interface CheckoutSubmissionForm {
-    readonly authorization_form?: io.flow.payment.v0.unions.AuthorizationForm;
-    readonly expected_order_summary?: io.flow.bundle.checkout.v0.models.ExpectedOrderSummary;
-    readonly feature_keys?: string[];
+  interface CheckoutItemContentAttribute {
+    readonly key: string;
+    readonly name: string;
+    readonly value: string;
   }
 
-  interface CheckoutSubmitOrderBundle {
-    readonly discriminator: 'checkout_submit_order_bundle';
-    readonly order?: io.flow.experience.v0.models.Order;
-    readonly redirect?: io.flow.payment.v0.unions.AuthorizationResultAction;
-    readonly errors?: io.flow.experience.v0.models.OrderError[];
+  interface CheckoutSettings {
+    readonly configuration: io.flow.experience.v0.models.ExperienceConfigurationReference;
   }
 
-  interface CheckoutSubmitOrderForm {
-    readonly discriminator: 'checkout_submit_order_form';
-    readonly authorization_form?: io.flow.payment.v0.unions.AuthorizationForm;
-    readonly expected_order_summary?: io.flow.bundle.checkout.v0.models.ExpectedOrderSummary;
+  interface CreditPayment {
+    readonly id: string;
+    readonly order: io.flow.experience.v0.unions.ExpandableOrder;
+    readonly key: string;
+    readonly description: string;
+    readonly value: io.flow.common.v0.models.PriceWithBase;
+    readonly original: io.flow.experience.v0.models.OriginalPrices;
+    readonly attributes: Record<string, string>;
   }
 
-  interface ExpectedOrderSummary {
-    readonly total?: io.flow.common.v0.models.Money;
+  interface CreditPaymentError {
+    readonly code: io.flow.experience.v0.enums.CreditPaymentErrorCode;
+    readonly messages: string[];
+    readonly codes: io.flow.experience.v0.enums.CreditPaymentErrorCode[];
   }
 
-  interface InvalidCheckoutData {
-    readonly order: io.flow.experience.v0.models.OrderPutForm;
+  interface CreditPaymentForm {
+    readonly order_number: string;
+    readonly description: string;
+    readonly amount: number;
+    readonly max: number;
+    readonly currency: string;
+    readonly attributes?: Record<string, string>;
   }
 
-  interface OrderParameters {
-    readonly experience?: string;
-    readonly country?: string;
-    readonly ip?: string;
-    readonly currency?: string;
-    readonly language?: string;
+  interface CreditPaymentVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly credit_payment: io.flow.experience.v0.models.CreditPayment;
   }
-}
 
-declare namespace io.flow.bundle.checkout.v0.unions {
-  type CheckoutForm =
-    | io.flow.bundle.checkout.v0.models.CheckoutOrderForm
-    | io.flow.bundle.checkout.v0.models.CheckoutOrderNumberForm;
-  type CheckoutSubmitOrderBundles = io.flow.bundle.checkout.v0.models.CheckoutSubmitOrderBundle;
-  type CheckoutSubmitOrderForms = io.flow.bundle.checkout.v0.models.CheckoutSubmitOrderForm;
-}
+  interface DeliveredDutySetting {
+    readonly default: io.flow.common.v0.enums.DeliveredDuty;
+    readonly available: io.flow.common.v0.enums.DeliveredDuty[];
+    readonly display?: io.flow.experience.v0.enums.DeliveredDutyDisplayType;
+  }
 
-declare namespace io.flow.tracking.v0.enums {
-  type TrackingStatus =
-    | 'label_created'
-    | 'pending'
-    | 'info_received'
-    | 'picked_up'
-    | 'in_transit'
-    | 'out_for_delivery'
-    | 'attempt_fail'
-    | 'delivered'
-    | 'exception'
-    | 'returned'
-    | 'expired';
-}
-
-declare namespace io.flow.tracking.v0.models {
-  interface Tracking {
-    readonly id: string;
-    readonly labels: io.flow.tracking.v0.models.TrackingLabel[];
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly attributes: Record<string, string>;
-    readonly url: string;
-    readonly window?: io.flow.common.v0.models.DatetimeRange;
-    readonly order_number?: string;
-  }
-
-  interface TrackingEvent {
+  interface Discount {
+    readonly discriminator: 'discount';
     readonly id: string;
-    readonly address: io.flow.common.v0.models.Address;
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly timestamp: string;
-    readonly description?: string;
-  }
-
-  interface TrackingEventForm {
-    readonly tracking_label_id: string;
-    readonly timestamp: string;
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly description?: string;
-    readonly address?: string;
+    readonly code?: string;
+    readonly label: string;
+    readonly price: io.flow.common.v0.models.PriceWithBase;
+    readonly attributes?: Record<string, string>;
   }
 
-  interface TrackingEventSummary {
+  interface Experience {
+    readonly discriminator: 'experience';
     readonly id: string;
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly timestamp: string;
+    readonly key: string;
+    readonly name: string;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly region: io.flow.experience.v0.models.RegionReference;
+    readonly country: string;
+    readonly currency: string;
+    readonly language: string;
+    readonly measurement_system: io.flow.common.v0.enums.MeasurementSystem;
+    readonly subcatalog: io.flow.catalog.v0.models.SubcatalogReference;
+    readonly position: number;
+    readonly settings: io.flow.experience.v0.models.ExperienceSettings;
+    readonly status?: io.flow.experience.v0.enums.ExperienceStatus;
   }
 
-  interface TrackingEventVersion {
+  interface ExperienceCheckoutSettings {
     readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly tracking_event: io.flow.tracking.v0.models.TrackingEventSummary;
+    readonly experience: io.flow.experience.v0.models.ExperienceOverview;
+    readonly checkout_configuration: io.flow.experience.v0.models.ExperienceConfigurationReference;
   }
 
-  interface TrackingForm {
-    readonly status?: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly order_number?: string;
-    readonly attributes?: Record<string, string>;
-    readonly window?: io.flow.common.v0.models.DatetimeRange;
+  interface ExperienceCheckoutSettingsForm {
+    readonly checkout_configuration_id: string;
   }
 
-  interface TrackingLabel {
+  interface ExperienceClone {
     readonly id: string;
-    readonly carrier: string;
-    readonly carrier_tracking_number: string;
-    readonly events: io.flow.tracking.v0.models.TrackingEvent[];
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly timestamp: string;
-    readonly delivery_estimate?: string;
-    readonly description?: string;
-  }
-
-  interface TrackingLabelForm {
-    readonly tracking_id: string;
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly carrier: string;
-    readonly carrier_tracking_number: string;
-    readonly delivery_estimate?: string;
-    readonly description?: string;
-    readonly timestamp?: string;
-    readonly parent_id?: string;
+    readonly source_experience: io.flow.experience.v0.models.ExperienceReference;
+    readonly cloned_experience?: io.flow.experience.v0.models.ExperienceReference;
+    readonly status: io.flow.experience.v0.enums.ExperienceCloneStatus;
   }
 
-  interface TrackingLabelSummary {
-    readonly id: string;
-    readonly tracking: io.flow.tracking.v0.models.TrackingSummary;
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly carrier: string;
-    readonly tracking_number: string;
+  interface ExperienceCloneForm {
+    readonly name?: string;
   }
 
-  interface TrackingLabelVersion {
+  interface ExperienceConfigurationReference {
     readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly tracking_label: io.flow.tracking.v0.models.TrackingLabelSummary;
   }
 
-  interface TrackingSummary {
-    readonly id: string;
-    readonly status: io.flow.tracking.v0.enums.TrackingStatus;
-    readonly order_number?: string;
+  interface ExperienceCurrencyFormat {
+    readonly symbol: io.flow.common.v0.enums.CurrencySymbolFormat;
+    readonly label_formatters: io.flow.common.v0.enums.CurrencyLabelFormatter[];
   }
 
-  interface TrackingVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly tracking: io.flow.tracking.v0.models.TrackingSummary;
+  interface ExperienceCurrencyFormatForm {
+    readonly symbol: io.flow.common.v0.enums.CurrencySymbolFormat;
+    readonly label_formatters: io.flow.common.v0.enums.CurrencyLabelFormatter[];
   }
-}
-
-declare namespace io.flow.experience.v0.enums {
-  type CreditPaymentErrorCode =
-    | 'generic_error'
-    | 'invalid_order_number'
-    | 'invalid_currency'
-    | 'invalid_description'
-    | 'duplicate'
-    | 'amount_must_be_positive'
-    | 'amount_exceeds_balance'
-    | 'insufficient_amount';
-  type DeliveredDutyDisplayType = 'all' | 'single';
-  type ExperienceCloneStatus = 'pending' | 'updating' | 'completed' | 'failed';
-  type ExperiencePaymentMethodTag = 'display';
-  type ExperienceStatus = 'draft' | 'active' | 'archiving' | 'archived';
-  type OrderErrorCode =
-    | 'generic_error'
-    | 'order_item_not_available'
-    | 'order_identifier_error'
-    | 'authorization_invalid'
-    | 'domestic_shipping_unavailable'
-    | 'shipping_unavailable'
-    | 'value_threshold_exceeded'
-    | 'invalid_currency'
-    | 'invalid_country'
-    | 'invalid_region'
-    | 'invalid_language'
-    | 'item_out_of_stock'
-    | 'gift_card_not_accepted'
-    | 'total_changed';
-  type OrderPaymentType =
-    | 'card'
-    | 'online'
-    | 'credit'
-    | 'installment_plan'
-    | 'cash_on_delivery';
-  type OrderStatus = 'open' | 'submitted';
-  type OrderStorage = 'do_not_persist' | 'persist';
-  type OrganizationPaymentMethodTag = 'deny';
-  type PaymentMethodRuleContentKey = 'description';
-  type PriceFacetBoundary = 'min' | 'max';
-  type PromotionTriggerType = 'automatic' | 'order_subtotal';
-}
 
-declare namespace io.flow.experience.v0.models {
-  interface AddressConfiguration {
+  interface ExperienceDefaults {
+    readonly key: string;
+    readonly name: string;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
     readonly country: string;
-    readonly field_validation: io.flow.experience.v0.models.AddressFieldValidation;
-    readonly provinces: io.flow.experience.v0.models.AddressConfigurationProvince[];
+    readonly currency: string;
+    readonly language: string;
+    readonly measurement_system: io.flow.common.v0.enums.MeasurementSystem;
   }
 
-  interface AddressConfigurationProvince {
-    readonly value: string;
+  interface ExperienceForm {
+    readonly region_id: string;
     readonly name: string;
-    readonly translations?: io.flow.experience.v0.models.AddressConfigurationProvinceTranslation[];
+    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
+    readonly country?: string;
+    readonly currency?: string;
+    readonly language?: string;
+    readonly key?: string;
+    readonly measurement_system?: io.flow.common.v0.enums.MeasurementSystem;
+    readonly subcatalog_id?: string;
   }
 
-  interface AddressConfigurationProvinceTranslation {
-    readonly locale: io.flow.experience.v0.models.AddressConfigurationProvinceTranslationLocale;
+  interface ExperienceGeo {
+    readonly key: string;
     readonly name: string;
+    readonly region: io.flow.experience.v0.models.RegionReference;
+    readonly country: string;
+    readonly currency: string;
+    readonly language: string;
+    readonly measurement_system: io.flow.common.v0.enums.MeasurementSystem;
   }
 
-  interface AddressConfigurationProvinceTranslationLocale {
+  interface ExperienceLogisticsSettings {
     readonly id: string;
-    readonly name: string;
-    readonly language: string;
+    readonly experience: io.flow.experience.v0.models.ExperienceOverview;
+    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfigurationReference;
   }
 
-  interface AddressFieldValidation {
-    readonly first_name: io.flow.field.validation.v0.unions.FieldValidationRule[];
-    readonly last_name: io.flow.field.validation.v0.unions.FieldValidationRule[];
-    readonly street_1: io.flow.field.validation.v0.unions.FieldValidationRule[];
-    readonly street_2: io.flow.field.validation.v0.unions.FieldValidationRule[];
-    readonly city: io.flow.field.validation.v0.unions.FieldValidationRule[];
-    readonly province: io.flow.field.validation.v0.unions.FieldValidationRule[];
-    readonly postal: io.flow.field.validation.v0.unions.FieldValidationRule[];
-    readonly phone: io.flow.field.validation.v0.unions.FieldValidationRule[];
+  interface ExperienceLogisticsSettingsPutForm {
+    readonly shipping_configuration_key: string;
   }
 
-  interface Allocation {
-    readonly order: io.flow.experience.v0.models.AllocationOrderSummary;
-    readonly details: io.flow.experience.v0.unions.AllocationDetail[];
+  interface ExperienceLogisticsSummary {
+    readonly outbound?: io.flow.experience.v0.models.ExperienceLogisticsTierSummary;
+    readonly return?: io.flow.experience.v0.models.ExperienceLogisticsTierSummary;
   }
 
-  interface AllocationDetailComponent {
-    readonly discriminator: 'allocation_detail_component';
-    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailComponentKey;
-    readonly total: io.flow.common.v0.models.PriceWithBase;
-    readonly price?: io.flow.common.v0.models.PriceWithBase;
+  interface ExperienceLogisticsTierSummary {
+    readonly prices: io.flow.experience.v0.models.ExperienceLogisticsTierSummaryPrices;
   }
 
-  interface AllocationLevyComponent {
-    readonly discriminator: 'allocation_levy_component';
-    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailComponentKey;
-    readonly total: io.flow.common.v0.models.PriceWithBase;
-    readonly rate: number;
-    readonly name: string;
-    readonly price?: io.flow.common.v0.models.PriceWithBase;
-    readonly accuracy?: io.flow.price.v0.enums.PriceAccuracy;
-    readonly basis?: io.flow.common.v0.models.MoneyWithBase;
+  interface ExperienceLogisticsTierSummaryPrices {
+    readonly minimum: io.flow.common.v0.models.Price;
   }
 
-  interface AllocationLineDetail {
-    readonly discriminator: 'allocation_line_detail';
-    readonly number: string;
-    readonly quantity: number;
-    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailKey;
-    readonly price: io.flow.common.v0.models.PriceWithBase;
-    readonly total: io.flow.common.v0.models.PriceWithBase;
-    readonly included: io.flow.experience.v0.unions.AllocationComponent[];
-    readonly not_included: io.flow.experience.v0.unions.AllocationComponent[];
+  interface ExperienceOverview {
+    readonly id: string;
+    readonly key: string;
   }
 
-  interface AllocationOrderDetail {
-    readonly discriminator: 'allocation_order_detail';
-    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailKey;
-    readonly total: io.flow.common.v0.models.PriceWithBase;
-    readonly included: io.flow.experience.v0.unions.AllocationComponent[];
-    readonly not_included: io.flow.experience.v0.unions.AllocationComponent[];
+  interface ExperiencePaymentMethodRuleForm {
+    readonly payment_method_id: string;
+    readonly tags: io.flow.experience.v0.enums.ExperiencePaymentMethodTag[];
+    readonly q?: string;
   }
 
-  interface AllocationOrderSummary {
-    readonly id: string;
-    readonly number: string;
-    readonly submitted_at?: string;
-  }
-
-  interface AllocationV2 {
-    readonly id: string;
-    readonly order: io.flow.experience.v0.models.AllocationOrderSummary;
-    readonly details: io.flow.experience.v0.unions.AllocationDetail[];
-    readonly total: io.flow.catalog.v0.models.LocalizedTotal;
-  }
-
-  interface AvailablePromotion {
-    readonly id: string;
-    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfigurationReference;
-    readonly region: io.flow.experience.v0.models.RegionReference;
-    readonly promotions: io.flow.experience.v0.unions.Promotion[];
-  }
-
-  interface CheckoutAttribute {
-    readonly id: string;
-    readonly experience: io.flow.experience.v0.models.ExperienceReference;
-    readonly key: string;
-    readonly name: string;
-    readonly attribute_keys: string[];
-    readonly position: number;
-  }
-
-  interface CheckoutAttributeForm {
-    readonly key: string;
-    readonly name?: string;
-    readonly experience_key: string;
-    readonly attribute_keys: string[];
-    readonly position?: number;
-  }
-
-  interface CheckoutItemContent {
-    readonly item: io.flow.catalog.v0.models.Item;
-    readonly name: string;
-    readonly description?: string;
-    readonly attributes: io.flow.experience.v0.models.CheckoutItemContentAttribute[];
-    readonly image?: io.flow.catalog.v0.models.Image;
-  }
-
-  interface CheckoutItemContentAttribute {
-    readonly key: string;
-    readonly name: string;
-    readonly value: string;
-  }
-
-  interface CheckoutSettings {
-    readonly configuration: io.flow.experience.v0.models.ExperienceConfigurationReference;
-  }
-
-  interface CreditPayment {
-    readonly id: string;
-    readonly order: io.flow.experience.v0.unions.ExpandableOrder;
-    readonly key: string;
-    readonly description: string;
-    readonly value: io.flow.common.v0.models.PriceWithBase;
-    readonly original: io.flow.experience.v0.models.OriginalPrices;
-    readonly attributes: Record<string, string>;
-  }
-
-  interface CreditPaymentError {
-    readonly code: io.flow.experience.v0.enums.CreditPaymentErrorCode;
-    readonly messages: string[];
-    readonly codes: io.flow.experience.v0.enums.CreditPaymentErrorCode[];
-  }
-
-  interface CreditPaymentForm {
-    readonly order_number: string;
-    readonly description: string;
-    readonly amount: number;
-    readonly max: number;
-    readonly currency: string;
-    readonly attributes?: Record<string, string>;
-  }
-
-  interface CreditPaymentVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly credit_payment: io.flow.experience.v0.models.CreditPayment;
-  }
-
-  interface DeliveredDutySetting {
-    readonly default: io.flow.common.v0.enums.DeliveredDuty;
-    readonly available: io.flow.common.v0.enums.DeliveredDuty[];
-    readonly display?: io.flow.experience.v0.enums.DeliveredDutyDisplayType;
-  }
-
-  interface Discount {
-    readonly discriminator: 'discount';
-    readonly id: string;
-    readonly code?: string;
-    readonly label: string;
-    readonly price: io.flow.common.v0.models.PriceWithBase;
-    readonly attributes?: Record<string, string>;
-  }
-
-  interface Experience {
-    readonly discriminator: 'experience';
-    readonly id: string;
-    readonly key: string;
-    readonly name: string;
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
-    readonly region: io.flow.experience.v0.models.RegionReference;
-    readonly country: string;
-    readonly currency: string;
-    readonly language: string;
-    readonly measurement_system: io.flow.common.v0.enums.MeasurementSystem;
-    readonly subcatalog: io.flow.catalog.v0.models.SubcatalogReference;
-    readonly position: number;
-    readonly settings: io.flow.experience.v0.models.ExperienceSettings;
-    readonly status?: io.flow.experience.v0.enums.ExperienceStatus;
-  }
-
-  interface ExperienceCheckoutSettings {
-    readonly id: string;
-    readonly experience: io.flow.experience.v0.models.ExperienceOverview;
-    readonly checkout_configuration: io.flow.experience.v0.models.ExperienceConfigurationReference;
-  }
-
-  interface ExperienceCheckoutSettingsForm {
-    readonly checkout_configuration_id: string;
-  }
-
-  interface ExperienceClone {
-    readonly id: string;
-    readonly source_experience: io.flow.experience.v0.models.ExperienceReference;
-    readonly cloned_experience?: io.flow.experience.v0.models.ExperienceReference;
-    readonly status: io.flow.experience.v0.enums.ExperienceCloneStatus;
-  }
-
-  interface ExperienceCloneForm {
-    readonly name?: string;
-  }
-
-  interface ExperienceConfigurationReference {
-    readonly id: string;
-  }
-
-  interface ExperienceCurrencyFormat {
-    readonly symbol: io.flow.common.v0.enums.CurrencySymbolFormat;
-    readonly label_formatters: io.flow.common.v0.enums.CurrencyLabelFormatter[];
-  }
-
-  interface ExperienceCurrencyFormatForm {
-    readonly symbol: io.flow.common.v0.enums.CurrencySymbolFormat;
-    readonly label_formatters: io.flow.common.v0.enums.CurrencyLabelFormatter[];
-  }
-
-  interface ExperienceDefaults {
-    readonly key: string;
-    readonly name: string;
-    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
-    readonly country: string;
-    readonly currency: string;
-    readonly language: string;
-    readonly measurement_system: io.flow.common.v0.enums.MeasurementSystem;
-  }
-
-  interface ExperienceForm {
-    readonly region_id: string;
-    readonly name: string;
-    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
-    readonly country?: string;
-    readonly currency?: string;
-    readonly language?: string;
-    readonly key?: string;
-    readonly measurement_system?: io.flow.common.v0.enums.MeasurementSystem;
-    readonly subcatalog_id?: string;
-  }
-
-  interface ExperienceGeo {
-    readonly key: string;
-    readonly name: string;
-    readonly region: io.flow.experience.v0.models.RegionReference;
-    readonly country: string;
-    readonly currency: string;
-    readonly language: string;
-    readonly measurement_system: io.flow.common.v0.enums.MeasurementSystem;
-  }
-
-  interface ExperienceLogisticsSettings {
-    readonly id: string;
-    readonly experience: io.flow.experience.v0.models.ExperienceOverview;
-    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfigurationReference;
-  }
-
-  interface ExperienceLogisticsSettingsPutForm {
-    readonly shipping_configuration_key: string;
-  }
-
-  interface ExperienceLogisticsSummary {
-    readonly outbound?: io.flow.experience.v0.models.ExperienceLogisticsTierSummary;
-    readonly return?: io.flow.experience.v0.models.ExperienceLogisticsTierSummary;
-  }
-
-  interface ExperienceLogisticsTierSummary {
-    readonly prices: io.flow.experience.v0.models.ExperienceLogisticsTierSummaryPrices;
-  }
-
-  interface ExperienceLogisticsTierSummaryPrices {
-    readonly minimum: io.flow.common.v0.models.Price;
-  }
-
-  interface ExperienceOverview {
-    readonly id: string;
-    readonly key: string;
-  }
-
-  interface ExperiencePaymentMethodRuleForm {
-    readonly payment_method_id: string;
-    readonly tags: io.flow.experience.v0.enums.ExperiencePaymentMethodTag[];
-    readonly q?: string;
-  }
-
-  interface ExperiencePriceBookMapping {
+  interface ExperiencePriceBookMapping {
     readonly id: string;
     readonly experience: io.flow.experience.v0.models.ExperienceReference;
     readonly price_book: io.flow.price.v0.models.PriceBookReference;
@@ -1705,778 +1412,783 @@ declare namespace io.flow.item.v0.models {
   }
 }
 
-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.harmonization.internal.event.v0.enums {
+  type SuggestionAction = 'accept' | 'validate' | 'review';
 }
 
-declare namespace io.flow.flexe.v0.models {
-  interface BillOfLading {
-    readonly type: string;
-    readonly gs1us?: io.flow.flexe.v0.models.Gs1Us;
-  }
-
-  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;
+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 CartonPickDeliveryDetails {
-    readonly shipment_uuid?: string;
-    readonly carrier?: string;
-    readonly carrier_id?: string;
+  interface BatchRateRefillRequest {
+    readonly discriminator: 'batch_rate_refill_request';
+    readonly requests: io.flow.harmonization.internal.event.v0.models.RateRefillRequest[];
   }
 
-  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 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 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 BlacklistedItemDeleted {
+    readonly discriminator: 'blacklisted_item_deleted';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly id: string;
   }
 
-  interface Error {
-    readonly url: string;
-    readonly client_request_id: string;
-    readonly generated_at: string;
-    readonly error: string;
+  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 FlexeAttachment {
-    readonly type: io.flow.flexe.v0.enums.FlexeAttachmentType;
-    readonly display_name: string;
-    readonly url: 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 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 CustomsDescriptionSugestion {
+    readonly value: number;
+    readonly customs_description: string;
+    readonly action?: io.flow.harmonization.internal.event.v0.enums.SuggestionAction;
   }
 
-  interface FlexeEcommerceFulfillmentData {
-    readonly import_id: string;
-    readonly succeeded_uuids: string[];
-    readonly failed_uuids: string[];
-    readonly errors: string[];
+  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 FlexeEcommerceFulfillmentErrors {
-    readonly status: string;
-    readonly title: string;
-    readonly detail: string;
-    readonly source?: 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 FlexeEcommerceFulfillmentForm {
-    readonly reservation_id: number;
-    readonly client_request_id: string;
-    readonly request: io.flow.flexe.v0.models.Orders;
+  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 FlexeInventoryData {
-    readonly sku: string;
-    readonly quantity: string;
-    readonly unit: 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 FlexeRetailAttachment {
-    readonly display_name: string;
-    readonly url: 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 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 HarmonizeFullyRequest {
+    readonly discriminator: 'harmonize_fully_request';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly item_id: string;
   }
 
-  interface FlexeRetailFulfillmentData {
-    readonly id: string;
-    readonly purchase_order_uuid: string;
-    readonly status: 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 FlexeRetailFulfillmentErrors {
-    readonly type: string;
-    readonly message: string;
+  interface HarmonizedItemsHs6Export {
+    readonly discriminator: 'harmonized_items_hs6_export';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly export_id: string;
   }
 
-  interface FlexeRetailFulfillmentForm {
-    readonly reservation_id: number;
-    readonly client_request_id?: string;
-    readonly request: io.flow.flexe.v0.models.RetailOrder;
+  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 FulfillmentOrderDetails {
-    readonly shipment_uuid: string;
-    readonly carrier?: string;
-    readonly carrier_id?: string;
+  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 Gs1Us {
-    readonly number: string;
-    readonly ship_to?: io.flow.flexe.v0.models.Gs1UsShipTo;
-    readonly bill_to?: io.flow.flexe.v0.models.BillTo;
+  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 Gs1UsShipTo {
-    readonly cid_number?: string;
-    readonly location_number?: string;
-    readonly free_on_board?: boolean;
+  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 Inventory {
-    readonly url: string;
-    readonly client_request_id: string;
-    readonly generated_at: string;
-    readonly data: Record<string, io.flow.flexe.v0.models.InventoryDetails>;
+  interface LandedCostItem {
+    readonly number: string;
+    readonly origin: string;
+    readonly destination: string;
   }
 
-  interface InventoryCount {
-    readonly amount: number;
-    readonly unit: string;
+  interface PhraseClassified {
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly phrase_id: string;
   }
 
-  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 PhrasePropagated {
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly phrase_id: string;
   }
 
-  interface InventoryDetails {
-    readonly key: Record<string, io.flow.flexe.v0.models.Sku>;
+  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 LadingQuantity {
-    readonly num_pallets: number;
+  interface UnharmonizedItemsExport {
+    readonly discriminator: 'unharmonized_items_export';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly export_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[];
-  }
+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 Orders {
-    readonly orders: io.flow.flexe.v0.models.Order[];
-  }
+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 Pallet {
-    readonly pallet_id: string;
-    readonly sku: string;
-    readonly quantity: number;
-    readonly packaging: string;
+declare namespace io.flow.inventory.v0.models {
+  interface ExternalApiTimeoutReservationError {
+    readonly code: 'external_api_timeout';
+    readonly messages: 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 GenericReservationError {
+    readonly code: 'generic_reservation_error';
+    readonly messages: string[];
   }
 
-  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 InventoryBackorder {
+    readonly discriminator: 'inventory_backorder';
+    readonly quantity: number;
   }
 
-  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 InventoryCenterReference {
+    readonly key: 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 InventoryCheckResponse {
+    readonly items: io.flow.inventory.v0.models.InventoryCheckResponseItem[];
   }
 
-  interface RetailInventoryData {
-    readonly sku: string;
+  interface InventoryCheckResponseItem {
+    readonly number: string;
     readonly quantity: number;
-    readonly unit: string;
-    readonly attachments?: io.flow.flexe.v0.models.FlexeRetailAttachment[];
+    readonly inventory_status: io.flow.inventory.v0.enums.InventoryStatus;
   }
 
-  interface RetailOrder {
-    readonly order: io.flow.flexe.v0.models.RetailOrderData;
+  interface InventoryExperienceReference {
+    readonly key: string;
   }
 
-  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 InventoryItemReference {
+    readonly number: 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 InventoryRequest {
+    readonly items: io.flow.inventory.v0.models.InventoryRequestItem[];
   }
 
-  interface ShipWithin {
-    readonly start: string;
-    readonly end: string;
+  interface InventoryRequestItem {
+    readonly number: string;
+    readonly quantity: number;
   }
 
-  interface ShipmentDeliveryDetails {
-    readonly shipment_uuid?: string;
+  interface InventoryRule {
+    readonly id: string;
+    readonly position: number;
+    readonly query: string;
+    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
   }
 
-  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 InventoryRuleForm {
+    readonly position: number;
+    readonly query: string;
+    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
   }
 
-  interface Sku {
-    readonly sku: string;
-    readonly description: string;
-    readonly summary: Record<string, io.flow.flexe.v0.models.SkuSummary>;
+  interface InventoryRuleVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly inventory_rule: io.flow.inventory.v0.models.InventoryRule;
   }
 
-  interface SkuSummary {
-    readonly key: string;
+  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;
-    readonly unit: 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;
+  interface InventorySnapshotVersion {
+    readonly id: string;
     readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly inventory_snapshot: io.flow.inventory.v0.models.InventorySnapshot;
   }
 
-  interface BatchRateRefillRequest {
-    readonly discriminator: 'batch_rate_refill_request';
-    readonly requests: io.flow.harmonization.internal.event.v0.models.RateRefillRequest[];
+  interface InventoryStock {
+    readonly discriminator: 'inventory_stock';
+    readonly quantity: number;
   }
 
-  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 InventoryUnlimited {
+    readonly discriminator: 'inventory_unlimited';
+    readonly quantity: string;
   }
 
-  interface BlacklistedItemDeleted {
-    readonly discriminator: 'blacklisted_item_deleted';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: 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 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 NoInventoryReservationErrorItem {
+    readonly number: string;
+    readonly requested_quantity: number;
+    readonly available_quantity: number;
   }
 
-  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 PfsInventoryCheckResponse {
+    readonly items: Record<
+      string,
+      io.flow.inventory.v0.models.PfsInventoryCheckResponseItem
+    >;
   }
 
-  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 PfsInventoryCheckResponseItem {
+    readonly number: string;
+    readonly ats: number;
+    readonly in_stock: boolean;
   }
 
-  interface HarmonizeFullyRequest {
-    readonly discriminator: 'harmonize_fully_request';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly item_id: string;
+  interface PfsInventoryStatus {
+    readonly status: 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 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 HarmonizedItemsHs6Export {
-    readonly discriminator: 'harmonized_items_hs6_export';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
+  interface ReservationForm {
+    readonly order_number?: string;
+    readonly items: io.flow.inventory.v0.models.ReservationItemForm[];
   }
 
-  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 ReservationItem {
+    readonly item: io.flow.inventory.v0.models.ReservationItemReference;
+    readonly quantity: number;
   }
 
-  interface ItemHarmonized {
-    readonly discriminator: 'item_harmonized';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
+  interface ReservationItemForm {
     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 LabelsPrediction {
-    readonly main_material: Record<string, number>;
-    readonly gender: Record<string, number>;
-    readonly construction: Record<string, number>;
-    readonly product_type: Record<string, 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[];
+    readonly quantity: number;
   }
 
-  interface LandedCostItem {
+  interface ReservationItemReference {
     readonly number: string;
-    readonly origin: string;
-    readonly destination: string;
   }
 
-  interface PhraseClassified {
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly phrase_id: string;
+  interface ReservationOrderReference {
+    readonly number: string;
   }
 
-  interface PhrasePropagated {
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly phrase_id: string;
+  interface Serial {
+    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 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 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 UnharmonizedItemsExport {
-    readonly discriminator: 'unharmonized_items_export';
-    readonly event_id: string;
+  interface SerialVersion {
+    readonly id: string;
     readonly timestamp: string;
-    readonly organization: string;
-    readonly export_id: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly serial: io.flow.inventory.v0.models.Serial;
   }
 }
 
-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;
+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.inventory.v0.enums {
-  type Aggregate = 'maximum' | 'minimum';
-  type InventoryStatus = 'has_inventory' | 'no_inventory';
-  type SerialStatus = 'available' | 'reserved' | 'sold';
-  type UpdateType = 'change' | 'set';
-}
+declare namespace io.flow.ratecard.v0.models {
+  interface CrossdockRatecardFee {
+    readonly discriminator: 'crossdock_ratecard_fee';
+    readonly amount: io.flow.common.v0.models.Money;
+  }
 
-declare namespace io.flow.inventory.v0.models {
-  interface ExternalApiTimeoutReservationError {
-    readonly code: 'external_api_timeout';
-    readonly messages: string[];
+  interface DdpRatecardFee {
+    readonly discriminator: 'ddp_ratecard_fee';
+    readonly amount: number;
   }
 
-  interface GenericReservationError {
-    readonly code: 'generic_reservation_error';
-    readonly messages: string[];
+  interface DimensionEstimate {
+    readonly id: string;
+    readonly q: string;
+    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
+    readonly position: number;
   }
 
-  interface InventoryBackorder {
-    readonly discriminator: 'inventory_backorder';
-    readonly quantity: number;
+  interface DimensionEstimateForm {
+    readonly q: string;
+    readonly dimensions: io.flow.ratecard.v0.models.EstimatedDimensions;
+    readonly position?: number;
   }
 
-  interface InventoryCenterReference {
-    readonly key: string;
+  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 InventoryCheckResponse {
-    readonly items: io.flow.inventory.v0.models.InventoryCheckResponseItem[];
+  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 InventoryCheckResponseItem {
-    readonly number: string;
-    readonly quantity: number;
-    readonly inventory_status: io.flow.inventory.v0.enums.InventoryStatus;
+  interface FuelSurchargeRatecardFee {
+    readonly discriminator: 'fuel_surcharge_ratecard_fee';
+    readonly amount: io.flow.common.v0.models.Money;
   }
 
-  interface InventoryExperienceReference {
-    readonly key: string;
+  interface FuelSurchargeServiceFee {
+    readonly discriminator: 'fuel_surcharge_service_fee';
+    readonly percent: number;
   }
 
-  interface InventoryItemReference {
-    readonly number: string;
+  interface Hop {
+    readonly hop_number: number;
+    readonly hop_estimate: io.flow.ratecard.v0.models.HopEstimate;
   }
 
-  interface InventoryRequest {
-    readonly items: io.flow.inventory.v0.models.InventoryRequestItem[];
+  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 InventoryRequestItem {
+  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 quantity: number;
+    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 InventoryRule {
+  interface RatecardCarrierSummary {
     readonly id: string;
-    readonly position: number;
-    readonly query: string;
-    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+    readonly name: string;
   }
 
-  interface InventoryRuleForm {
-    readonly position: number;
-    readonly query: string;
-    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+  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 InventoryRuleVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly inventory_rule: io.flow.inventory.v0.models.InventoryRule;
+  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 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 RatecardEstimateSummaryForm {
+    readonly origin?: string;
+    readonly destination?: string;
+    readonly service?: string;
+    readonly center_key?: string;
   }
 
-  interface InventorySnapshotVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly inventory_snapshot: io.flow.inventory.v0.models.InventorySnapshot;
+  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 InventoryStock {
-    readonly discriminator: 'inventory_stock';
-    readonly quantity: number;
+  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 InventoryUnlimited {
-    readonly discriminator: 'inventory_unlimited';
-    readonly quantity: string;
+  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 InventoryUpdate {
+  interface RatecardLane {
     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;
+    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 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 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 InventoryUpdateVersion {
+  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 inventory_update: io.flow.inventory.v0.models.InventoryUpdate;
+    readonly ratecard_lane: io.flow.ratecard.v0.models.RatecardLane;
   }
 
-  interface NoInventoryReservationError {
-    readonly code: 'no_inventory';
-    readonly messages: string[];
-    readonly items: io.flow.inventory.v0.models.NoInventoryReservationErrorItem[];
+  interface RatecardLanesImportRequestData {
+    readonly id: string;
+    readonly source_url: string;
+    readonly filename?: string;
   }
 
-  interface NoInventoryReservationErrorItem {
-    readonly number: string;
-    readonly requested_quantity: number;
-    readonly available_quantity: number;
+  interface RatecardRate {
+    readonly id: string;
+    readonly amount: number;
+    readonly weight: number;
   }
 
-  interface PfsInventoryCheckResponse {
-    readonly items: Record<
-      string,
-      io.flow.inventory.v0.models.PfsInventoryCheckResponseItem
-    >;
+  interface RatecardRateForm {
+    readonly amount: number;
+    readonly weight: number;
   }
 
-  interface PfsInventoryCheckResponseItem {
-    readonly number: string;
-    readonly ats: number;
-    readonly in_stock: boolean;
+  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 PfsInventoryStatus {
-    readonly status: string;
+  interface RatecardReference {
+    readonly id: string;
   }
 
-  interface Reservation {
+  interface RatecardServiceSummary {
     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;
+    readonly name: string;
+    readonly carrier: io.flow.ratecard.v0.models.RatecardCarrierSummary;
   }
 
-  interface ReservationForm {
-    readonly order_number?: string;
-    readonly items: io.flow.inventory.v0.models.ReservationItemForm[];
+  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 ReservationItem {
-    readonly item: io.flow.inventory.v0.models.ReservationItemReference;
-    readonly quantity: number;
+  interface RemoteAreaRatecardFee {
+    readonly discriminator: 'remote_area_ratecard_fee';
+    readonly amount: io.flow.common.v0.models.Money;
   }
 
-  interface ReservationItemForm {
-    readonly item_number: string;
-    readonly quantity: number;
+  interface RemoteAreaServiceFee {
+    readonly discriminator: 'remote_area_service_fee';
+    readonly amount: io.flow.common.v0.models.Money;
   }
 
-  interface ReservationItemReference {
-    readonly number: string;
-  }
+  interface ReturnPackageRatecardFee {
+    readonly discriminator: 'return_package_ratecard_fee';
+    readonly amount: number;
+  }
 
-  interface ReservationOrderReference {
-    readonly number: string;
+  interface ShipmentWindow {
+    readonly from: number;
+    readonly to: number;
   }
+}
 
-  interface Serial {
+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.session.context.v0.models {
+  interface Context {
     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>;
+    readonly experiments: io.flow.session.context.v0.models.Experiment[];
   }
 
-  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 ContextForm {
+    readonly experiments: io.flow.session.context.v0.models.Experiment[];
   }
 
-  interface SerialVersion {
+  interface ContextReference {
     readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly serial: io.flow.inventory.v0.models.Serial;
   }
-}
 
-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;
+  interface Experiment {
+    readonly key: string;
+    readonly variant?: io.flow.session.context.v0.models.ExperimentVariant;
+  }
+
+  interface ExperimentVariant {
+    readonly key: string;
+  }
 }
 
 declare namespace io.flow.optin.internal.v0.enums {
@@ -6354,7 +6066,7 @@ declare namespace io.flow.shopify.v0.unions {
 
 declare namespace io.flow.payment.internal.v0.enums {
   type ChargebackPaymentStatus = 'captured' | 'refunded';
-  type ChargebackProcessStatus = 'open' | 'closed';
+  type ChargebackProcessStatus = 'inquiry' | 'open' | 'closed';
   type HttpMethod = 'get' | 'post';
   type Processor =
     | 'adyen'
@@ -6362,7 +6074,9 @@ declare namespace io.flow.payment.internal.v0.enums {
     | 'bitpay'
     | 'stripe'
     | 'paypal'
-    | 'flow_sandbox';
+    | 'flow_sandbox'
+    | 'fiserv'
+    | 'crypto';
   type RedirectReason = 'three_d_secure';
   type RiskCheck = 'three_d_secure';
 }
@@ -6437,7 +6151,6 @@ declare namespace io.flow.payment.internal.v0.models {
     readonly id: string;
     readonly key: string;
     readonly authorization: io.flow.payment.v0.models.AuthorizationReference;
-    readonly capture: io.flow.payment.v0.models.CaptureReference;
     readonly amount: number;
     readonly currency: string;
     readonly base?: io.flow.common.v0.models.Money;
@@ -6450,6 +6163,7 @@ declare namespace io.flow.payment.internal.v0.models {
     readonly processor_status: string;
     readonly processor_reference?: string;
     readonly provider_reference?: string;
+    readonly provider_reason_code?: string;
   }
 
   interface ChargebackVersion {
@@ -6486,6 +6200,11 @@ declare namespace io.flow.payment.internal.v0.models {
     readonly passphrase_ids: string[];
   }
 
+  interface FiservAuthenticationDataReference {
+    readonly account_id: string;
+    readonly store_id: string;
+  }
+
   interface InternalAdyenAuthorizationDetails {
     readonly discriminator: 'internal_adyen_authorization_details';
     readonly adyen_authentication_data: io.flow.payment.internal.v0.models.AdyenAuthenticationDataReference;
@@ -6506,6 +6225,11 @@ declare namespace io.flow.payment.internal.v0.models {
     readonly internal?: io.flow.payment.internal.v0.unions.InternalAuthorizationDetails;
   }
 
+  interface InternalFiservAuthorizationDetails {
+    readonly discriminator: 'internal_fiserv_authorization_details';
+    readonly fiserv_authentication_data: io.flow.payment.internal.v0.models.FiservAuthenticationDataReference;
+  }
+
   interface InternalPaypalAuthorizationDetails {
     readonly discriminator: 'internal_paypal_authorization_details';
     readonly paypal_authentication_data: io.flow.payment.internal.v0.models.PaypalAuthenticationDataReference;
@@ -6618,7 +6342,8 @@ declare namespace io.flow.payment.internal.v0.unions {
     | io.flow.payment.internal.v0.models.InternalBitpayAuthorizationDetails
     | io.flow.payment.internal.v0.models.InternalStripeAuthorizationDetails
     | io.flow.payment.internal.v0.models.InternalAdyenAuthorizationDetails
-    | io.flow.payment.internal.v0.models.InternalAfterpayAuthorizationDetails;
+    | io.flow.payment.internal.v0.models.InternalAfterpayAuthorizationDetails
+    | io.flow.payment.internal.v0.models.InternalFiservAuthorizationDetails;
   type InternalRefundForm = io.flow.payment.internal.v0.models.AdyenRefundForm;
   type PaymentAccount = io.flow.payment.internal.v0.models.StripeAccount;
   type PaymentAccountForm = io.flow.payment.internal.v0.models.StripeAccountForm;
@@ -8818,691 +8543,1088 @@ declare namespace io.flow.stripe.v0.models {
     readonly dynamic_last4?: string;
   }
 
-  interface SourceCardRequest {
-    readonly exp_month: string;
-    readonly exp_year: string;
+  interface SourceCardRequest {
+    readonly exp_month: string;
+    readonly exp_year: string;
+    readonly number: string;
+    readonly cvc?: string;
+  }
+
+  interface SourceKlarna {
+    readonly first_name?: string;
+    readonly last_name?: string;
+    readonly client_token: string;
+  }
+
+  interface SourceKlarnaRequest {
+    readonly first_name: string;
+    readonly last_name: string;
+    readonly attachment?: string;
+  }
+
+  interface SourceRequest {
+    readonly type?: io.flow.stripe.v0.enums.SourceType;
+    readonly amount?: number;
+    readonly card?: io.flow.stripe.v0.models.SourceCardRequest;
+    readonly currency?: string;
+    readonly flow?: io.flow.stripe.v0.enums.SourceFlow;
+    readonly klarna?: io.flow.stripe.v0.models.SourceKlarnaRequest;
+    readonly order?: io.flow.stripe.v0.models.OrderRequest;
+    readonly owner?: io.flow.stripe.v0.models.Owner;
+    readonly receiver?: io.flow.stripe.v0.models.Receiver;
+    readonly redirect?: io.flow.stripe.v0.models.Redirect;
+    readonly statement_descriptor?: string;
+    readonly three_d_secure?: io.flow.stripe.v0.models.ThreeDSecure;
+    readonly token?: string;
+    readonly usage: io.flow.stripe.v0.enums.SourceUsageType;
+  }
+
+  interface Stripe3Ds2Fingerprint {
+    readonly type: io.flow.stripe.v0.enums.UseStripeSdkType;
+    readonly three_d_secure_2_source: string;
+    readonly directory_server_name?: string;
+    readonly server_transaction_id?: string;
+    readonly three_ds_method_url?: string;
+    readonly three_ds_optimizations?: string;
+    readonly directory_server_encryption?: any /*object*/;
+  }
+
+  interface StripeError {
+    readonly type: io.flow.stripe.v0.enums.ErrorType;
+    readonly charge?: string;
+    readonly message?: string;
+    readonly code?: io.flow.stripe.v0.enums.CardErrorCode;
+    readonly decline_code?: string;
+    readonly param?: string;
+  }
+
+  interface StripeEvent {
+    readonly id: string;
+    readonly object: string;
+    readonly api_version?: string;
+    readonly created: number;
+    readonly data: io.flow.stripe.v0.models.StripeEventData;
+    readonly livemode: boolean;
+    readonly pending_webhooks: number;
+    readonly request?: io.flow.stripe.v0.models.StripeEventRequest;
+    readonly type: string;
+  }
+
+  interface StripeEventData {
+    readonly object?: any /*object*/;
+    readonly previous_attributes?: any /*object*/;
+  }
+
+  interface StripeEventRequest {
+    readonly id?: string;
+    readonly idempotency_key?: string;
+  }
+
+  interface ThreeDSecure {
+    readonly card: string;
+    readonly customer?: string;
+  }
+
+  interface ThreeDSecureRedirect {
+    readonly type: io.flow.stripe.v0.enums.UseStripeSdkType;
+    readonly stripe_js: string;
+  }
+
+  interface Token {
+    readonly id: string;
+    readonly object: string;
+    readonly client_ip: string;
+    readonly created: number;
+    readonly livemode: boolean;
+    readonly type: io.flow.stripe.v0.enums.TokenType;
+    readonly used: boolean;
+    readonly card?: io.flow.stripe.v0.models.Card;
+  }
+
+  interface TosAcceptance {
+    readonly date?: number;
+    readonly ip?: string;
+    readonly user_agent?: string;
+  }
+
+  interface TransferData {
+    readonly amount: number;
+    readonly destination?: string;
+  }
+}
+
+declare namespace io.flow.RESERVED_WORD_export.v0.enums {
+  type ExportStatus = 'created' | 'processing' | 'completed' | 'failed';
+}
+
+declare namespace io.flow.RESERVED_WORD_export.v0.models {
+  interface AccountOrdersExportType {
+    readonly discriminator: 'account_orders_export_type';
+    readonly statement_id?: string;
+    readonly transaction_summary_id?: string;
+    readonly transaction_created_from?: string;
+    readonly transaction_created_to?: string;
+    readonly transaction_created_on_or_after?: string;
+    readonly transaction_created_after?: string;
+    readonly transaction_created_on_or_before?: string;
+    readonly transaction_created_before?: string;
+    readonly transaction_posted_from?: string;
+    readonly transaction_posted_to?: string;
+    readonly transaction_posted_on_or_after?: string;
+    readonly transaction_posted_after?: string;
+    readonly transaction_posted_on_or_before?: string;
+    readonly transaction_posted_before?: string;
+  }
+
+  interface AccountTransactionsExportType {
+    readonly discriminator: 'account_transactions_export_type';
+    readonly statement_id?: string;
+    readonly transaction_summary_id?: string;
+    readonly created_from?: string;
+    readonly created_to?: string;
+    readonly created_on_or_after?: string;
+    readonly created_after?: string;
+    readonly created_on_or_before?: string;
+    readonly created_before?: string;
+    readonly posted_from?: string;
+    readonly posted_to?: string;
+    readonly posted_on_or_after?: string;
+    readonly posted_after?: string;
+    readonly posted_on_or_before?: string;
+    readonly posted_before?: string;
+  }
+
+  interface AnalyticsExportType {
+    readonly discriminator: 'analytics_export_type';
+    readonly from?: string;
+    readonly to?: string;
+    readonly region?: string;
+    readonly interval?: io.flow.common.v0.enums.UnitOfTime;
+  }
+
+  interface CatalogItemExportType {
+    readonly discriminator: 'catalog_item_export_type';
+    readonly numbers?: string[];
+    readonly q?: string;
+    readonly sort?: string;
+  }
+
+  interface CsvPriceBookItemExportRow {
+    readonly price_book_key: string;
+    readonly price_book_item_key: string;
+    readonly item_number: string;
+    readonly item_name: string;
+    readonly amount: number;
+    readonly item_attributes?: Record<string, string>;
+    readonly starts_at: string;
+    readonly ends_at?: string;
+  }
+
+  interface ExperienceExportType {
+    readonly discriminator: 'experience_export_type';
+    readonly organization_id: string;
+    readonly ids?: string[];
+    readonly keys?: string[];
+  }
+
+  interface Export {
+    readonly id: string;
+    readonly type: io.flow.RESERVED_WORD_export.v0.unions.ExportType;
+    readonly status: io.flow.RESERVED_WORD_export.v0.enums.ExportStatus;
+    readonly organization_q: string;
+    readonly created_at: string;
+    readonly started_at?: string;
+    readonly completed_at?: string;
+    readonly url?: string;
+    readonly deliveries: io.flow.RESERVED_WORD_export.v0.unions.ExportDelivery[];
+  }
+
+  interface ExportDeliveryEmail {
+    readonly discriminator: 'export_delivery_email';
+    readonly email: string;
+  }
+
+  interface ExportForm {
+    readonly type: io.flow.RESERVED_WORD_export.v0.unions.ExportType;
+    readonly emails?: string[];
+    readonly organization_q?: string;
+  }
+
+  interface ExportLocalizedItemPrices {
+    readonly organization: io.flow.common.v0.models.OrganizationReference;
+    readonly experience: io.flow.experience.v0.models.ExperienceReference;
+    readonly item: io.flow.common.v0.models.CatalogItemReference;
+    readonly prices: io.flow.RESERVED_WORD_export.v0.models.ExportLocalizedItemPricesDetail;
+    readonly status?: io.flow.catalog.v0.enums.SubcatalogItemStatus;
+  }
+
+  interface ExportLocalizedItemPricesDetail {
+    readonly item: io.flow.catalog.v0.models.LocalizedItemPrice;
+    readonly vat?: io.flow.catalog.v0.models.LocalizedItemVat;
+    readonly duty?: io.flow.catalog.v0.models.LocalizedItemDuty;
+    readonly price_attributes: Record<
+      string,
+      io.flow.common.v0.models.PriceWithBase
+    >;
+  }
+
+  interface ExportVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly export: io.flow.RESERVED_WORD_export.v0.models.Export;
+  }
+
+  interface HarmonizationHs10ExportType {
+    readonly discriminator: 'harmonization_hs10_export_type';
+    readonly origin?: string;
+    readonly destination?: string;
+    readonly numbers?: string[];
+    readonly has_codes?: boolean;
+    readonly has_origins?: boolean;
+    readonly sort?: string;
+  }
+
+  interface HarmonizationHs6ExportType {
+    readonly discriminator: 'harmonization_hs6_export_type';
+    readonly numbers?: string[];
+    readonly has_codes?: boolean;
+    readonly sort?: string;
+  }
+
+  interface HarmonizationLandedCostExportType {
+    readonly discriminator: 'harmonization_landed_cost_export_type';
+    readonly items: io.flow.RESERVED_WORD_export.v0.models.LandedCostItem[];
+  }
+
+  interface HarmonizationOverviewExportType {
+    readonly discriminator: 'harmonization_overview_export_type';
+    readonly origin?: string;
+    readonly destination?: string;
+    readonly sort?: string;
+  }
+
+  interface LandedCostItem {
+    readonly number: string;
+    readonly origin: string;
+    readonly destination: string;
+  }
+
+  interface LocalizedItemPricesExportType {
+    readonly discriminator: 'localized_item_prices_export_type';
+    readonly since?: string;
+  }
+
+  interface OrderExportType {
+    readonly discriminator: 'order_export_type';
+    readonly numbers?: string[];
+    readonly min_hours_since_submitted_at?: number;
+    readonly submitted_on_or_before?: string;
+    readonly submitted_on_or_after?: string;
+    readonly status?: io.flow.experience.v0.enums.OrderStatus;
+    readonly has_tracking_label?: boolean;
+    readonly sort?: string;
+  }
+
+  interface PriceBookItemExportType {
+    readonly discriminator: 'price_book_item_export_type';
+    readonly price_book_key?: string;
+    readonly item_numbers?: string[];
+    readonly start_date?: string;
+    readonly end_date?: string;
+  }
+
+  interface ScheduledExport {
+    readonly id: string;
+    readonly user: io.flow.common.v0.models.UserReference;
+    readonly organization_q: string;
+    readonly hour: number;
+    readonly minute: number;
+    readonly timezone: string;
+    readonly types: io.flow.RESERVED_WORD_export.v0.unions.ExportType[];
+    readonly last_sent_at?: string;
+  }
+
+  interface ScheduledExportForm {
+    readonly user_id: string;
+    readonly organization_q: string;
+    readonly hour: number;
+    readonly minute: number;
+    readonly timezone: string;
+    readonly types: io.flow.RESERVED_WORD_export.v0.unions.ExportType[];
+  }
+
+  interface SolidusProductExportType {
+    readonly discriminator: 'solidus_product_export_type';
+    readonly numbers?: string[];
+    readonly sort?: string;
+  }
+
+  interface SolidusVariantExportType {
+    readonly discriminator: 'solidus_variant_export_type';
+    readonly numbers?: string[];
+    readonly sort?: string;
+  }
+
+  interface UnharmonizedItemExportType {
+    readonly discriminator: 'unharmonized_item_export_type';
+    readonly sort?: string;
+  }
+}
+
+declare namespace io.flow.RESERVED_WORD_export.v0.unions {
+  type ExportDelivery = io.flow.RESERVED_WORD_export.v0.models.ExportDeliveryEmail;
+  type ExportType =
+    | io.flow.RESERVED_WORD_export.v0.models.AccountTransactionsExportType
+    | io.flow.RESERVED_WORD_export.v0.models.AccountOrdersExportType
+    | io.flow.RESERVED_WORD_export.v0.models.AnalyticsExportType
+    | io.flow.RESERVED_WORD_export.v0.models.CatalogItemExportType
+    | io.flow.RESERVED_WORD_export.v0.models.ExperienceExportType
+    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationOverviewExportType
+    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationHs6ExportType
+    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationHs10ExportType
+    | io.flow.RESERVED_WORD_export.v0.models.UnharmonizedItemExportType
+    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationLandedCostExportType
+    | io.flow.RESERVED_WORD_export.v0.models.OrderExportType
+    | io.flow.RESERVED_WORD_export.v0.models.PriceBookItemExportType
+    | io.flow.RESERVED_WORD_export.v0.models.SolidusProductExportType
+    | io.flow.RESERVED_WORD_export.v0.models.SolidusVariantExportType
+    | io.flow.RESERVED_WORD_export.v0.models.LocalizedItemPricesExportType;
+}
+
+declare namespace io.flow.shopify.internal.v0.enums {
+  type FlowApp = 'console';
+  type ShopifyCheckInventoryErrorCode = 'inventory_out_of_stock';
+  type ShopifyGrantStatus = 'pass' | 'fail';
+  type ShopifyPromotionOfferAllocationMethod = 'each' | 'across';
+  type ShopifyPromotionOrderEntitlementComponent =
+    | 'subtotal'
+    | 'shipping'
+    | 'vat'
+    | 'duty';
+  type ShopifyPromotionStatus = 'active' | 'inactive';
+}
+
+declare namespace io.flow.shopify.internal.v0.models {
+  interface CompletePriceRule {
+    readonly price_rule: io.flow.shopify.external.v0.models.PriceRule;
+    readonly discount_codes: io.flow.shopify.external.v0.models.PriceRuleDiscountCode[];
+  }
+
+  interface InstallForm {
+    readonly token: string;
+  }
+
+  interface OrderSubmissionForm {
+    readonly authorization?: io.flow.payment.v0.unions.AuthorizationForm;
+  }
+
+  interface Shop {
+    readonly id: string;
+    readonly organization?: io.flow.common.v0.models.OrganizationReference;
+    readonly myshopify_domain: string;
+    readonly domain?: string;
+  }
+
+  interface ShopForm {
+    readonly organization_id: string;
+  }
+
+  interface ShopVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly shop: io.flow.shopify.internal.v0.models.Shop;
+  }
+
+  interface ShopifyCheckInventoryError {
+    readonly code: io.flow.shopify.internal.v0.enums.ShopifyCheckInventoryErrorCode;
+    readonly messages: string[];
+    readonly numbers?: string[];
+  }
+
+  interface ShopifyCodeForm {
+    readonly code: string;
+  }
+
+  interface ShopifyExperienceShortId {
+    readonly id: string;
+    readonly experience: io.flow.experience.v0.models.ExperienceReference;
+    readonly short_id: string;
+  }
+
+  interface ShopifyGiftCardBalance {
+    readonly gift_card_id: number;
+    readonly last_characters: string;
+    readonly amount: number;
+    readonly currency: string;
+  }
+
+  interface ShopifyGiftCardBalanceForm {
     readonly number: string;
-    readonly cvc?: string;
   }
 
-  interface SourceKlarna {
-    readonly first_name?: string;
-    readonly last_name?: string;
-    readonly client_token: string;
+  interface ShopifyGiftCardPaymentForm {
+    readonly code: string;
+    readonly customer_id?: number;
   }
 
-  interface SourceKlarnaRequest {
-    readonly first_name: string;
-    readonly last_name: string;
-    readonly attachment?: string;
+  interface ShopifyGiftCardRedemption {
+    readonly adjustment_id: number;
+    readonly gift_card_id: number;
+    readonly last_characters: string;
+    readonly amount: number;
+    readonly currency: string;
   }
 
-  interface SourceRequest {
-    readonly type?: io.flow.stripe.v0.enums.SourceType;
-    readonly amount?: number;
-    readonly card?: io.flow.stripe.v0.models.SourceCardRequest;
-    readonly currency?: string;
-    readonly flow?: io.flow.stripe.v0.enums.SourceFlow;
-    readonly klarna?: io.flow.stripe.v0.models.SourceKlarnaRequest;
-    readonly order?: io.flow.stripe.v0.models.OrderRequest;
-    readonly owner?: io.flow.stripe.v0.models.Owner;
-    readonly receiver?: io.flow.stripe.v0.models.Receiver;
-    readonly redirect?: io.flow.stripe.v0.models.Redirect;
-    readonly statement_descriptor?: string;
-    readonly three_d_secure?: io.flow.stripe.v0.models.ThreeDSecure;
-    readonly token?: string;
-    readonly usage: io.flow.stripe.v0.enums.SourceUsageType;
+  interface ShopifyGiftCardRedemptionForm {
+    readonly number: string;
+    readonly amount: number;
+    readonly currency: string;
   }
 
-  interface Stripe3Ds2Fingerprint {
-    readonly type: io.flow.stripe.v0.enums.UseStripeSdkType;
-    readonly three_d_secure_2_source: string;
-    readonly directory_server_name?: string;
-    readonly server_transaction_id?: string;
-    readonly three_ds_method_url?: string;
-    readonly three_ds_optimizations?: string;
-    readonly directory_server_encryption?: any /*object*/;
+  interface ShopifyGiftCardReversal {
+    readonly adjustment_id: number;
+    readonly gift_card_id: number;
+    readonly last_characters: string;
+    readonly amount: number;
+    readonly currency: string;
   }
 
-  interface StripeError {
-    readonly type: io.flow.stripe.v0.enums.ErrorType;
-    readonly charge?: string;
-    readonly message?: string;
-    readonly code?: io.flow.stripe.v0.enums.CardErrorCode;
-    readonly decline_code?: string;
-    readonly param?: string;
+  interface ShopifyGiftCardReversalForm {
+    readonly number: string;
+    readonly amount: number;
+    readonly currency: string;
   }
 
-  interface StripeEvent {
-    readonly id: string;
-    readonly object: string;
-    readonly api_version?: string;
-    readonly created: number;
-    readonly data: io.flow.stripe.v0.models.StripeEventData;
-    readonly livemode: boolean;
-    readonly pending_webhooks: number;
-    readonly request?: io.flow.stripe.v0.models.StripeEventRequest;
-    readonly type: string;
+  interface ShopifyGrantsCheck {
+    readonly dummy: string;
   }
 
-  interface StripeEventData {
-    readonly object?: any /*object*/;
-    readonly previous_attributes?: any /*object*/;
+  interface ShopifyOrderAuthorization {
+    readonly result: io.flow.payment.v0.models.AuthorizationResult;
+    readonly detail?: io.flow.shopify.internal.v0.models.ShopifyOrderDetail;
+    readonly redirect?: string;
   }
 
-  interface StripeEventRequest {
-    readonly id?: string;
-    readonly idempotency_key?: string;
+  interface ShopifyOrderContent {
+    readonly lines: io.flow.shopify.internal.v0.models.ShopifyOrderLineContent[];
+    readonly discounts: io.flow.shopify.internal.v0.models.ShopifyOrderDiscountContent[];
   }
 
-  interface ThreeDSecure {
-    readonly card: string;
-    readonly customer?: string;
+  interface ShopifyOrderDetail {
+    readonly organization: io.flow.common.v0.models.OrganizationReference;
+    readonly number: string;
+    readonly order: io.flow.experience.v0.models.Order;
+    readonly payments: io.flow.shopify.internal.v0.models.ShopifyPaymentSummary[];
+    readonly contents: io.flow.shopify.internal.v0.models.ShopifyOrderContent;
   }
 
-  interface ThreeDSecureRedirect {
-    readonly type: io.flow.stripe.v0.enums.UseStripeSdkType;
-    readonly stripe_js: string;
+  interface ShopifyOrderDiscountContent {
+    readonly description: string;
+    readonly code?: string;
   }
 
-  interface Token {
-    readonly id: string;
-    readonly object: string;
-    readonly client_ip: string;
-    readonly created: number;
-    readonly livemode: boolean;
-    readonly type: io.flow.stripe.v0.enums.TokenType;
-    readonly used: boolean;
-    readonly card?: io.flow.stripe.v0.models.Card;
+  interface ShopifyOrderInventoryCheck {
+    readonly item_number: string;
+    readonly quantity: number;
   }
 
-  interface TosAcceptance {
-    readonly date?: number;
-    readonly ip?: string;
-    readonly user_agent?: string;
+  interface ShopifyOrderLineAttribute {
+    readonly key: string;
+    readonly name: string;
+    readonly value: string;
   }
 
-  interface TransferData {
-    readonly amount: number;
-    readonly destination?: string;
+  interface ShopifyOrderLineContent {
+    readonly item_number: string;
+    readonly quantity: number;
+    readonly price: io.flow.common.v0.models.PriceWithBase;
+    readonly total: io.flow.common.v0.models.PriceWithBase;
+    readonly name: string;
+    readonly image_url: string;
+    readonly variant_url: string;
+    readonly attributes: io.flow.shopify.internal.v0.models.ShopifyOrderLineAttribute[];
   }
-}
-
-declare namespace io.flow.RESERVED_WORD_export.v0.enums {
-  type ExportStatus = 'created' | 'processing' | 'completed' | 'failed';
-}
 
-declare namespace io.flow.RESERVED_WORD_export.v0.models {
-  interface AccountOrdersExportType {
-    readonly discriminator: 'account_orders_export_type';
-    readonly statement_id?: string;
-    readonly transaction_summary_id?: string;
-    readonly transaction_created_from?: string;
-    readonly transaction_created_to?: string;
-    readonly transaction_created_on_or_after?: string;
-    readonly transaction_created_after?: string;
-    readonly transaction_created_on_or_before?: string;
-    readonly transaction_created_before?: string;
-    readonly transaction_posted_from?: string;
-    readonly transaction_posted_to?: string;
-    readonly transaction_posted_on_or_after?: string;
-    readonly transaction_posted_after?: string;
-    readonly transaction_posted_on_or_before?: string;
-    readonly transaction_posted_before?: string;
+  interface ShopifyPaymentSummary {
+    readonly description: string;
+    readonly address?: io.flow.common.v0.models.Address;
+    readonly contact?: io.flow.common.v0.models.Contact;
   }
 
-  interface AccountTransactionsExportType {
-    readonly discriminator: 'account_transactions_export_type';
-    readonly statement_id?: string;
-    readonly transaction_summary_id?: string;
-    readonly created_from?: string;
-    readonly created_to?: string;
-    readonly created_on_or_after?: string;
-    readonly created_after?: string;
-    readonly created_on_or_before?: string;
-    readonly created_before?: string;
-    readonly posted_from?: string;
-    readonly posted_to?: string;
-    readonly posted_on_or_after?: string;
-    readonly posted_after?: string;
-    readonly posted_on_or_before?: string;
-    readonly posted_before?: string;
+  interface ShopifyPromoForm {
+    readonly name: string;
+    readonly starts_at: string;
+    readonly ends_at?: string;
+    readonly status: io.flow.shopify.internal.v0.enums.ShopifyPromotionStatus;
+    readonly rule: io.flow.shopify.internal.v0.models.ShopifyPromotionRule;
+    readonly stackable_limit?: number;
   }
 
-  interface AnalyticsExportType {
-    readonly discriminator: 'analytics_export_type';
-    readonly from?: string;
-    readonly to?: string;
-    readonly region?: string;
-    readonly interval?: io.flow.common.v0.enums.UnitOfTime;
+  interface ShopifyPromotion {
+    readonly id: string;
+    readonly name: string;
+    readonly starts_at: string;
+    readonly ends_at?: string;
+    readonly status: io.flow.shopify.internal.v0.enums.ShopifyPromotionStatus;
+    readonly rule: io.flow.shopify.internal.v0.models.ShopifyPromotionRule;
+    readonly stackable_limit?: number;
   }
 
-  interface CatalogItemExportType {
-    readonly discriminator: 'catalog_item_export_type';
-    readonly numbers?: string[];
-    readonly q?: string;
-    readonly sort?: string;
+  interface ShopifyPromotionAttributeValue {
+    readonly name: string;
+    readonly discount: io.flow.common.v0.models.Money;
   }
 
-  interface CsvPriceBookItemExportRow {
-    readonly price_book_key: string;
-    readonly price_book_item_key: string;
-    readonly item_number: string;
-    readonly item_name: string;
+  interface ShopifyPromotionFixedAmount {
+    readonly discriminator: 'shopify_promotion_fixed_amount';
     readonly amount: number;
-    readonly item_attributes?: Record<string, string>;
-    readonly starts_at: string;
-    readonly ends_at?: string;
+    readonly currency: string;
   }
 
-  interface ExperienceExportType {
-    readonly discriminator: 'experience_export_type';
-    readonly organization_id: string;
-    readonly ids?: string[];
-    readonly keys?: string[];
+  interface ShopifyPromotionForm {
+    readonly code: string;
   }
 
-  interface Export {
-    readonly id: string;
-    readonly type: io.flow.RESERVED_WORD_export.v0.unions.ExportType;
-    readonly status: io.flow.RESERVED_WORD_export.v0.enums.ExportStatus;
-    readonly organization_q: string;
-    readonly created_at: string;
-    readonly started_at?: string;
-    readonly completed_at?: string;
-    readonly url?: string;
-    readonly deliveries: io.flow.RESERVED_WORD_export.v0.unions.ExportDelivery[];
+  interface ShopifyPromotionItemEntitlement {
+    readonly discriminator: 'shopify_promotion_item_entitlement';
+    readonly q: string;
+    readonly allocation_method: io.flow.shopify.internal.v0.enums.ShopifyPromotionOfferAllocationMethod;
+  }
+
+  interface ShopifyPromotionItemPrerequisite {
+    readonly discriminator: 'shopify_promotion_item_prerequisite';
+    readonly q: string;
+    readonly at_least?: number;
+    readonly at_most?: number;
+    readonly exclude_from_offer?: boolean;
+  }
+
+  interface ShopifyPromotionMaxAmount {
+    readonly discriminator: 'shopify_promotion_max_amount';
+    readonly amount: number;
+    readonly currency: string;
   }
 
-  interface ExportDeliveryEmail {
-    readonly discriminator: 'export_delivery_email';
-    readonly email: string;
+  interface ShopifyPromotionMaxLimit {
+    readonly discriminator: 'shopify_promotion_max_limit';
+    readonly limit: number;
   }
 
-  interface ExportForm {
-    readonly type: io.flow.RESERVED_WORD_export.v0.unions.ExportType;
-    readonly emails?: string[];
-    readonly organization_q?: string;
+  interface ShopifyPromotionOffer {
+    readonly discount: io.flow.shopify.internal.v0.unions.ShopifyPromotionOfferDiscount;
+    readonly entitlement: io.flow.shopify.internal.v0.unions.ShopifyPromotionOfferEntitlement;
+    readonly max?: io.flow.shopify.internal.v0.unions.ShopifyPromotionOfferMax[];
   }
 
-  interface ExportLocalizedItemPrices {
-    readonly organization: io.flow.common.v0.models.OrganizationReference;
-    readonly experience: io.flow.experience.v0.models.ExperienceReference;
-    readonly item: io.flow.common.v0.models.CatalogItemReference;
-    readonly prices: io.flow.RESERVED_WORD_export.v0.models.ExportLocalizedItemPricesDetail;
-    readonly status?: io.flow.catalog.v0.enums.SubcatalogItemStatus;
+  interface ShopifyPromotionOrderEntitlement {
+    readonly discriminator: 'shopify_promotion_order_entitlement';
+    readonly components: io.flow.shopify.internal.v0.enums.ShopifyPromotionOrderEntitlementComponent[];
+    readonly allocation_method: io.flow.shopify.internal.v0.enums.ShopifyPromotionOfferAllocationMethod;
   }
 
-  interface ExportLocalizedItemPricesDetail {
-    readonly item: io.flow.catalog.v0.models.LocalizedItemPrice;
-    readonly vat?: io.flow.catalog.v0.models.LocalizedItemVat;
-    readonly duty?: io.flow.catalog.v0.models.LocalizedItemDuty;
-    readonly price_attributes: Record<
-      string,
-      io.flow.common.v0.models.PriceWithBase
-    >;
+  interface ShopifyPromotionOrderPrerequisite {
+    readonly discriminator: 'shopify_promotion_order_prerequisite';
+    readonly q: string;
   }
 
-  interface ExportVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly export: io.flow.RESERVED_WORD_export.v0.models.Export;
+  interface ShopifyPromotionPercent {
+    readonly discriminator: 'shopify_promotion_percent';
+    readonly percent: number;
   }
 
-  interface HarmonizationHs10ExportType {
-    readonly discriminator: 'harmonization_hs10_export_type';
-    readonly origin?: string;
-    readonly destination?: string;
-    readonly numbers?: string[];
-    readonly has_codes?: boolean;
-    readonly has_origins?: boolean;
-    readonly sort?: string;
+  interface ShopifyPromotionRule {
+    readonly prerequisites: io.flow.shopify.internal.v0.unions.ShopifyPromotionPrerequisite[];
+    readonly offers: io.flow.shopify.internal.v0.models.ShopifyPromotionOffer[];
   }
 
-  interface HarmonizationHs6ExportType {
-    readonly discriminator: 'harmonization_hs6_export_type';
-    readonly numbers?: string[];
-    readonly has_codes?: boolean;
-    readonly sort?: string;
+  interface ShopifyWebhook {
+    readonly id: string;
+    readonly shop_id: string;
+    readonly address: string;
+    readonly topic: io.flow.shopify.external.v0.enums.Topic;
   }
 
-  interface HarmonizationLandedCostExportType {
-    readonly discriminator: 'harmonization_landed_cost_export_type';
-    readonly items: io.flow.RESERVED_WORD_export.v0.models.LandedCostItem[];
+  interface ShopifyWebhookEvent {
+    readonly dummy: string;
   }
 
-  interface HarmonizationOverviewExportType {
-    readonly discriminator: 'harmonization_overview_export_type';
-    readonly origin?: string;
-    readonly destination?: string;
-    readonly sort?: string;
+  interface ShopifyWebhookForm {
+    readonly myshopify_domain: string;
+    readonly address: string;
+    readonly topic: io.flow.shopify.external.v0.enums.Topic;
   }
+}
 
-  interface LandedCostItem {
-    readonly number: string;
-    readonly origin: string;
-    readonly destination: string;
-  }
+declare namespace io.flow.shopify.internal.v0.unions {
+  type ShopifyPromotionOfferDiscount =
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionFixedAmount
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionPercent;
+  type ShopifyPromotionOfferEntitlement =
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionItemEntitlement
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionOrderEntitlement;
+  type ShopifyPromotionOfferMax =
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionMaxLimit
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionMaxAmount;
+  type ShopifyPromotionPrerequisite =
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionItemPrerequisite
+    | io.flow.shopify.internal.v0.models.ShopifyPromotionOrderPrerequisite;
+}
 
-  interface LocalizedItemPricesExportType {
-    readonly discriminator: 'localized_item_prices_export_type';
-    readonly since?: string;
+declare namespace io.flow.ftp.v0.enums {
+  type FtpFileSource = 'flow' | 'organization';
+}
+
+declare namespace io.flow.ftp.v0.models {
+  interface FtpAccount {
+    readonly server: io.flow.ftp.v0.models.FtpServer;
+    readonly user: io.flow.ftp.v0.models.FtpUser;
   }
 
-  interface OrderExportType {
-    readonly discriminator: 'order_export_type';
-    readonly numbers?: string[];
-    readonly min_hours_since_submitted_at?: number;
-    readonly submitted_on_or_before?: string;
-    readonly submitted_on_or_after?: string;
-    readonly status?: io.flow.experience.v0.enums.OrderStatus;
-    readonly has_tracking_label?: boolean;
-    readonly sort?: string;
+  interface FtpFile {
+    readonly id: string;
+    readonly source: io.flow.ftp.v0.enums.FtpFileSource;
+    readonly name: string;
+    readonly directory: string;
+    readonly url: string;
+    readonly created_at: string;
   }
 
-  interface PriceBookItemExportType {
-    readonly discriminator: 'price_book_item_export_type';
-    readonly price_book_key?: string;
-    readonly item_numbers?: string[];
-    readonly start_date?: string;
-    readonly end_date?: string;
+  interface FtpFileForm {
+    readonly url: string;
+    readonly directory: string;
+    readonly name?: string;
   }
 
-  interface ScheduledExport {
+  interface FtpFolder {
     readonly id: string;
-    readonly user: io.flow.common.v0.models.UserReference;
-    readonly organization_q: string;
-    readonly hour: number;
-    readonly minute: number;
-    readonly timezone: string;
-    readonly types: io.flow.RESERVED_WORD_export.v0.unions.ExportType[];
-    readonly last_sent_at?: string;
+    readonly path: string;
+    readonly webhook: boolean;
+    readonly description?: string;
   }
 
-  interface ScheduledExportForm {
-    readonly user_id: string;
-    readonly organization_q: string;
-    readonly hour: number;
-    readonly minute: number;
-    readonly timezone: string;
-    readonly types: io.flow.RESERVED_WORD_export.v0.unions.ExportType[];
+  interface FtpFolderForm {
+    readonly path: string;
+    readonly webhook: boolean;
+    readonly description?: string;
   }
 
-  interface SolidusProductExportType {
-    readonly discriminator: 'solidus_product_export_type';
-    readonly numbers?: string[];
-    readonly sort?: string;
+  interface FtpOrganizationSettings {
+    readonly enabled: boolean;
+    readonly emails: string[];
+    readonly account?: io.flow.ftp.v0.models.FtpAccount;
   }
 
-  interface SolidusVariantExportType {
-    readonly discriminator: 'solidus_variant_export_type';
-    readonly numbers?: string[];
-    readonly sort?: string;
+  interface FtpOrganizationSettingsForm {
+    readonly enabled: boolean;
+    readonly emails: string[];
   }
 
-  interface UnharmonizedItemExportType {
-    readonly discriminator: 'unharmonized_item_export_type';
-    readonly sort?: string;
+  interface FtpServer {
+    readonly hostname: string;
   }
-}
 
-declare namespace io.flow.RESERVED_WORD_export.v0.unions {
-  type ExportDelivery = io.flow.RESERVED_WORD_export.v0.models.ExportDeliveryEmail;
-  type ExportType =
-    | io.flow.RESERVED_WORD_export.v0.models.AccountTransactionsExportType
-    | io.flow.RESERVED_WORD_export.v0.models.AccountOrdersExportType
-    | io.flow.RESERVED_WORD_export.v0.models.AnalyticsExportType
-    | io.flow.RESERVED_WORD_export.v0.models.CatalogItemExportType
-    | io.flow.RESERVED_WORD_export.v0.models.ExperienceExportType
-    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationOverviewExportType
-    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationHs6ExportType
-    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationHs10ExportType
-    | io.flow.RESERVED_WORD_export.v0.models.UnharmonizedItemExportType
-    | io.flow.RESERVED_WORD_export.v0.models.HarmonizationLandedCostExportType
-    | io.flow.RESERVED_WORD_export.v0.models.OrderExportType
-    | io.flow.RESERVED_WORD_export.v0.models.PriceBookItemExportType
-    | io.flow.RESERVED_WORD_export.v0.models.SolidusProductExportType
-    | io.flow.RESERVED_WORD_export.v0.models.SolidusVariantExportType
-    | io.flow.RESERVED_WORD_export.v0.models.LocalizedItemPricesExportType;
+  interface FtpUser {
+    readonly username: string;
+    readonly password?: string;
+  }
 }
 
-declare namespace io.flow.shopify.internal.v0.enums {
-  type FlowApp = 'console';
-  type ShopifyCheckInventoryErrorCode = 'inventory_out_of_stock';
-  type ShopifyGrantStatus = 'pass' | 'fail';
-  type ShopifyPromotionOfferAllocationMethod = 'each' | 'across';
-  type ShopifyPromotionOrderEntitlementComponent =
-    | 'subtotal'
-    | 'shipping'
-    | 'vat'
-    | 'duty';
-  type ShopifyPromotionStatus = 'active' | 'inactive';
+declare namespace io.flow.checkout.configuration.v0.enums {
+  type CheckoutPromptBehavior = 'always' | 'incomplete';
+  type CheckoutShippingMethodPromptBehavior = 'always' | 'multiple';
+  type GoogleAnalyticsPlugin = 'ec';
 }
 
-declare namespace io.flow.shopify.internal.v0.models {
-  interface CompletePriceRule {
-    readonly price_rule: io.flow.shopify.external.v0.models.PriceRule;
-    readonly discount_codes: io.flow.shopify.external.v0.models.PriceRuleDiscountCode[];
+declare namespace io.flow.checkout.configuration.v0.models {
+  interface CheckoutAnalytics {
+    readonly trackers: io.flow.checkout.configuration.v0.unions.Tracker[];
+    readonly use_base_currency: boolean;
   }
 
-  interface InstallForm {
-    readonly token: string;
+  interface CheckoutBehavior {
+    readonly shipping_address: io.flow.checkout.configuration.v0.models.CheckoutBehaviorShippingAddress;
+    readonly shipping_method: io.flow.checkout.configuration.v0.models.CheckoutBehaviorShippingMethod;
+    readonly customer_info: io.flow.checkout.configuration.v0.models.CheckoutBehaviorCustomerInfo;
   }
 
-  interface OrderSubmissionForm {
-    readonly authorization?: io.flow.payment.v0.unions.AuthorizationForm;
+  interface CheckoutBehaviorCustomerInfo {
+    readonly email: io.flow.checkout.configuration.v0.models.CheckoutBehaviorCustomerInfoEmail;
   }
 
-  interface Shop {
-    readonly id: string;
-    readonly organization?: io.flow.common.v0.models.OrganizationReference;
-    readonly myshopify_domain: string;
-    readonly domain?: string;
+  interface CheckoutBehaviorCustomerInfoEmail {
+    readonly prompt: io.flow.checkout.configuration.v0.enums.CheckoutPromptBehavior;
   }
 
-  interface ShopForm {
-    readonly organization_id: string;
+  interface CheckoutBehaviorShippingAddress {
+    readonly prompt: io.flow.checkout.configuration.v0.enums.CheckoutPromptBehavior;
   }
 
-  interface ShopVersion {
+  interface CheckoutBehaviorShippingMethod {
+    readonly prompt: io.flow.checkout.configuration.v0.enums.CheckoutShippingMethodPromptBehavior;
+  }
+
+  interface CheckoutConfiguration {
     readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly shop: io.flow.shopify.internal.v0.models.Shop;
+    readonly behavior: io.flow.checkout.configuration.v0.models.CheckoutBehavior;
+    readonly settings: io.flow.checkout.configuration.v0.models.CheckoutSettings;
+    readonly analytics?: io.flow.checkout.configuration.v0.models.CheckoutAnalytics;
+    readonly domain?: string;
   }
 
-  interface ShopifyCheckInventoryError {
-    readonly code: io.flow.shopify.internal.v0.enums.ShopifyCheckInventoryErrorCode;
-    readonly messages: string[];
-    readonly numbers?: string[];
+  interface CheckoutConfigurationReference {
+    readonly id: string;
+  }
+
+  interface CheckoutSettings {
+    readonly session_persistence_timeout?: io.flow.common.v0.models.Duration;
+    readonly session_persistence_attribute_keys?: string[];
   }
 
-  interface ShopifyCodeForm {
-    readonly code: string;
+  interface FacebookPixel {
+    readonly discriminator: 'facebook_pixel';
+    readonly name?: string;
+    readonly tracker_id: string;
   }
 
-  interface ShopifyExperienceShortId {
-    readonly id: string;
-    readonly experience: io.flow.experience.v0.models.ExperienceReference;
-    readonly short_id: string;
+  interface GoogleAnalytics {
+    readonly discriminator: 'google_analytics';
+    readonly name?: string;
+    readonly tracker_id: string;
+    readonly plugins: io.flow.checkout.configuration.v0.enums.GoogleAnalyticsPlugin[];
   }
 
-  interface ShopifyGiftCardBalance {
-    readonly gift_card_id: number;
-    readonly last_characters: string;
-    readonly amount: number;
-    readonly currency: string;
+  interface GoogleGlobalSiteTag {
+    readonly discriminator: 'google_global_site_tag';
+    readonly name?: string;
+    readonly tracker_id: string;
   }
 
-  interface ShopifyGiftCardBalanceForm {
-    readonly number: string;
+  interface SnapchatPixel {
+    readonly discriminator: 'snapchat_pixel';
+    readonly name?: string;
+    readonly tracker_id: string;
   }
+}
 
-  interface ShopifyGiftCardPaymentForm {
-    readonly code: string;
-    readonly customer_id?: number;
-  }
+declare namespace io.flow.checkout.configuration.v0.unions {
+  type Tracker =
+    | io.flow.checkout.configuration.v0.models.GoogleAnalytics
+    | io.flow.checkout.configuration.v0.models.GoogleGlobalSiteTag
+    | io.flow.checkout.configuration.v0.models.FacebookPixel
+    | io.flow.checkout.configuration.v0.models.SnapchatPixel;
+}
 
-  interface ShopifyGiftCardRedemption {
-    readonly adjustment_id: number;
-    readonly gift_card_id: number;
-    readonly last_characters: string;
-    readonly amount: number;
-    readonly currency: string;
+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 ShopifyGiftCardRedemptionForm {
-    readonly number: string;
-    readonly amount: number;
-    readonly currency: string;
+  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 ShopifyGiftCardReversal {
-    readonly adjustment_id: number;
-    readonly gift_card_id: number;
-    readonly last_characters: string;
-    readonly amount: number;
-    readonly currency: string;
+  interface CartonPickDeliveryDetails {
+    readonly shipment_uuid?: string;
+    readonly carrier?: string;
+    readonly carrier_id?: string;
   }
 
-  interface ShopifyGiftCardReversalForm {
-    readonly number: string;
-    readonly amount: number;
-    readonly currency: 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 ShopifyGrantsCheck {
-    readonly dummy: string;
+  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 ShopifyOrderAuthorization {
-    readonly result: io.flow.payment.v0.models.AuthorizationResult;
-    readonly detail?: io.flow.shopify.internal.v0.models.ShopifyOrderDetail;
-    readonly redirect?: string;
+  interface Error {
+    readonly url: string;
+    readonly client_request_id: string;
+    readonly generated_at: string;
+    readonly error: string;
   }
 
-  interface ShopifyOrderContent {
-    readonly lines: io.flow.shopify.internal.v0.models.ShopifyOrderLineContent[];
-    readonly discounts: io.flow.shopify.internal.v0.models.ShopifyOrderDiscountContent[];
+  interface FlexeAttachment {
+    readonly type: io.flow.flexe.v0.enums.FlexeAttachmentType;
+    readonly display_name: string;
+    readonly url: string;
   }
 
-  interface ShopifyOrderDetail {
-    readonly organization: io.flow.common.v0.models.OrganizationReference;
-    readonly number: string;
-    readonly order: io.flow.experience.v0.models.Order;
-    readonly payments: io.flow.shopify.internal.v0.models.ShopifyPaymentSummary[];
-    readonly contents: io.flow.shopify.internal.v0.models.ShopifyOrderContent;
+  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 ShopifyOrderDiscountContent {
-    readonly description: string;
-    readonly code?: string;
+  interface FlexeEcommerceFulfillmentData {
+    readonly import_id: string;
+    readonly succeeded_uuids: string[];
+    readonly failed_uuids: string[];
+    readonly errors: string[];
   }
 
-  interface ShopifyOrderInventoryCheck {
-    readonly item_number: string;
-    readonly quantity: number;
+  interface FlexeEcommerceFulfillmentErrors {
+    readonly status: string;
+    readonly title: string;
+    readonly detail: string;
+    readonly source?: string;
   }
 
-  interface ShopifyOrderLineAttribute {
-    readonly key: string;
-    readonly name: string;
-    readonly value: string;
+  interface FlexeEcommerceFulfillmentForm {
+    readonly reservation_id: number;
+    readonly client_request_id: string;
+    readonly request: io.flow.flexe.v0.models.Orders;
   }
 
-  interface ShopifyOrderLineContent {
-    readonly item_number: string;
-    readonly quantity: number;
-    readonly price: io.flow.common.v0.models.PriceWithBase;
-    readonly total: io.flow.common.v0.models.PriceWithBase;
-    readonly name: string;
-    readonly image_url: string;
-    readonly variant_url: string;
-    readonly attributes: io.flow.shopify.internal.v0.models.ShopifyOrderLineAttribute[];
+  interface FlexeInventoryData {
+    readonly sku: string;
+    readonly quantity: string;
+    readonly unit: string;
   }
 
-  interface ShopifyPaymentSummary {
-    readonly description: string;
-    readonly address?: io.flow.common.v0.models.Address;
-    readonly contact?: io.flow.common.v0.models.Contact;
+  interface FlexeRetailAttachment {
+    readonly display_name: string;
+    readonly url: string;
   }
 
-  interface ShopifyPromoForm {
-    readonly name: string;
-    readonly starts_at: string;
-    readonly ends_at?: string;
-    readonly status: io.flow.shopify.internal.v0.enums.ShopifyPromotionStatus;
-    readonly rule: io.flow.shopify.internal.v0.models.ShopifyPromotionRule;
-    readonly stackable_limit?: number;
+  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 ShopifyPromotion {
+  interface FlexeRetailFulfillmentData {
     readonly id: string;
-    readonly name: string;
-    readonly starts_at: string;
-    readonly ends_at?: string;
-    readonly status: io.flow.shopify.internal.v0.enums.ShopifyPromotionStatus;
-    readonly rule: io.flow.shopify.internal.v0.models.ShopifyPromotionRule;
-    readonly stackable_limit?: number;
+    readonly purchase_order_uuid: string;
+    readonly status: string;
   }
 
-  interface ShopifyPromotionAttributeValue {
-    readonly name: string;
-    readonly discount: io.flow.common.v0.models.Money;
+  interface FlexeRetailFulfillmentErrors {
+    readonly type: string;
+    readonly message: string;
   }
 
-  interface ShopifyPromotionFixedAmount {
-    readonly discriminator: 'shopify_promotion_fixed_amount';
-    readonly amount: number;
-    readonly currency: string;
+  interface FlexeRetailFulfillmentForm {
+    readonly reservation_id: number;
+    readonly client_request_id?: string;
+    readonly request: io.flow.flexe.v0.models.RetailOrder;
   }
 
-  interface ShopifyPromotionForm {
-    readonly code: string;
+  interface FulfillmentOrderDetails {
+    readonly shipment_uuid: string;
+    readonly carrier?: string;
+    readonly carrier_id?: string;
   }
 
-  interface ShopifyPromotionItemEntitlement {
-    readonly discriminator: 'shopify_promotion_item_entitlement';
-    readonly q: string;
-    readonly allocation_method: io.flow.shopify.internal.v0.enums.ShopifyPromotionOfferAllocationMethod;
+  interface Gs1Us {
+    readonly number: string;
+    readonly ship_to?: io.flow.flexe.v0.models.Gs1UsShipTo;
+    readonly bill_to?: io.flow.flexe.v0.models.BillTo;
   }
 
-  interface ShopifyPromotionItemPrerequisite {
-    readonly discriminator: 'shopify_promotion_item_prerequisite';
-    readonly q: string;
-    readonly at_least?: number;
-    readonly at_most?: number;
-    readonly exclude_from_offer?: boolean;
+  interface Gs1UsShipTo {
+    readonly cid_number?: string;
+    readonly location_number?: string;
+    readonly free_on_board?: boolean;
   }
 
-  interface ShopifyPromotionMaxAmount {
-    readonly discriminator: 'shopify_promotion_max_amount';
-    readonly amount: number;
-    readonly currency: 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 ShopifyPromotionMaxLimit {
-    readonly discriminator: 'shopify_promotion_max_limit';
-    readonly limit: number;
+  interface InventoryCount {
+    readonly amount: number;
+    readonly unit: string;
   }
 
-  interface ShopifyPromotionOffer {
-    readonly discount: io.flow.shopify.internal.v0.unions.ShopifyPromotionOfferDiscount;
-    readonly entitlement: io.flow.shopify.internal.v0.unions.ShopifyPromotionOfferEntitlement;
-    readonly max?: io.flow.shopify.internal.v0.unions.ShopifyPromotionOfferMax[];
+  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 ShopifyPromotionOrderEntitlement {
-    readonly discriminator: 'shopify_promotion_order_entitlement';
-    readonly components: io.flow.shopify.internal.v0.enums.ShopifyPromotionOrderEntitlementComponent[];
-    readonly allocation_method: io.flow.shopify.internal.v0.enums.ShopifyPromotionOfferAllocationMethod;
+  interface InventoryDetails {
+    readonly key: Record<string, io.flow.flexe.v0.models.Sku>;
   }
 
-  interface ShopifyPromotionOrderPrerequisite {
-    readonly discriminator: 'shopify_promotion_order_prerequisite';
-    readonly q: string;
+  interface LadingQuantity {
+    readonly num_pallets: number;
   }
 
-  interface ShopifyPromotionPercent {
-    readonly discriminator: 'shopify_promotion_percent';
-    readonly percent: number;
+  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 ShopifyPromotionRule {
-    readonly prerequisites: io.flow.shopify.internal.v0.unions.ShopifyPromotionPrerequisite[];
-    readonly offers: io.flow.shopify.internal.v0.models.ShopifyPromotionOffer[];
+  interface Orders {
+    readonly orders: io.flow.flexe.v0.models.Order[];
   }
 
-  interface ShopifyWebhook {
-    readonly id: string;
-    readonly shop_id: string;
-    readonly address: string;
-    readonly topic: io.flow.shopify.external.v0.enums.Topic;
+  interface Pallet {
+    readonly pallet_id: string;
+    readonly sku: string;
+    readonly quantity: number;
+    readonly packaging: string;
   }
 
-  interface ShopifyWebhookEvent {
-    readonly dummy: 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 ShopifyWebhookForm {
-    readonly myshopify_domain: string;
-    readonly address: string;
-    readonly topic: io.flow.shopify.external.v0.enums.Topic;
+  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.shopify.internal.v0.unions {
-  type ShopifyPromotionOfferDiscount =
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionFixedAmount
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionPercent;
-  type ShopifyPromotionOfferEntitlement =
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionItemEntitlement
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionOrderEntitlement;
-  type ShopifyPromotionOfferMax =
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionMaxLimit
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionMaxAmount;
-  type ShopifyPromotionPrerequisite =
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionItemPrerequisite
-    | io.flow.shopify.internal.v0.models.ShopifyPromotionOrderPrerequisite;
-}
+  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.ftp.v0.enums {
-  type FtpFileSource = 'flow' | 'organization';
-}
+  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.ftp.v0.models {
-  interface FtpAccount {
-    readonly server: io.flow.ftp.v0.models.FtpServer;
-    readonly user: io.flow.ftp.v0.models.FtpUser;
+  interface RetailInventoryData {
+    readonly sku: string;
+    readonly quantity: number;
+    readonly unit: string;
+    readonly attachments?: io.flow.flexe.v0.models.FlexeRetailAttachment[];
   }
 
-  interface FtpFile {
-    readonly id: string;
-    readonly source: io.flow.ftp.v0.enums.FtpFileSource;
-    readonly name: string;
-    readonly directory: string;
-    readonly url: string;
-    readonly created_at: string;
+  interface RetailOrder {
+    readonly order: io.flow.flexe.v0.models.RetailOrderData;
   }
 
-  interface FtpFileForm {
-    readonly url: string;
-    readonly directory: string;
-    readonly name?: string;
+  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 FtpFolder {
-    readonly id: string;
-    readonly path: string;
-    readonly webhook: boolean;
-    readonly description?: 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 FtpFolderForm {
-    readonly path: string;
-    readonly webhook: boolean;
-    readonly description?: string;
+  interface ShipWithin {
+    readonly start: string;
+    readonly end: string;
   }
 
-  interface FtpOrganizationSettings {
-    readonly enabled: boolean;
-    readonly emails: string[];
-    readonly account?: io.flow.ftp.v0.models.FtpAccount;
+  interface ShipmentDeliveryDetails {
+    readonly shipment_uuid?: string;
   }
 
-  interface FtpOrganizationSettingsForm {
-    readonly enabled: boolean;
-    readonly emails: 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 FtpServer {
-    readonly hostname: string;
+  interface Sku {
+    readonly sku: string;
+    readonly description: string;
+    readonly summary: Record<string, io.flow.flexe.v0.models.SkuSummary>;
   }
 
-  interface FtpUser {
-    readonly username: string;
-    readonly password?: string;
+  interface SkuSummary {
+    readonly key: string;
+    readonly quantity: number;
+    readonly unit: string;
   }
 }
 
@@ -11398,6 +11520,12 @@ declare namespace io.flow.adyen.v0.models {
     readonly 'threeds2.threeDS2ResponseData.messageVersion': string;
   }
 
+  interface ChargebackNotificationAdditionalData {
+    readonly chargebackReasonCode: string;
+    readonly modificationMerchantReferences: string;
+    readonly chargebackSchemeCode: string;
+  }
+
   interface Error {
     readonly status: number;
     readonly errorCode: string;
@@ -11527,6 +11655,12 @@ declare namespace io.flow.adyen.v0.models {
     readonly MD?: string;
   }
 
+  interface RequestForInformationAdditionalData {
+    readonly rfiSchemeCode: string;
+    readonly modificationMerchantReferences: string;
+    readonly rfiReasonCode: string;
+  }
+
   interface Scheme {
     readonly type: 'scheme';
     readonly expiryMonth: string;
@@ -12671,6 +12805,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 +12973,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 +13089,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 +13127,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 {
@@ -13378,6 +13515,11 @@ declare namespace io.flow.internal.v0.models {
     readonly number: string;
   }
 
+  interface AllowedLabels {
+    readonly name: string;
+    readonly labels: Record<string, string[]>;
+  }
+
   interface ApmContent {
     readonly processor_description: io.flow.internal.v0.unions.ContentItem;
   }
@@ -13398,6 +13540,11 @@ declare namespace io.flow.internal.v0.models {
     readonly transactionId: string;
   }
 
+  interface AttributeLabel {
+    readonly value: string;
+    readonly estimated: boolean;
+  }
+
   interface AuthenticationForm {
     readonly password: string;
   }
@@ -13916,7 +14063,7 @@ declare namespace io.flow.internal.v0.models {
     readonly optins: io.flow.optin.internal.v0.models.OptinPrompt[];
     readonly addresses: io.flow.experience.v0.models.AddressConfiguration[];
     readonly features: io.flow.feature.v0.models.FeatureValueResult;
-    readonly configuration: unknown /*io.flow.checkout.configuration.v0.models.checkout_configuration*/;
+    readonly configuration: io.flow.checkout.configuration.v0.models.CheckoutConfiguration;
     readonly cart?: io.flow.shopify.v0.models.ShopifyCart;
     readonly customer?: io.flow.customer.v0.models.Customer;
     readonly address_book?: io.flow.customer.v0.models.CustomerAddressBook;
@@ -13964,7 +14111,7 @@ declare namespace io.flow.internal.v0.models {
     readonly provinces: io.flow.reference.v0.models.Province[];
     readonly checkout_items: io.flow.experience.v0.models.CheckoutItemContent[];
     readonly metadata?: io.flow.internal.v0.models.CheckoutBundleMetadata;
-    readonly configuration?: unknown /*io.flow.checkout.configuration.v0.models.checkout_configuration*/;
+    readonly configuration?: io.flow.checkout.configuration.v0.models.CheckoutConfiguration;
     readonly address_configurations?: io.flow.experience.v0.models.AddressConfiguration[];
     readonly customer?: io.flow.customer.v0.models.Customer;
     readonly address_book?: io.flow.customer.v0.models.CustomerAddressBook;
@@ -13989,7 +14136,7 @@ declare namespace io.flow.internal.v0.models {
     readonly event_id: string;
     readonly timestamp: string;
     readonly organization: string;
-    readonly checkout_configuration: unknown /*io.flow.checkout.configuration.v0.models.checkout_configuration*/;
+    readonly checkout_configuration: io.flow.checkout.configuration.v0.models.CheckoutConfiguration;
   }
 
   interface CheckoutConfigurationReference {
@@ -14001,7 +14148,7 @@ declare namespace io.flow.internal.v0.models {
     readonly event_id: string;
     readonly timestamp: string;
     readonly organization: string;
-    readonly checkout_configuration: unknown /*io.flow.checkout.configuration.v0.models.checkout_configuration*/;
+    readonly checkout_configuration: io.flow.checkout.configuration.v0.models.CheckoutConfiguration;
   }
 
   interface CheckoutContent {
@@ -14660,9 +14807,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 +14868,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;
@@ -15669,6 +15825,18 @@ declare namespace io.flow.internal.v0.models {
     readonly value: string;
   }
 
+  interface LabelAliases {
+    readonly name: string;
+    readonly aliases: string[];
+  }
+
+  interface LabelAssociation {
+    readonly items: Record<string, string[]>;
+    readonly genders: Record<string, string[]>;
+    readonly materials: Record<string, string[]>;
+    readonly constructions: Record<string, string[]>;
+  }
+
   interface LabelSummary {
     readonly commercial_invoice?: string;
     readonly pdf?: string;
@@ -15679,6 +15847,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[];
@@ -17020,6 +17196,11 @@ declare namespace io.flow.internal.v0.models {
     readonly withholdings: io.flow.internal.v0.models.Components;
     readonly parent_transaction_id?: string;
     readonly order?: io.flow.internal.v0.models.BillingOrderSummary;
+    readonly spot_rate: number;
+    readonly flow_rate: number;
+    readonly organization_rate: number;
+    readonly flow_margin: number;
+    readonly organization_margin: number;
   }
 
   interface ProcessingTransactionDeleted {
@@ -17038,6 +17219,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 +17253,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 +18115,11 @@ declare namespace io.flow.internal.v0.models {
     readonly period: io.flow.common.v0.models.DatetimeRange;
   }
 
+  interface SupportedLabels {
+    readonly discriminator: 'supported_labels';
+    readonly values: io.flow.internal.v0.models.LabelAliases[];
+  }
+
   interface SvbVirtualCardClearing {
     readonly id: string;
     readonly virtual_card_id: string;
@@ -18178,7 +18403,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 +18503,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
@@ -18570,7 +18803,6 @@ declare namespace io.flow.internal.v0.unions {
     | io.flow.internal.v0.models.ExperienceVariant
     | io.flow.internal.v0.models.FeatureVariant;
   type VariantForm =
-    | io.flow.internal.v0.models.ExperienceVariant
     | io.flow.internal.v0.models.ExperienceVariantForm
     | io.flow.internal.v0.models.FeatureVariantForm;
 }
@@ -18624,9 +18856,11 @@ export type AlertFailureSummaryDetail = io.flow.internal.v0.models.AlertFailureS
 export type AlertRequeueSummary = io.flow.internal.v0.models.AlertRequeueSummary;
 export type AllItemsExport = io.flow.internal.v0.models.AllItemsExport;
 export type AllocationItemReference = io.flow.internal.v0.models.AllocationItemReference;
+export type AllowedLabels = io.flow.internal.v0.models.AllowedLabels;
 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 +18992,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 +19061,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 +19079,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;
@@ -19015,8 +19253,11 @@ export type ItemsShipped = io.flow.internal.v0.models.ItemsShipped;
 export type Key = io.flow.internal.v0.models.Key;
 export type KeyReference = io.flow.internal.v0.models.KeyReference;
 export type Label = io.flow.internal.v0.models.Label;
+export type LabelAliases = io.flow.internal.v0.models.LabelAliases;
+export type LabelAssociation = io.flow.internal.v0.models.LabelAssociation;
 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 +19479,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 +19634,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 +19679,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;