@flowio/types 11.24.105 → 11.24.107

package/src/api.ts

@@ -339,6 +339,15 @@ declare namespace io.flow.stripe.v0.enums {
     | 'under_review'
     | 'won'
     | 'lost';
+  type EarlyFraudWarningEventType = 'radar.early_fraud_warning';
+  type EarlyFraudWarningType =
+    | 'card_never_received'
+    | 'fraudulent_card_application'
+    | 'made_with_counterfeit_card'
+    | 'made_with_lost_card'
+    | 'made_with_stolen_card'
+    | 'unauthorized_use_of_card'
+    | 'misc';
   type ErrorCode =
     | 'invalid_number'
     | 'invalid_expiry_month'
@@ -1626,6 +1635,17 @@ declare namespace io.flow.stripe.v0.models {
     readonly previous_attributes?: any /*object*/;
   }
 
+  interface StripeEarlyFraudWarningEvent {
+    readonly id: string;
+    readonly object: io.flow.stripe.v0.enums.EarlyFraudWarningEventType;
+    readonly actionable: boolean;
+    readonly charge: string;
+    readonly created: number;
+    readonly fraud_type: io.flow.stripe.v0.enums.EarlyFraudWarningType;
+    readonly livemode: boolean;
+    readonly payment_intent?: string;
+  }
+
   interface StripeError {
     readonly type: io.flow.stripe.v0.enums.ErrorType;
     readonly charge?: string;
@@ -2851,138 +2871,2586 @@ declare namespace io.flow.shopify.external.v0.models {
   }
 }
 
-declare namespace io.flow.error.v0.enums {
-  type GenericErrorCode = 'generic_error' | 'client_error' | 'server_error';
+declare namespace io.flow.order.price.v0.enums {
+  type OrderPriceDetailComponentKey =
+    | 'adjustment'
+    | 'vat_deminimis'
+    | 'duty_deminimis'
+    | 'duties_item_price'
+    | 'duties_freight'
+    | 'duties_insurance'
+    | 'vat_item_price'
+    | 'vat_freight'
+    | 'vat_insurance'
+    | 'vat_duties_item_price'
+    | 'vat_duties_freight'
+    | 'vat_duties_insurance'
+    | 'item_price'
+    | 'item_discount'
+    | 'rounding'
+    | 'insurance'
+    | 'shipping'
+    | 'shipping_discount'
+    | 'order_discount'
+    | 'subtotal_percent_sales_margin'
+    | 'subtotal_vat_percent_sales_margin'
+    | 'subtotal_duty_percent_sales_margin'
+    | 'vat_subsidy'
+    | 'duty_subsidy'
+    | 'remote_area_surcharge'
+    | 'fuel_surcharge'
+    | 'emergency_situation_surcharge'
+    | 'peak_surcharge'
+    | 'duties_taxes_paid_surcharge'
+    | 'tip';
+  type OrderPriceDetailKey =
+    | 'adjustment'
+    | 'subtotal'
+    | 'vat'
+    | 'duty'
+    | 'shipping'
+    | 'insurance'
+    | 'discount'
+    | 'surcharges'
+    | 'tip';
 }
 
-declare namespace io.flow.error.v0.models {
-  interface GenericError {
-    readonly code: io.flow.error.v0.enums.GenericErrorCode;
-    readonly messages: string[];
+declare namespace io.flow.order.price.v0.models {
+  interface OrderPriceDetail {
+    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailKey;
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base: io.flow.common.v0.models.Price;
+    readonly components: io.flow.order.price.v0.models.OrderPriceDetailComponent[];
+    readonly name?: string;
+    readonly rate?: number;
+    readonly accuracy?: io.flow.price.v0.enums.PriceAccuracy;
+    readonly rate_label?: string;
+  }
+
+  interface OrderPriceDetailComponent {
+    readonly key: io.flow.order.price.v0.enums.OrderPriceDetailComponentKey;
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base: io.flow.common.v0.models.Price;
+    readonly name?: string;
   }
 }
 
-declare namespace io.flow.ben.test.internal.v0.models {
-  interface GenerateLoadMultipleOrgs {
-    readonly discriminator: 'generate_load_multiple_orgs';
-    readonly organization_ids: string[];
-    readonly num_events: number;
+declare namespace io.flow.common.v0.enums {
+  type AttributeDataType =
+    | 'boolean'
+    | 'integer'
+    | 'decimal'
+    | 'string'
+    | 'json_array';
+  type AvailabilityStatus = 'enabled' | 'disabled';
+  type Calendar = 'weekdays' | 'everyday';
+  type Capability = 'crossdock';
+  type ChangeType = 'insert' | 'update' | 'delete';
+  type CurrencyLabelFormatter =
+    | 'strip_trailing_zeros'
+    | 'symbol_prefix'
+    | 'symbol_suffix';
+  type CurrencySymbolFormat = 'narrow' | 'primary';
+  type DayOfWeek =
+    | 'sunday'
+    | 'monday'
+    | 'tuesday'
+    | 'wednesday'
+    | 'thursday'
+    | 'friday'
+    | 'saturday';
+  type DeliveredDuty = 'paid' | 'unpaid';
+  type DiscountTarget = 'item' | 'shipping';
+  type EntityIdentifierType = 'ioss' | 'voec' | 'zaz';
+  type Environment = 'sandbox' | 'production';
+  type ExceptionType = 'open' | 'closed';
+  type GoodsSupply = 'export' | 'intra_community' | 'local';
+  type HolidayCalendar = 'us_bank_holidays' | 'jewish_holidays';
+  type IncludedLevyKey = 'duty' | 'vat' | 'vat_and_duty' | 'none';
+  type Incoterm =
+    | 'EXW'
+    | 'FCA'
+    | 'CPT'
+    | 'CIP'
+    | 'DAT'
+    | 'DAP'
+    | 'DDP'
+    | 'FAS'
+    | 'FOB'
+    | 'CFR'
+    | 'CIF'
+    | 'DAF'
+    | 'DES'
+    | 'DEQ'
+    | 'DDU';
+  type InputSpecificationType = 'text' | 'number';
+  type MarginType = 'fixed' | 'percent';
+  type MeasurementSystem = 'imperial' | 'metric';
+  type MerchantOfRecord = 'flow' | 'organization';
+  type OrderMerchantOfRecord = 'flow' | 'organization' | 'mixed';
+  type OrganizationStatus =
+    | 'active'
+    | 'inactive'
+    | 'deactivated'
+    | 'provisioned';
+  type OrganizationType = 'standalone' | 'channel';
+  type PriceBookStatus = 'draft' | 'published' | 'archived';
+  type Role = 'admin' | 'member';
+  type RoundingMethod = 'up' | 'down' | 'nearest';
+  type RoundingType = 'pattern' | 'multiple';
+  type ScheduleExceptionStatus = 'Open' | 'Closed';
+  type SortDirection = 'ascending' | 'descending';
+  type UnitOfMeasurement =
+    | 'millimeter'
+    | 'centimeter'
+    | 'inch'
+    | 'foot'
+    | 'cubic_inch'
+    | 'cubic_meter'
+    | 'gram'
+    | 'kilogram'
+    | 'meter'
+    | 'ounce'
+    | 'pound';
+  type UnitOfTime = 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute';
+  type UserStatus = 'pending' | 'active' | 'inactive';
+  type ValueAddedService = 'Hazardous Material';
+  type Visibility = 'public' | 'private';
+}
+
+declare namespace io.flow.common.v0.models {
+  interface Address {
+    readonly text?: string;
+    readonly streets?: string[];
+    readonly street_number?: string;
+    readonly city?: string;
+    readonly province?: string;
+    readonly postal?: string;
+    readonly country?: string;
+    readonly latitude?: string;
+    readonly longitude?: string;
   }
 
-  interface GenerateLoadSingleOrg {
-    readonly discriminator: 'generate_load_single_org';
-    readonly organization_id: string;
-    readonly num_events: number;
+  interface BillingAddress {
+    readonly name?: io.flow.common.v0.models.Name;
+    readonly streets?: string[];
+    readonly city?: string;
+    readonly province?: string;
+    readonly postal?: string;
+    readonly country?: string;
+    readonly company?: string;
+  }
+
+  interface CatalogItemReference {
+    readonly id: string;
+    readonly number: string;
   }
 
-  interface SvitlanaTest {
+  interface CatalogItemSummary {
+    readonly number: string;
     readonly name: string;
+    readonly attributes: Record<string, string>;
   }
 
-  interface Test {
+  interface ChannelReference {
     readonly id: string;
-    readonly name: string;
   }
 
-  interface TestForm {
-    readonly name: string;
+  interface CheckoutReference {
+    readonly id: string;
   }
-}
 
-declare namespace io.flow.ben.test.internal.v0.unions {
-  type GenerateLoad =
-    | io.flow.ben.test.internal.v0.models.GenerateLoadSingleOrg
-    | io.flow.ben.test.internal.v0.models.GenerateLoadMultipleOrgs;
-}
+  interface Contact {
+    readonly name: io.flow.common.v0.models.Name;
+    readonly company?: string;
+    readonly email?: string;
+    readonly phone?: string;
+  }
 
-declare namespace io.flow.apple.pay.v0.enums {
-  type ApplePayContactField =
-    | 'email'
-    | 'name'
-    | 'phone'
-    | 'postalAddress'
-    | 'phoneticName';
-  type ApplePayLineItemType = 'final' | 'pending';
-  type ApplePayMerchantCapability =
-    | 'supports3DS'
-    | 'supportsCredit'
-    | 'supportsDebit'
-    | 'supportsEMV';
-  type ApplePayShippingType =
-    | 'shipping'
-    | 'delivery'
-    | 'storePickup'
-    | 'servicePickup';
-  type ApplePaySupportedNetworks =
-    | 'amex'
-    | 'chinaUnionPay'
-    | 'discover'
-    | 'jcb'
-    | 'masterCard'
-    | 'privateLabel'
-    | 'visa';
-}
+  interface CustomerInvoice {
+    readonly address?: io.flow.common.v0.models.BillingAddress;
+  }
 
-declare namespace io.flow.apple.pay.v0.models {
-  interface ApplePayLineItem {
-    readonly label: string;
-    readonly type: io.flow.apple.pay.v0.enums.ApplePayLineItemType;
-    readonly amount: string;
+  interface CustomerReference {
+    readonly number: string;
   }
 
-  interface ApplePayPaymentContact {
-    readonly email_address?: string;
-    readonly family_name?: string;
-    readonly given_name?: string;
-    readonly phone_number?: string;
-    readonly phonetic_familyName?: string;
-    readonly phonetic_givenName?: string;
-    readonly address_lines?: string[];
-    readonly locality?: string;
-    readonly sub_locality?: string;
-    readonly administrative_area?: string;
-    readonly sub_administrative_area?: string;
-    readonly postal_code?: string;
-    readonly country?: string;
-    readonly country_code?: string;
+  interface DatetimeRange {
+    readonly from: string;
+    readonly to: string;
+  }
+
+  interface Dimension {
+    readonly depth?: io.flow.common.v0.models.Measurement;
+    readonly diameter?: 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 Dimensions {
+    readonly product?: io.flow.common.v0.models.Dimension;
+    readonly packaging?: io.flow.common.v0.models.Dimension;
+  }
+
+  interface DiscountForm {
+    readonly offer: io.flow.common.v0.unions.DiscountOffer;
+    readonly target?: io.flow.common.v0.enums.DiscountTarget;
+    readonly label?: string;
+  }
+
+  interface DiscountOfferFixed {
+    readonly discriminator: 'discount_offer_fixed';
+    readonly money: io.flow.common.v0.models.Money;
+  }
+
+  interface DiscountOfferPercent {
+    readonly discriminator: 'discount_offer_percent';
+    readonly percent: number;
+  }
+
+  interface DiscountsForm {
+    readonly discounts: io.flow.common.v0.models.DiscountForm[];
+  }
+
+  interface Duration {
+    readonly unit: io.flow.common.v0.enums.UnitOfTime;
+    readonly value: number;
+  }
+
+  interface EntityIdentifier {
+    readonly name: io.flow.common.v0.enums.EntityIdentifierType;
+    readonly number: string;
+    readonly issuing_country?: string;
+  }
+
+  interface Exception {
+    readonly type: io.flow.common.v0.enums.ExceptionType;
+    readonly datetime_range: io.flow.common.v0.models.DatetimeRange;
+  }
+
+  interface ExperienceSummary {
+    readonly id: string;
+    readonly key: string;
+    readonly name: string;
+    readonly country?: string;
+    readonly currency?: string;
+    readonly language?: string;
+  }
+
+  interface IncludedLevies {
+    readonly key: io.flow.common.v0.enums.IncludedLevyKey;
+    readonly label: string;
+  }
+
+  interface InputForm {
+    readonly values?: Record<string, string>;
+  }
+
+  interface InputFormSpecification {
+    readonly inputs?: io.flow.common.v0.models.InputSpecification[];
+    readonly limitations?: io.flow.common.v0.models.InputSpecificationLimitations;
+  }
+
+  interface InputSpecification {
+    readonly type: io.flow.common.v0.enums.InputSpecificationType;
+    readonly name: string;
+    readonly display_text?: string;
+  }
+
+  interface InputSpecificationLimitationMax {
+    readonly discriminator: 'input_specification_limitation_max';
+    readonly max: number;
+  }
+
+  interface InputSpecificationLimitations {
+    readonly limitations?: io.flow.common.v0.unions.InputSpecificationLimitation[];
+  }
+
+  interface ItemReference {
+    readonly number: string;
+  }
+
+  interface LineItem {
+    readonly number: string;
+    readonly quantity: number;
+    readonly price: io.flow.common.v0.models.Money;
+    readonly attributes: Record<string, string>;
+    readonly center?: string;
+    readonly discount?: io.flow.common.v0.models.Money;
+  }
+
+  interface LineItemAttributesForm {
+    readonly attributes: Record<string, string>;
+  }
+
+  interface LineItemForm {
+    readonly number: string;
+    readonly quantity: number;
+    readonly shipment_estimate?: io.flow.common.v0.models.DatetimeRange;
+    readonly price?: io.flow.common.v0.models.Money;
+    readonly attributes?: Record<string, string>;
+    readonly center?: string;
+    readonly discount?: io.flow.common.v0.models.Money;
+    readonly discounts?: io.flow.common.v0.models.DiscountsForm;
+  }
+
+  interface LineItemQuantityForm {
+    readonly quantity: number;
+  }
+
+  interface LogoImageSetStatic {
+    readonly discriminator: 'static';
+    readonly small?: io.flow.common.v0.models.LogoImageStatic;
+    readonly medium: io.flow.common.v0.models.LogoImageStatic;
+    readonly large?: io.flow.common.v0.models.LogoImageStatic;
+  }
+
+  interface LogoImageStatic {
+    readonly url: string;
+    readonly width: number;
+    readonly height: number;
+  }
+
+  interface LogoImageSvg {
+    readonly discriminator: 'svg';
+    readonly url: string;
+  }
+
+  interface Margin {
+    readonly type: io.flow.common.v0.enums.MarginType;
+    readonly value: number;
+  }
+
+  interface Measurement {
+    readonly value: string;
+    readonly units: io.flow.common.v0.enums.UnitOfMeasurement;
+  }
+
+  interface MerchantOfRecordEntity {
+    readonly organization: io.flow.common.v0.models.OrganizationReference;
+    readonly name: string;
+    readonly vat?: io.flow.common.v0.models.MerchantOfRecordEntityRegistration;
+    readonly identifiers?: io.flow.common.v0.models.EntityIdentifier[];
+    readonly streets: string[];
+    readonly city: string;
+    readonly province?: string;
+    readonly postal?: string;
+    readonly country: string;
+    readonly phone?: string;
+    readonly email?: string;
+  }
+
+  interface MerchantOfRecordEntityRegistration {
+    readonly number: string;
+    readonly country: string;
+  }
+
+  interface Money {
+    readonly amount: number;
+    readonly currency: string;
+  }
+
+  interface MoneyWithBase {
+    readonly currency: string;
+    readonly amount: number;
+    readonly base: io.flow.common.v0.models.Money;
+  }
+
+  interface MoneyWithOptionalBase {
+    readonly currency: string;
+    readonly amount: number;
+    readonly base?: io.flow.common.v0.models.Money;
+  }
+
+  interface Name {
+    readonly first?: string;
+    readonly last?: string;
+  }
+
+  interface OrderCustomer {
+    readonly name: io.flow.common.v0.models.Name;
+    readonly number?: string;
+    readonly phone?: string;
+    readonly email?: string;
+    readonly address?: io.flow.common.v0.models.BillingAddress;
+    readonly invoice?: io.flow.common.v0.models.CustomerInvoice;
+  }
+
+  interface OrderCustomerForm {
+    readonly name?: io.flow.common.v0.models.Name;
+    readonly number?: string;
+    readonly phone?: string;
+    readonly email?: string;
+    readonly address?: io.flow.common.v0.models.BillingAddress;
+    readonly invoice?: io.flow.common.v0.models.CustomerInvoice;
+  }
+
+  interface Organization {
+    readonly discriminator: 'organization';
+    readonly id: string;
+    readonly name: string;
+    readonly environment: io.flow.common.v0.enums.Environment;
+    readonly parent?: io.flow.common.v0.models.OrganizationReference;
+    readonly defaults?: io.flow.common.v0.models.OrganizationDefaults;
+    readonly created_at?: string;
+    readonly status?: io.flow.common.v0.enums.OrganizationStatus;
+    readonly type?: io.flow.common.v0.enums.OrganizationType;
+  }
+
+  interface OrganizationDefaults {
+    readonly country: string;
+    readonly base_currency: string;
+    readonly language: string;
+    readonly locale: string;
+    readonly timezone: string;
+  }
+
+  interface OrganizationReference {
+    readonly discriminator: 'organization_reference';
+    readonly id: string;
+  }
+
+  interface OrganizationSummary {
+    readonly id: string;
+    readonly name: string;
+    readonly environment: io.flow.common.v0.enums.Environment;
+  }
+
+  interface PartnerReference {
+    readonly id: string;
+  }
+
+  interface Price {
+    readonly amount: number;
+    readonly currency: string;
+    readonly label: string;
+  }
+
+  interface PriceForm {
+    readonly amount: number;
+    readonly currency: string;
+  }
+
+  interface PriceSourceCatalog {
+    readonly discriminator: 'catalog';
+    readonly price: io.flow.common.v0.models.Money;
+  }
+
+  interface PriceSourcePriceBook {
+    readonly discriminator: 'price_book';
+    readonly price: io.flow.common.v0.models.Money;
+    readonly includes: io.flow.common.v0.models.IncludedLevies;
+    readonly price_book_reference: io.flow.common.v0.models.PriceSourcePriceBookReference;
+  }
+
+  interface PriceSourcePriceBookReference {
+    readonly id: string;
+    readonly key: string;
+  }
+
+  interface PriceSourceProvided {
+    readonly discriminator: 'provided';
+    readonly price: io.flow.common.v0.models.Money;
+  }
+
+  interface PriceWithBase {
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base?: io.flow.common.v0.models.Price;
+  }
+
+  interface RepeatDaily {
+    readonly discriminator: 'repeat_daily';
+    readonly interval: number;
+  }
+
+  interface RepeatHourly {
+    readonly discriminator: 'repeat_hourly';
+    readonly interval: number;
+  }
+
+  interface RepeatMonthly {
+    readonly discriminator: 'repeat_monthly';
+    readonly interval: number;
+    readonly days: number[];
+  }
+
+  interface RepeatWeekly {
+    readonly discriminator: 'repeat_weekly';
+    readonly interval: number;
+    readonly days_of_week: io.flow.common.v0.enums.DayOfWeek[];
+  }
+
+  interface Rounding {
+    readonly type: io.flow.common.v0.enums.RoundingType;
+    readonly method: io.flow.common.v0.enums.RoundingMethod;
+    readonly value: number;
+  }
+
+  interface Schedule {
+    readonly calendar?: io.flow.common.v0.enums.Calendar;
+    readonly holiday: io.flow.common.v0.enums.HolidayCalendar;
+    readonly exception: io.flow.common.v0.models.Exception[];
+    readonly cutoff?: string;
+    readonly min_lead_time?: number;
+    readonly max_lead_time?: number;
+  }
+
+  interface SessionReference {
+    readonly id: string;
+  }
+
+  interface User {
+    readonly discriminator: 'user';
+    readonly id: string;
+    readonly email?: string;
+    readonly name: io.flow.common.v0.models.Name;
+    readonly status: io.flow.common.v0.enums.UserStatus;
+  }
+
+  interface UserReference {
+    readonly discriminator: 'user_reference';
+    readonly id: string;
+  }
+
+  interface Zone {
+    readonly postals?: string[];
+    readonly provinces?: string[];
+    readonly country: string;
+  }
+}
+
+declare namespace io.flow.common.v0.unions {
+  type DiscountOffer =
+    | io.flow.common.v0.models.DiscountOfferFixed
+    | io.flow.common.v0.models.DiscountOfferPercent;
+  type ExpandableOrganization =
+    | io.flow.common.v0.models.Organization
+    | io.flow.common.v0.models.OrganizationReference;
+  type ExpandableUser =
+    | io.flow.common.v0.models.User
+    | io.flow.common.v0.models.UserReference;
+  type InputSpecificationLimitation =
+    io.flow.common.v0.models.InputSpecificationLimitationMax;
+  type LogoImage =
+    | io.flow.common.v0.models.LogoImageSvg
+    | io.flow.common.v0.models.LogoImageSetStatic;
+  type PriceSource =
+    | io.flow.common.v0.models.PriceSourcePriceBook
+    | io.flow.common.v0.models.PriceSourceCatalog
+    | io.flow.common.v0.models.PriceSourceProvided;
+  type RepeatSchedule =
+    | io.flow.common.v0.models.RepeatHourly
+    | io.flow.common.v0.models.RepeatDaily
+    | io.flow.common.v0.models.RepeatWeekly
+    | io.flow.common.v0.models.RepeatMonthly;
+}
+
+declare namespace io.flow.error.v0.enums {
+  type GenericErrorCode = 'generic_error' | 'client_error' | 'server_error';
+}
+
+declare namespace io.flow.error.v0.models {
+  interface GenericError {
+    readonly code: io.flow.error.v0.enums.GenericErrorCode;
+    readonly messages: string[];
+  }
+}
+
+declare namespace io.flow.price.v0.enums {
+  type LevyComponent = 'goods' | 'duty' | 'insurance' | 'freight' | 'vat';
+  type LevyStrategy = 'minimum' | 'average' | 'maximum';
+  type PriceAccuracy = 'calculated' | 'estimated_from_partial_destination';
+  type PriceDetailComponentKey =
+    | 'base_price'
+    | 'discount'
+    | 'currency_margin'
+    | 'percent_item_margin'
+    | 'fixed_item_margin'
+    | 'duties_item_price'
+    | 'duties_added_margin'
+    | 'duties_rounding'
+    | 'duties_deminimis'
+    | 'vat_item_price'
+    | 'vat_added_margin'
+    | 'vat_rounding'
+    | 'vat_duties_item_price'
+    | 'vat_duties_added_margin'
+    | 'vat_duties_rounding'
+    | 'vat_deminimis'
+    | 'item_price_percent_sales_margin'
+    | 'margins_percent_sales_margin'
+    | 'rounding_percent_sales_margin'
+    | 'vat_percent_sales_margin'
+    | 'vat_duty_percent_sales_margin'
+    | 'duty_percent_sales_margin';
+  type PriceDetailKey =
+    | 'item_price'
+    | 'margins'
+    | 'vat'
+    | 'duty'
+    | 'rounding'
+    | 'adjustment';
+  type PricingLevySetting = 'included' | 'displayed' | 'ignored';
+}
+
+declare namespace io.flow.price.v0.models {
+  interface CurrencyFormat {
+    readonly symbol: io.flow.common.v0.enums.CurrencySymbolFormat;
+    readonly label_formatters: io.flow.common.v0.enums.CurrencyLabelFormatter[];
+  }
+
+  interface DeminimisPerItem {
+    readonly discriminator: 'deminimis_per_item';
+    readonly currency: string;
+    readonly minimum?: number;
+    readonly maximum?: number;
+  }
+
+  interface DeminimisSimple {
+    readonly discriminator: 'deminimis_simple';
+    readonly value?: number;
+    readonly currency: string;
+    readonly components: io.flow.price.v0.enums.LevyComponent[];
+    readonly minimum?: number;
+  }
+
+  interface Duty {
+    readonly rate: number;
+    readonly components: io.flow.price.v0.enums.LevyComponent[];
+    readonly deminimis?: io.flow.price.v0.unions.Deminimis;
+    readonly name?: string;
+  }
+
+  interface LocalPriceDetails {
+    readonly base: io.flow.price.v0.models.PriceDetails;
+    readonly local: io.flow.price.v0.models.PriceDetails;
+    readonly discount?: io.flow.price.v0.models.PriceDetail;
+    readonly local_before_discount?: io.flow.price.v0.models.PriceDetail;
+  }
+
+  interface PriceBook {
+    readonly id: string;
+    readonly key: string;
+    readonly currency: string;
+    readonly name: string;
+    readonly includes: io.flow.common.v0.models.IncludedLevies;
+    readonly status: io.flow.common.v0.enums.PriceBookStatus;
+  }
+
+  interface PriceBookForm {
+    readonly currency: string;
+    readonly name: string;
+    readonly includes: io.flow.common.v0.enums.IncludedLevyKey;
+    readonly status?: io.flow.common.v0.enums.PriceBookStatus;
+  }
+
+  interface PriceBookItem {
+    readonly id: string;
+    readonly key: string;
+    readonly price_book: io.flow.price.v0.models.PriceBookReference;
+    readonly price: io.flow.common.v0.models.Price;
+    readonly item_number: string;
+    readonly schedule: io.flow.price.v0.models.PriceBookItemSchedule;
+    readonly item_attributes?: Record<string, string>;
+  }
+
+  interface PriceBookItemForm {
+    readonly price_book_key: string;
+    readonly item_number: string;
+    readonly amount: number;
+    readonly schedule?: io.flow.price.v0.models.PriceBookItemSchedule;
+    readonly item_attributes?: Record<string, string>;
+  }
+
+  interface PriceBookItemQueryForm {
+    readonly price_book_key: string;
+    readonly item_query: string;
+    readonly amount: number;
+    readonly schedule?: io.flow.price.v0.models.PriceBookItemSchedule;
+    readonly item_attributes?: Record<string, string>;
+  }
+
+  interface PriceBookItemSchedule {
+    readonly starts_at: string;
+    readonly ends_at?: string;
+  }
+
+  interface PriceBookReference {
+    readonly id: string;
+    readonly key: string;
+  }
+
+  interface PriceCheck {
+    readonly display: io.flow.price.v0.models.LocalPriceDetails;
+    readonly final: io.flow.price.v0.models.LocalPriceDetails;
+  }
+
+  interface PriceDetail {
+    readonly key: io.flow.price.v0.enums.PriceDetailKey;
+    readonly components: io.flow.price.v0.models.PriceDetailComponent[];
+    readonly amount: number;
+    readonly label: string;
+    readonly name?: string;
+    readonly basis?: number;
+  }
+
+  interface PriceDetailComponent {
+    readonly key: io.flow.price.v0.enums.PriceDetailComponentKey;
+    readonly amount: number;
+    readonly label: string;
+    readonly name?: string;
+  }
+
+  interface PriceDetails {
+    readonly currency: string;
+    readonly item_price: io.flow.price.v0.models.PriceDetail;
+    readonly margins: io.flow.price.v0.models.PriceDetail;
+    readonly vat: io.flow.price.v0.models.PriceDetail;
+    readonly duty: io.flow.price.v0.models.PriceDetail;
+    readonly rounding: io.flow.price.v0.models.PriceDetail;
+    readonly price: io.flow.common.v0.models.Price;
+    readonly total: io.flow.common.v0.models.Price;
+    readonly adjustment?: io.flow.price.v0.models.PriceDetail;
+  }
+
+  interface PriceEquation {
+    readonly contracted_rate: number;
+    readonly rate: number;
+    readonly pricing: io.flow.price.v0.models.Pricing;
+    readonly base_price: number;
+    readonly discount: number;
+    readonly fixed_margin: number;
+    readonly percent_margin: number;
+    readonly insurance: number;
+    readonly freight: number;
+    readonly duty?: io.flow.price.v0.models.Duty;
+    readonly tax?: io.flow.price.v0.models.Tax;
+    readonly percent_sales_margin: number;
+  }
+
+  interface Pricing {
+    readonly vat: io.flow.price.v0.enums.PricingLevySetting;
+    readonly duty: io.flow.price.v0.enums.PricingLevySetting;
+    readonly rounding?: io.flow.common.v0.models.Rounding;
+  }
+
+  interface Tax {
+    readonly name: string;
+    readonly rate: number;
+    readonly components: io.flow.price.v0.enums.LevyComponent[];
+    readonly deminimis?: io.flow.price.v0.unions.Deminimis;
+  }
+}
+
+declare namespace io.flow.price.v0.unions {
+  type Deminimis =
+    | io.flow.price.v0.models.DeminimisSimple
+    | io.flow.price.v0.models.DeminimisPerItem;
+}
+
+declare namespace io.flow.reference.v0.enums {
+  type PaymentMethodCapability = 'credit' | 'debit';
+  type PaymentMethodType = 'card' | 'online' | 'offline';
+  type PostalType = 'eircode' | 'pin' | 'postal' | 'zip';
+  type ProvinceType =
+    | 'area'
+    | 'city'
+    | 'county'
+    | 'department'
+    | 'dependency'
+    | 'district'
+    | 'do_si'
+    | 'emirate'
+    | 'entity'
+    | 'island'
+    | 'municipality'
+    | 'oblast'
+    | 'outlying_area'
+    | 'parish'
+    | 'prefecture'
+    | 'province'
+    | 'state'
+    | 'territory'
+    | 'other';
+}
+
+declare namespace io.flow.reference.v0.models {
+  interface Carrier {
+    readonly id: string;
+    readonly name: string;
+    readonly tracking_url: string;
+  }
+
+  interface CarrierService {
+    readonly id: string;
+    readonly carrier: io.flow.reference.v0.models.Carrier;
+    readonly name: string;
+  }
+
+  interface Country {
+    readonly name: string;
+    readonly iso_3166_2: string;
+    readonly iso_3166_3: string;
+    readonly languages: string[];
+    readonly measurement_system: string;
+    readonly default_currency?: string;
+    readonly default_language?: string;
+    readonly timezones: string[];
+    readonly default_delivered_duty?: string;
+  }
+
+  interface Currency {
+    readonly name: string;
+    readonly iso_4217_3: string;
+    readonly number_decimals: number;
+    readonly symbols?: io.flow.reference.v0.models.CurrencySymbols;
+    readonly default_locale?: string;
+  }
+
+  interface CurrencySymbols {
+    readonly primary: string;
+    readonly narrow?: string;
+  }
+
+  interface Language {
+    readonly name: string;
+    readonly iso_639_2: string;
+  }
+
+  interface Locale {
+    readonly id: string;
+    readonly name: string;
+    readonly country: string;
+    readonly language: string;
+    readonly numbers: io.flow.reference.v0.models.LocaleNumbers;
+  }
+
+  interface LocaleNumbers {
+    readonly decimal: string;
+    readonly group: string;
+  }
+
+  interface LocalizedTranslation {
+    readonly locale: io.flow.reference.v0.models.Locale;
+    readonly name: string;
+  }
+
+  interface PaymentMethod {
+    readonly id: string;
+    readonly type: io.flow.reference.v0.enums.PaymentMethodType;
+    readonly name: string;
+    readonly images: io.flow.reference.v0.models.PaymentMethodImages;
+    readonly regions: string[];
+    readonly capabilities?: io.flow.reference.v0.enums.PaymentMethodCapability[];
+  }
+
+  interface PaymentMethodImage {
+    readonly url: string;
+    readonly width: number;
+    readonly height: number;
+  }
+
+  interface PaymentMethodImages {
+    readonly small: io.flow.reference.v0.models.PaymentMethodImage;
+    readonly medium: io.flow.reference.v0.models.PaymentMethodImage;
+    readonly large: io.flow.reference.v0.models.PaymentMethodImage;
+  }
+
+  interface Province {
+    readonly id: string;
+    readonly iso_3166_2: string;
+    readonly name: string;
+    readonly country: string;
+    readonly province_type: io.flow.reference.v0.enums.ProvinceType;
+    readonly translations?: io.flow.reference.v0.models.LocalizedTranslation[];
+  }
+
+  interface Region {
+    readonly id: string;
+    readonly name: string;
+    readonly countries: string[];
+    readonly currencies: string[];
+    readonly languages: string[];
+    readonly measurement_systems: string[];
+    readonly timezones: string[];
+  }
+
+  interface Timezone {
+    readonly name: string;
+    readonly description: string;
+    readonly offset: number;
+  }
+}
+
+declare namespace io.flow.ben.test.internal.v0.models {
+  interface GenerateLoadMultipleOrgs {
+    readonly discriminator: 'generate_load_multiple_orgs';
+    readonly organization_ids: string[];
+    readonly num_events: number;
+  }
+
+  interface GenerateLoadSingleOrg {
+    readonly discriminator: 'generate_load_single_org';
+    readonly organization_id: string;
+    readonly num_events: number;
+  }
+
+  interface Test {
+    readonly id: string;
+    readonly name: string;
+  }
+
+  interface TestForm {
+    readonly name: string;
+  }
+}
+
+declare namespace io.flow.ben.test.internal.v0.unions {
+  type GenerateLoad =
+    | io.flow.ben.test.internal.v0.models.GenerateLoadSingleOrg
+    | io.flow.ben.test.internal.v0.models.GenerateLoadMultipleOrgs;
+}
+
+declare namespace io.flow.fulfillment.v0.enums {
+  type CenterCapability =
+    | 'international'
+    | 'domestic'
+    | 'crossdock'
+    | 'commercial_invoice';
+  type DeliveryOptionCostDetailComponentKey =
+    | 'ratecard_base_cost'
+    | 'ratecard_ddp_fee'
+    | 'ratecard_fuel_surcharge'
+    | 'ratecard_oversized_shipment_fee'
+    | 'ratecard_rural_shipment_fee'
+    | 'ratecard_emergency_situation_surcharge_fee'
+    | 'ratecard_peak_surcharge_fee'
+    | 'ratecard_duties_taxes_paid_surcharge_fee'
+    | 'center_commercial_invoice_fee'
+    | 'center_inbound_carton_fee'
+    | 'center_outbound_carton_fee';
+  type DeliveryOptionCostDetailSource = 'center' | 'ratecard';
+  type DeliveryWindowComponentSource =
+    | 'flow'
+    | 'organization'
+    | 'carrier'
+    | 'center'
+    | 'mixed';
+  type DeliveryWindowLocation = 'center' | 'crossdock' | 'customer';
+  type FulfillmentRouting = 'fulfilled_from_center' | 'fulfillment_service';
+  type ItemAvailabilityStatus = 'available' | 'low' | 'out_of_stock';
+  type LaneDirection = 'outbound' | 'return';
+  type LanePreselectPreference = 'lowest_cost' | 'default_tier';
+  type LaneStrategy = 'oldest' | 'fastest' | 'lowest_cost' | 'highest_priority';
+  type PhysicalDeliverySpecialSerivce =
+    | 'cold_storage'
+    | 'hazardous'
+    | 'perishable';
+  type PreferredServiceSelectionStrategy =
+    | 'calculated_rate'
+    | 'flat_rate'
+    | 'custom_rate';
+  type QuoteErrorCode =
+    | 'generic_error'
+    | 'items_not_available'
+    | 'shipping_unavailable';
+  type RatecardOwner = 'flow' | 'organization';
+  type ShipmentIntegrationType = 'direct' | 'information' | 'preadvice';
+  type ShippingConfigurationType = 'default' | 'variant';
+  type Strategy = 'range' | 'from' | 'to';
+  type SurchargeResponsibleParty = 'organization' | 'customer';
+  type TierAvailability = 'always' | 'backup';
+  type TierEstimateType = 'calculated' | 'custom';
+  type TierStrategy = 'fastest' | 'lowest_cost';
+  type ZeroAmountIndicator = 'zero' | 'free';
+}
+
+declare namespace io.flow.fulfillment.v0.models {
+  interface AmountMargin {
+    readonly discriminator: 'amount_margin';
+    readonly margin: io.flow.common.v0.models.Price;
+  }
+
+  interface AmountMarginForm {
+    readonly discriminator: 'amount_margin_form';
+    readonly margin: io.flow.common.v0.models.Money;
+  }
+
+  interface AtCost {
+    readonly discriminator: 'at_cost';
+    readonly ignore?: string;
+  }
+
+  interface AvailableService {
+    readonly service: string;
+    readonly scheduled_pickups?: io.flow.fulfillment.v0.models.ScheduledPickup[];
+    readonly lead_days?: io.flow.fulfillment.v0.models.NumberRange;
+  }
+
+  interface CarrierReference {
+    readonly id: string;
+  }
+
+  interface Center {
+    readonly discriminator: 'center';
+    readonly id: string;
+    readonly key: string;
+    readonly address: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly packaging: io.flow.fulfillment.v0.models.Packaging[];
+    readonly name: string;
+    readonly services: io.flow.fulfillment.v0.models.AvailableService[];
+    readonly schedule: io.flow.common.v0.models.Schedule;
+    readonly timezone: string;
+    readonly capabilities?: io.flow.fulfillment.v0.enums.CenterCapability[];
+    readonly partner_center?: io.flow.fulfillment.v0.models.PartnerCenter;
+  }
+
+  interface CenterForm {
+    readonly address: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly packaging: io.flow.fulfillment.v0.models.Packaging[];
+    readonly name: string;
+    readonly services: io.flow.fulfillment.v0.models.AvailableService[];
+    readonly schedule: io.flow.common.v0.models.Schedule;
+    readonly timezone?: string;
+    readonly key?: string;
+    readonly capabilities?: io.flow.fulfillment.v0.enums.CenterCapability[];
+    readonly partner_center_form?: io.flow.fulfillment.v0.models.PartnerCenterForm;
+  }
+
+  interface CenterQuery {
+    readonly q: string;
+  }
+
+  interface CenterReference {
+    readonly discriminator: 'center_reference';
+    readonly organization_id: string;
+    readonly center_key: string;
+  }
+
+  interface CenterSummary {
+    readonly id: string;
+    readonly key: string;
+    readonly address?: io.flow.fulfillment.v0.models.ShippingAddress;
+  }
+
+  interface CenterVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly center: io.flow.fulfillment.v0.models.Center;
+  }
+
+  interface CommercialInvoiceFee {
+    readonly discriminator: 'commercial_invoice_fee';
+    readonly amount: io.flow.common.v0.models.Money;
+  }
+
+  interface CountryAvailability {
+    readonly status: io.flow.fulfillment.v0.enums.ItemAvailabilityStatus;
+    readonly countries: string[];
+  }
+
+  interface CountryShippingPricing {
+    readonly pricing: io.flow.fulfillment.v0.models.ItemShippingPricing;
+    readonly countries: string[];
+  }
+
+  interface DeliveryItem {
+    readonly id?: string;
+    readonly number: string;
+    readonly quantity: number;
+    readonly shipment_estimate?: io.flow.common.v0.models.DatetimeRange;
+    readonly price?: io.flow.common.v0.models.MoneyWithOptionalBase;
+    readonly attributes?: Record<string, string>;
+    readonly center?: string;
+    readonly line_number?: number;
+  }
+
+  interface DeliveryOption {
+    readonly id: string;
+    readonly cost: io.flow.fulfillment.v0.models.PriceWithBaseAndDetails;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly price: io.flow.fulfillment.v0.models.PriceWithBaseAndDetails;
+    readonly service: io.flow.fulfillment.v0.models.ServiceSummary;
+    readonly tier: io.flow.fulfillment.v0.models.TierSummary;
+    readonly window: io.flow.fulfillment.v0.models.DeliveryWindow;
+    readonly rule_outcome?: io.flow.fulfillment.v0.unions.TierRuleOutcome;
+    readonly weight?: io.flow.fulfillment.v0.models.OptionWeightEstimates;
+    readonly send_to?: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly surcharge?: io.flow.fulfillment.v0.models.PriceWithBaseAndDetails;
+    readonly ratecard_owner?: io.flow.fulfillment.v0.enums.RatecardOwner;
+  }
+
+  interface DeliveryOptionCostComponent {
+    readonly key: io.flow.fulfillment.v0.enums.DeliveryOptionCostDetailComponentKey;
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base?: io.flow.common.v0.models.Price;
+  }
+
+  interface DeliveryOptionCostDetail {
+    readonly source: io.flow.fulfillment.v0.enums.DeliveryOptionCostDetailSource;
+    readonly ratecard_id?: string;
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base?: io.flow.common.v0.models.Price;
+    readonly components: io.flow.fulfillment.v0.models.DeliveryOptionCostComponent[];
+  }
+
+  interface DeliveryOptionForm {
+    readonly delivery: string;
+    readonly items: io.flow.fulfillment.v0.models.QuoteLineItemForm[];
+    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
+  }
+
+  interface DeliveryOptionReference {
+    readonly id: string;
+  }
+
+  interface DeliveryOptionSummary {
+    readonly id: string;
+    readonly cost: io.flow.common.v0.models.Price;
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly price: io.flow.common.v0.models.Price;
+    readonly service: io.flow.fulfillment.v0.models.ServiceReference;
+    readonly tier: io.flow.fulfillment.v0.models.TierReference;
+    readonly window: io.flow.common.v0.models.DatetimeRange;
+  }
+
+  interface DeliveryOptionVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly delivery_option: io.flow.fulfillment.v0.models.DeliveryOptionSummary;
+  }
+
+  interface DeliverySummary {
+    readonly id: string;
+    readonly items: io.flow.common.v0.models.LineItemForm[];
+  }
+
+  interface DeliveryVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly delivery: io.flow.fulfillment.v0.models.DeliverySummary;
+  }
+
+  interface DeliveryWindow {
+    readonly from: string;
+    readonly to: string;
+    readonly timezone?: string;
+    readonly label?: string;
+    readonly min_days?: number;
+    readonly max_days?: number;
+  }
+
+  interface DeliveryWindowComponent {
+    readonly from: string;
+    readonly to: string;
+    readonly source: io.flow.fulfillment.v0.enums.DeliveryWindowComponentSource;
+  }
+
+  interface DeliveryWindowComponents {
+    readonly shipment_estimate: io.flow.fulfillment.v0.models.DeliveryWindowComponent;
+    readonly transit_estimate: io.flow.fulfillment.v0.models.DeliveryWindowComponent;
+  }
+
+  interface DeliveryWindowComponentsV2 {
+    readonly processing_estimates: io.flow.fulfillment.v0.models.ProcessingEstimate[];
+    readonly transit_estimates: io.flow.fulfillment.v0.models.TransitEstimate[];
+  }
+
+  interface DeliveryWindowSummary {
+    readonly country: string;
+    readonly delivery_window: io.flow.fulfillment.v0.models.DeliveryWindow;
+  }
+
+  interface DigitalDelivery {
+    readonly discriminator: 'digital_delivery';
+    readonly id: string;
+    readonly key?: string;
+    readonly items: io.flow.fulfillment.v0.models.DeliveryItem[];
+    readonly prices?: io.flow.order.price.v0.models.OrderPriceDetail[];
+    readonly total?: io.flow.catalog.v0.models.LocalizedTotal;
+  }
+
+  interface EstimatedWindow {
+    readonly from: number;
+    readonly to: number;
+    readonly unit: io.flow.common.v0.enums.UnitOfTime;
+  }
+
+  interface FlatRate {
+    readonly discriminator: 'flat_rate';
+    readonly price: io.flow.common.v0.models.Price;
+    readonly zero_amount_indicator?: io.flow.fulfillment.v0.enums.ZeroAmountIndicator;
+  }
+
+  interface FlatRateForm {
+    readonly discriminator: 'flat_rate_form';
+    readonly price: io.flow.common.v0.models.Money;
+    readonly zero_amount_indicator?: io.flow.fulfillment.v0.enums.ZeroAmountIndicator;
+  }
+
+  interface FulfillmentExperienceReference {
+    readonly id: string;
+    readonly currency: string;
+  }
+
+  interface InboundCartonFee {
+    readonly discriminator: 'inbound_carton_fee';
+    readonly amount: io.flow.common.v0.models.Money;
+  }
+
+  interface ItemShippingPricing {
+    readonly min: io.flow.common.v0.models.Price;
+    readonly max?: io.flow.common.v0.models.Price;
+  }
+
+  interface NumberRange {
+    readonly min: number;
+    readonly max: number;
+  }
+
+  interface OptionWeightEstimates {
+    readonly gravitational: io.flow.common.v0.models.Measurement;
+    readonly dimensional: io.flow.common.v0.models.Measurement;
+  }
+
+  interface OutboundCartonFee {
+    readonly discriminator: 'outbound_carton_fee';
+    readonly amount: io.flow.common.v0.models.Money;
+  }
+
+  interface Packaging {
+    readonly dimensions: io.flow.common.v0.models.Dimensions;
+    readonly name?: string;
+    readonly number?: string;
+  }
+
+  interface PartnerCenter {
+    readonly partner_reference: io.flow.common.v0.models.PartnerReference;
+    readonly number?: string;
+    readonly fees?: io.flow.fulfillment.v0.unions.PartnerCenterFee[];
+  }
+
+  interface PartnerCenterForm {
+    readonly partner_id: string;
+    readonly number?: string;
+    readonly fees?: io.flow.fulfillment.v0.unions.PartnerCenterFee[];
+  }
+
+  interface PercentMargin {
+    readonly discriminator: 'percent_margin';
+    readonly percentage: number;
+  }
+
+  interface PhysicalDelivery {
+    readonly discriminator: 'physical_delivery';
+    readonly id: string;
+    readonly key?: string;
+    readonly center?: io.flow.fulfillment.v0.models.CenterSummary;
+    readonly fulfillment_routing?: io.flow.fulfillment.v0.enums.FulfillmentRouting;
+    readonly ship_from_country?: string;
+    readonly items: io.flow.fulfillment.v0.models.DeliveryItem[];
+    readonly options: io.flow.fulfillment.v0.models.DeliveryOption[];
+    readonly special_services?: io.flow.fulfillment.v0.enums.PhysicalDeliverySpecialSerivce[];
+    readonly prices?: io.flow.order.price.v0.models.OrderPriceDetail[];
+    readonly total?: io.flow.catalog.v0.models.LocalizedTotal;
+    readonly goods_supply?: io.flow.common.v0.enums.GoodsSupply;
+    readonly merchant_of_record_flow_entity?: io.flow.merchant.of.record.v0.enums.FlowEntity;
+    readonly preferred_service?: io.flow.fulfillment.v0.models.PhysicalDeliveryPreferredService;
+  }
+
+  interface PhysicalDeliveryPreferredService {
+    readonly id: string;
+    readonly selection_stratey: io.flow.fulfillment.v0.enums.PreferredServiceSelectionStrategy;
+  }
+
+  interface PriceWithBaseAndDetails {
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base?: io.flow.common.v0.models.Price;
+    readonly details?: io.flow.fulfillment.v0.models.DeliveryOptionCostDetail[];
+  }
+
+  interface ProcessingEstimate {
+    readonly location: io.flow.fulfillment.v0.enums.DeliveryWindowLocation;
+    readonly min_date: string;
+    readonly max_date: string;
+    readonly source: io.flow.fulfillment.v0.enums.DeliveryWindowComponentSource;
+  }
+
+  interface Quote {
+    readonly id: string;
+    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly deliveries: io.flow.fulfillment.v0.unions.Delivery[];
+    readonly selections: io.flow.fulfillment.v0.models.DeliveryOptionReference[];
+    readonly delivered_duty: io.flow.common.v0.enums.DeliveredDuty;
+    readonly delivered_duties: io.flow.common.v0.enums.DeliveredDuty[];
+  }
+
+  interface QuoteError {
+    readonly code: io.flow.fulfillment.v0.enums.QuoteErrorCode;
+    readonly messages: string[];
+    readonly item_numbers?: string[];
+  }
+
+  interface QuoteForm {
+    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly experience: string;
+    readonly items: io.flow.fulfillment.v0.models.QuoteLineItemForm[];
+    readonly delivered_duty?: io.flow.common.v0.enums.DeliveredDuty;
+    readonly delivered_duties?: io.flow.common.v0.enums.DeliveredDuty[];
+    readonly direction?: io.flow.fulfillment.v0.enums.LaneDirection;
+  }
+
+  interface QuoteLineItemForm {
+    readonly number: string;
+    readonly quantity: number;
+    readonly shipment_estimate?: io.flow.common.v0.models.DatetimeRange;
+    readonly price: io.flow.common.v0.models.MoneyWithBase;
+    readonly attributes?: Record<string, string>;
+    readonly center?: string;
+  }
+
+  interface QuoteSummary {
+    readonly id: string;
+    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
+  }
+
+  interface QuoteVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly quote: io.flow.fulfillment.v0.models.QuoteSummary;
+  }
+
+  interface ScheduledPickup {
+    readonly day_of_week: io.flow.common.v0.enums.DayOfWeek;
+    readonly hour_of_day: string;
+    readonly minute_of_hour: string;
+  }
+
+  interface ServiceReference {
+    readonly id: string;
+  }
+
+  interface ServiceSummary {
+    readonly discriminator: 'service_summary';
+    readonly id: string;
+    readonly carrier: io.flow.fulfillment.v0.models.CarrierReference;
+    readonly name: string;
+    readonly center_code?: string;
+  }
+
+  interface ServiceUnknown {
+    readonly discriminator: 'service_unknown';
+    readonly name: string;
+  }
+
+  interface ShippingAddress {
+    readonly contact: io.flow.common.v0.models.Contact;
+    readonly location: io.flow.common.v0.models.Address;
+    readonly center_key?: string;
+    readonly center_reference?: io.flow.fulfillment.v0.models.CenterReference;
+    readonly service?: io.flow.fulfillment.v0.models.ServiceSummary;
+  }
+
+  interface ShippingConfiguration {
+    readonly id: string;
+    readonly name: string;
+    readonly key: string;
+    readonly type: io.flow.fulfillment.v0.enums.ShippingConfigurationType;
+    readonly shipping_lanes: io.flow.fulfillment.v0.models.ShippingLane[];
+  }
+
+  interface ShippingConfigurationCopy {
+    readonly original: io.flow.fulfillment.v0.models.ShippingConfigurationReference;
+    readonly new: io.flow.fulfillment.v0.models.ShippingConfigurationReference;
+  }
+
+  interface ShippingConfigurationCopyForm {
+    readonly name: string;
+  }
+
+  interface ShippingConfigurationForm {
+    readonly name: string;
+  }
+
+  interface ShippingConfigurationItemAvailability {
+    readonly id: string;
+    readonly item: io.flow.common.v0.models.ItemReference;
+    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfigurationSummary;
+    readonly availabilities: io.flow.fulfillment.v0.models.CountryAvailability[];
+  }
+
+  interface ShippingConfigurationItemShippingPricing {
+    readonly id: string;
+    readonly item: io.flow.common.v0.models.ItemReference;
+    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfigurationSummary;
+    readonly country_shipping_pricings: io.flow.fulfillment.v0.models.CountryShippingPricing[];
+  }
+
+  interface ShippingConfigurationReference {
+    readonly key: string;
+  }
+
+  interface ShippingConfigurationSummary {
+    readonly id: string;
+    readonly name: string;
+    readonly key: string;
+    readonly type: io.flow.fulfillment.v0.enums.ShippingConfigurationType;
+  }
+
+  interface ShippingConfigurationVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfiguration;
+  }
+
+  interface ShippingLane {
+    readonly id: string;
+    readonly shipping_configuration: io.flow.fulfillment.v0.models.ShippingConfigurationReference;
+    readonly region: string;
+    readonly centers: io.flow.fulfillment.v0.unions.ExpandableCenter[];
+    readonly tiers: io.flow.fulfillment.v0.models.Tier[];
+    readonly query: io.flow.query.builder.v0.models.Query;
+    readonly strategy: io.flow.fulfillment.v0.enums.LaneStrategy;
+    readonly direction?: io.flow.fulfillment.v0.enums.LaneDirection;
+    readonly preference?: io.flow.fulfillment.v0.enums.LanePreselectPreference;
+  }
+
+  interface ShippingLaneDefaultTier {
+    readonly id: string;
+    readonly tier: io.flow.fulfillment.v0.models.TierReference;
+  }
+
+  interface ShippingLaneDefaultTierForm {
+    readonly tier_id: string;
+  }
+
+  interface ShippingLaneForm {
+    readonly from: string;
+    readonly to: string;
+    readonly strategy?: io.flow.fulfillment.v0.enums.LaneStrategy;
+    readonly direction?: io.flow.fulfillment.v0.enums.LaneDirection;
+    readonly preference?: io.flow.fulfillment.v0.enums.LanePreselectPreference;
+  }
+
+  interface ShippingLaneSummary {
+    readonly shipping_lane_id: string;
+    readonly region: string;
+    readonly centers: io.flow.fulfillment.v0.unions.ExpandableCenter[];
+  }
+
+  interface ShippingLaneVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly shipping_lane: io.flow.fulfillment.v0.models.ShippingLane;
+  }
+
+  interface SurchargeResponsiblePartyDisplay {
+    readonly name: string;
+    readonly responsible_party: io.flow.fulfillment.v0.enums.SurchargeResponsibleParty;
+  }
+
+  interface SurchargeSetting {
+    readonly key: io.flow.fulfillment.v0.enums.DeliveryOptionCostDetailComponentKey;
+    readonly responsible_party: io.flow.fulfillment.v0.enums.SurchargeResponsibleParty;
+  }
+
+  interface SurchargeSettingDisplay {
+    readonly name: string;
+    readonly description: string;
+    readonly key: io.flow.fulfillment.v0.enums.DeliveryOptionCostDetailComponentKey;
+    readonly available: io.flow.fulfillment.v0.models.SurchargeResponsiblePartyDisplay[];
+  }
+
+  interface Tier {
+    readonly id: string;
+    readonly direction: io.flow.fulfillment.v0.enums.LaneDirection;
+    readonly integration: io.flow.fulfillment.v0.enums.ShipmentIntegrationType;
+    readonly name: string;
+    readonly message?: string;
+    readonly rules: io.flow.fulfillment.v0.models.TierRule[];
+    readonly services: io.flow.reference.v0.models.CarrierService[];
+    readonly strategy: io.flow.fulfillment.v0.enums.TierStrategy;
+    readonly visibility: io.flow.common.v0.enums.Visibility;
+    readonly currency: string;
+    readonly description?: string;
+    readonly display?: io.flow.fulfillment.v0.models.TierDisplay;
+    readonly shipping_lane?: string;
+    readonly surcharge_settings?: io.flow.fulfillment.v0.models.SurchargeSetting[];
+    readonly lane?: io.flow.fulfillment.v0.models.ShippingLaneSummary;
+    readonly settings?: io.flow.fulfillment.v0.models.TierSettings;
+  }
+
+  interface TierDisplay {
+    readonly estimate: io.flow.fulfillment.v0.models.TierEstimate;
+  }
+
+  interface TierDisplayForm {
+    readonly estimate?: io.flow.fulfillment.v0.models.TierEstimate;
+  }
+
+  interface TierEstimate {
+    readonly type: io.flow.fulfillment.v0.enums.TierEstimateType;
+    readonly label?: string;
+  }
+
+  interface TierForm {
+    readonly currency: string;
+    readonly integration: io.flow.fulfillment.v0.enums.ShipmentIntegrationType;
+    readonly name: string;
+    readonly message?: string;
+    readonly rules: io.flow.fulfillment.v0.models.TierRuleForm[];
+    readonly services: string[];
+    readonly strategy: io.flow.fulfillment.v0.enums.TierStrategy;
+    readonly visibility: io.flow.common.v0.enums.Visibility;
+    readonly description?: string;
+    readonly direction?: io.flow.fulfillment.v0.enums.LaneDirection;
+    readonly display?: io.flow.fulfillment.v0.models.TierDisplayForm;
+    readonly shipping_lane: string;
+    readonly surcharge_settings?: io.flow.fulfillment.v0.models.SurchargeSetting[];
+    readonly settings?: io.flow.fulfillment.v0.models.TierSettings;
+  }
+
+  interface TierReference {
+    readonly id: string;
+  }
+
+  interface TierRule {
+    readonly id: string;
+    readonly position: number;
+    readonly query: string;
+    readonly outcome: io.flow.fulfillment.v0.unions.TierRuleOutcome;
+  }
+
+  interface TierRuleForm {
+    readonly position?: number;
+    readonly query: string;
+    readonly outcome: io.flow.fulfillment.v0.unions.TierRuleOutcomeForm;
+  }
+
+  interface TierRuleVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly tier_rule: io.flow.fulfillment.v0.models.TierRule;
+  }
+
+  interface TierSettings {
+    readonly availability: io.flow.fulfillment.v0.enums.TierAvailability;
+  }
+
+  interface TierSummary {
+    readonly id: string;
+    readonly experience?: io.flow.fulfillment.v0.models.FulfillmentExperienceReference;
+    readonly integration: io.flow.fulfillment.v0.enums.ShipmentIntegrationType;
+    readonly name: string;
+    readonly services: string[];
+    readonly strategy: io.flow.fulfillment.v0.enums.TierStrategy;
+    readonly visibility: io.flow.common.v0.enums.Visibility;
+    readonly currency: string;
+    readonly display?: io.flow.fulfillment.v0.models.TierDisplay;
+    readonly message?: string;
+    readonly settings?: io.flow.fulfillment.v0.models.TierSettings;
+  }
+
+  interface TierVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly tier: io.flow.fulfillment.v0.models.TierSummary;
+  }
+
+  interface TransitEstimate {
+    readonly origin: io.flow.fulfillment.v0.enums.DeliveryWindowLocation;
+    readonly destination: io.flow.fulfillment.v0.enums.DeliveryWindowLocation;
+    readonly min_date: string;
+    readonly max_date: string;
+    readonly source: io.flow.fulfillment.v0.enums.DeliveryWindowComponentSource;
+  }
+}
+
+declare namespace io.flow.fulfillment.v0.unions {
+  type Delivery =
+    | io.flow.fulfillment.v0.models.DigitalDelivery
+    | io.flow.fulfillment.v0.models.PhysicalDelivery;
+  type ExpandableCenter =
+    | io.flow.fulfillment.v0.models.Center
+    | io.flow.fulfillment.v0.models.CenterReference;
+  type PartnerCenterFee =
+    | io.flow.fulfillment.v0.models.CommercialInvoiceFee
+    | io.flow.fulfillment.v0.models.InboundCartonFee
+    | io.flow.fulfillment.v0.models.OutboundCartonFee;
+  type ServiceDescription =
+    | io.flow.fulfillment.v0.models.ServiceSummary
+    | io.flow.fulfillment.v0.models.ServiceUnknown;
+  type TierRuleOutcome =
+    | io.flow.fulfillment.v0.models.AmountMargin
+    | io.flow.fulfillment.v0.models.AtCost
+    | io.flow.fulfillment.v0.models.FlatRate
+    | io.flow.fulfillment.v0.models.PercentMargin;
+  type TierRuleOutcomeForm =
+    | io.flow.fulfillment.v0.models.AmountMarginForm
+    | io.flow.fulfillment.v0.models.FlatRateForm
+    | io.flow.fulfillment.v0.models.AtCost
+    | io.flow.fulfillment.v0.models.PercentMargin;
+}
+
+declare namespace io.flow.apple.pay.v0.enums {
+  type ApplePayContactField =
+    | 'email'
+    | 'name'
+    | 'phone'
+    | 'postalAddress'
+    | 'phoneticName';
+  type ApplePayLineItemType = 'final' | 'pending';
+  type ApplePayMerchantCapability =
+    | 'supports3DS'
+    | 'supportsCredit'
+    | 'supportsDebit'
+    | 'supportsEMV';
+  type ApplePayShippingType =
+    | 'shipping'
+    | 'delivery'
+    | 'storePickup'
+    | 'servicePickup';
+  type ApplePaySupportedNetworks =
+    | 'amex'
+    | 'chinaUnionPay'
+    | 'discover'
+    | 'jcb'
+    | 'masterCard'
+    | 'privateLabel'
+    | 'visa';
+}
+
+declare namespace io.flow.apple.pay.v0.models {
+  interface ApplePayLineItem {
+    readonly label: string;
+    readonly type: io.flow.apple.pay.v0.enums.ApplePayLineItemType;
+    readonly amount: string;
+  }
+
+  interface ApplePayPaymentContact {
+    readonly email_address?: string;
+    readonly family_name?: string;
+    readonly given_name?: string;
+    readonly phone_number?: string;
+    readonly phonetic_familyName?: string;
+    readonly phonetic_givenName?: string;
+    readonly address_lines?: string[];
+    readonly locality?: string;
+    readonly sub_locality?: string;
+    readonly administrative_area?: string;
+    readonly sub_administrative_area?: string;
+    readonly postal_code?: string;
+    readonly country?: string;
+    readonly country_code?: string;
+  }
+
+  interface ApplePayPaymentData {
+    readonly applicationPrimaryAccountNumber: string;
+    readonly applicationExpirationDate: string;
+    readonly currencyCode: string;
+    readonly transactionAmount: number;
+    readonly cardholderName?: string;
+    readonly deviceManufacturerIdentifier: string;
+    readonly paymentDataType: string;
+    readonly paymentData: any /*object*/;
+  }
+
+  interface ApplePayPaymentInfo {
+    readonly total: io.flow.apple.pay.v0.models.ApplePayLineItem;
+    readonly line_items?: io.flow.apple.pay.v0.models.ApplePayLineItem[];
+    readonly country_code: string;
+    readonly currency_code: string;
+    readonly merchant_capabilities: io.flow.apple.pay.v0.enums.ApplePayMerchantCapability[];
+    readonly shipping_methods?: io.flow.apple.pay.v0.models.ApplePayShippingMethod[];
+    readonly shipping_type?: io.flow.apple.pay.v0.enums.ApplePayShippingType;
+    readonly supported_countries?: string[];
+    readonly supported_networks: io.flow.apple.pay.v0.enums.ApplePaySupportedNetworks[];
+    readonly required_billingContactFields?: io.flow.apple.pay.v0.enums.ApplePayContactField[];
+    readonly required_shippingContactFields?: io.flow.apple.pay.v0.enums.ApplePayContactField[];
+    readonly billing_contact?: io.flow.apple.pay.v0.models.ApplePayPaymentContact;
+    readonly shipping_contact?: io.flow.apple.pay.v0.models.ApplePayPaymentContact;
+    readonly application_data?: string;
+  }
+
+  interface ApplePayShippingMethod {
+    readonly label: string;
+    readonly detail: string;
+    readonly amount: string;
+    readonly identifier: string;
+  }
+}
+
+declare namespace io.flow.merchant.of.record.v0.enums {
+  type EconomicTitleLocation = 'high_seas' | 'origination' | 'destination';
+  type FlowEntity = 'flow-usa' | 'flow-irl' | 'flow-can' | 'ge-usa';
+}
+
+declare namespace io.flow.currency.v0.models {
+  interface Rate {
+    readonly id: string;
+    readonly base: string;
+    readonly target: string;
+    readonly effective_at: string;
+    readonly value: number;
+  }
+
+  interface RateForm {
+    readonly base: string;
+    readonly target: string;
+    readonly effective_at: string;
+  }
+
+  interface RateVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly rate: io.flow.currency.v0.models.Rate;
+  }
+}
+
+declare namespace io.flow.organization.v0.enums {
+  type CountryPickerSource = 'experience' | 'destination';
+  type EcommercePlatformType =
+    | 'commercetools'
+    | 'custom'
+    | 'hybris'
+    | 'magento'
+    | 'shopify'
+    | 'shopify_markets'
+    | 'sfcc'
+    | 'solidus'
+    | 'workarea';
+  type InvitationErrorCode = 'expired' | 'invalid_email';
+}
+
+declare namespace io.flow.organization.v0.models {
+  interface CountryPicker {
+    readonly id: string;
+    readonly source: io.flow.organization.v0.enums.CountryPickerSource;
+  }
+
+  interface CountryPickerForm {
+    readonly source: io.flow.organization.v0.enums.CountryPickerSource;
+  }
+
+  interface EcommercePlatform {
+    readonly id: string;
+    readonly type: io.flow.organization.v0.enums.EcommercePlatformType;
+    readonly version?: string;
+  }
+
+  interface EcommercePlatformForm {
+    readonly type: io.flow.organization.v0.enums.EcommercePlatformType;
+    readonly version?: string;
+  }
+
+  interface Invitation {
+    readonly id: string;
+    readonly organization: io.flow.common.v0.unions.ExpandableOrganization;
+    readonly email: string;
+    readonly name: io.flow.common.v0.models.Name;
+    readonly role?: io.flow.common.v0.enums.Role;
+    readonly roles?: io.flow.permission.v0.enums.FlowRole[];
+    readonly expiration: string;
+  }
+
+  interface InvitationError {
+    readonly code: io.flow.organization.v0.enums.InvitationErrorCode;
+    readonly messages: string[];
+  }
+
+  interface InvitationForm {
+    readonly organization: string;
+    readonly email: string;
+    readonly name?: io.flow.common.v0.models.Name;
+    readonly role?: io.flow.common.v0.enums.Role;
+    readonly roles?: io.flow.permission.v0.enums.FlowRole[];
+  }
+
+  interface InvitationVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly invitation: io.flow.organization.v0.models.Invitation;
+  }
+
+  interface Membership {
+    readonly id: string;
+    readonly organization: io.flow.common.v0.unions.ExpandableOrganization;
+    readonly user: io.flow.common.v0.unions.ExpandableUser;
+    readonly role?: io.flow.common.v0.enums.Role;
+    readonly roles: io.flow.permission.v0.enums.FlowRole[];
+  }
+
+  interface MembershipForm {
+    readonly organization: string;
+    readonly user: string;
+    readonly role?: io.flow.common.v0.enums.Role;
+    readonly roles?: io.flow.permission.v0.enums.FlowRole[];
+  }
+
+  interface MembershipPutForm {
+    readonly role?: io.flow.common.v0.enums.Role;
+    readonly roles?: io.flow.permission.v0.enums.FlowRole[];
+  }
+
+  interface MembershipVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly membership: io.flow.organization.v0.models.Membership;
+  }
+
+  interface OrganizationAuthorization {
+    readonly role?: io.flow.common.v0.enums.Role;
+    readonly environment: io.flow.common.v0.enums.Environment;
+  }
+
+  interface OrganizationAuthorizationForm {
+    readonly organization: string;
+    readonly environment: io.flow.common.v0.enums.Environment;
+  }
+
+  interface OrganizationConfigurationReference {
+    readonly id: string;
+  }
+
+  interface OrganizationDefaultConfigurations {
+    readonly id: string;
+    readonly checkout_configuration: io.flow.organization.v0.models.OrganizationConfigurationReference;
+  }
+
+  interface OrganizationDefaultConfigurationsForm {
+    readonly id: string;
+  }
+
+  interface OrganizationForm {
+    readonly id?: string;
+    readonly name?: string;
+    readonly environment: io.flow.common.v0.enums.Environment;
+    readonly parent_id?: string;
+    readonly defaults?: io.flow.common.v0.models.OrganizationDefaults;
+    readonly status?: io.flow.common.v0.enums.OrganizationStatus;
+    readonly type?: io.flow.common.v0.enums.OrganizationType;
+  }
+
+  interface OrganizationPutForm {
+    readonly name?: string;
+    readonly environment?: io.flow.common.v0.enums.Environment;
+    readonly parent_id?: string;
+    readonly defaults?: io.flow.common.v0.models.OrganizationDefaults;
+    readonly status?: io.flow.common.v0.enums.OrganizationStatus;
+  }
+
+  interface OrganizationVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly organization: io.flow.common.v0.models.Organization;
+  }
+
+  interface RegionSetting {
+    readonly id: string;
+    readonly region: string;
+    readonly status: io.flow.common.v0.enums.AvailabilityStatus;
+  }
+
+  interface RegionSettingForm {
+    readonly status: io.flow.common.v0.enums.AvailabilityStatus;
+  }
+}
+
+declare namespace io.flow.catalog.v0.enums {
+  type AdjustmentReasonKey = 'duty_deminimis' | 'vat_deminimis';
+  type AttributeIntent =
+    | 'brand'
+    | 'color'
+    | 'countries_of_origin'
+    | 'product_id'
+    | 'fulfillment_method'
+    | 'hazardous'
+    | 'price'
+    | 'size'
+    | 'sku'
+    | 'taxability'
+    | 'consumer_url'
+    | 'gtin'
+    | 'mpn'
+    | 'facet'
+    | 'eccn'
+    | 'returnable'
+    | 'searchable'
+    | 'barcode'
+    | 'min_days_to_ship'
+    | 'max_days_to_ship'
+    | 'commercial_invoice_item_number'
+    | 'include_in_product_feeds';
+  type FulfillmentMethodType = 'fulfillment_method';
+  type FulfillmentMethodValue = 'digital' | 'physical';
+  type ImageTag = 'thumbnail' | 'checkout';
+  type ReturnItemStatus = 'returnable' | 'non-returnable';
+  type SubcatalogItemStatus = 'excluded' | 'included' | 'restricted';
+  type TaxabilityType = 'tax_rule';
+  type TaxabilityValue = 'exempt';
+  type UpdatePolicy = 'auto' | 'queue' | 'discard';
+}
+
+declare namespace io.flow.catalog.v0.models {
+  interface AdjustmentReason {
+    readonly key: io.flow.catalog.v0.enums.AdjustmentReasonKey;
+    readonly label: string;
+  }
+
+  interface Attribute {
+    readonly id: string;
+    readonly key: string;
+    readonly options: io.flow.catalog.v0.models.Options;
+    readonly label?: string;
+    readonly intent?: io.flow.catalog.v0.enums.AttributeIntent;
+    readonly type?: io.flow.common.v0.enums.AttributeDataType;
+    readonly position?: number;
+  }
+
+  interface AttributeForm {
+    readonly key: string;
+    readonly options: io.flow.catalog.v0.models.Options;
+    readonly label?: string;
+    readonly intent?: io.flow.catalog.v0.enums.AttributeIntent;
+    readonly type?: io.flow.common.v0.enums.AttributeDataType;
+    readonly position?: number;
+  }
+
+  interface AttributeVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly attribute: io.flow.catalog.v0.models.Attribute;
+  }
+
+  interface Catalog {
+    readonly id: string;
+  }
+
+  interface CatalogReference {
+    readonly id: string;
+  }
+
+  interface CatalogStatistics {
+    readonly id: string;
+    readonly items: number;
+    readonly categories: number;
+  }
+
+  interface CatalogVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly catalog: io.flow.catalog.v0.models.Catalog;
+  }
+
+  interface FlowItemIndexMetadata {
+    readonly status: io.flow.catalog.v0.enums.SubcatalogItemStatus;
+  }
+
+  interface Image {
+    readonly url: string;
+    readonly tags: io.flow.catalog.v0.enums.ImageTag[];
+    readonly attributes?: Record<string, string>;
+  }
+
+  interface ImageForm {
+    readonly url: string;
+    readonly tags?: io.flow.catalog.v0.enums.ImageTag[];
+    readonly attributes?: Record<string, string>;
+  }
+
+  interface Item {
+    readonly id: string;
+    readonly number: string;
+    readonly locale: string;
+    readonly name: string;
+    readonly price: io.flow.common.v0.models.Price;
+    readonly categories: string[];
+    readonly description?: string;
+    readonly attributes: Record<string, string>;
+    readonly dimensions: io.flow.common.v0.models.Dimensions;
+    readonly images: io.flow.catalog.v0.models.Image[];
+    readonly local?: io.flow.catalog.v0.models.Local;
+    readonly created_at?: string;
+    readonly updated_at?: string;
+    readonly deleted_at?: string;
+  }
+
+  interface ItemAttributesPatchForm {
+    readonly attributes: Record<string, string>;
+  }
+
+  interface ItemForm {
+    readonly number: string;
+    readonly locale: string;
+    readonly name: string;
+    readonly currency: string;
+    readonly price: number;
+    readonly categories?: string[];
+    readonly description?: string;
+    readonly attributes?: Record<string, string>;
+    readonly dimensions?: io.flow.common.v0.models.Dimensions;
+    readonly images?: io.flow.catalog.v0.models.ImageForm[];
+    readonly deleted_at?: string;
+  }
+
+  interface ItemFormOverlay {
+    readonly id: string;
+    readonly number: string;
+    readonly key: string;
+    readonly position: number;
+    readonly price?: io.flow.common.v0.models.Price;
+    readonly categories?: string[];
+    readonly description?: string;
+    readonly attributes?: Record<string, string>;
+    readonly dimensions?: io.flow.common.v0.models.Dimensions;
+    readonly images?: io.flow.catalog.v0.models.ImageForm[];
+    readonly deleted_at?: string;
+  }
+
+  interface ItemFormOverlayForm {
+    readonly number: string;
+    readonly price?: number;
+    readonly currency?: string;
+    readonly position?: number;
+    readonly categories?: string[];
+    readonly description?: string;
+    readonly attributes?: Record<string, string>;
+    readonly dimensions?: io.flow.common.v0.models.Dimensions;
+    readonly images?: io.flow.catalog.v0.models.ImageForm[];
+    readonly deleted_at?: string;
+  }
+
+  interface ItemPriceUpdateForm {
+    readonly number: string;
+    readonly currency?: string;
+    readonly price: number;
+    readonly attributes: Record<string, string>;
+  }
+
+  interface ItemPriceUpdatePutForm {
+    readonly currency?: string;
+    readonly price: number;
+    readonly attributes: Record<string, string>;
+  }
+
+  interface ItemStatistics {
+    readonly items: number;
+    readonly categories: number;
+  }
+
+  interface ItemVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly item: io.flow.catalog.v0.models.Item;
+  }
+
+  interface Local {
+    readonly experience: io.flow.common.v0.models.ExperienceSummary;
+    readonly prices: io.flow.catalog.v0.unions.LocalizedPrice[];
+    readonly rates: io.flow.currency.v0.models.Rate[];
+    readonly spot_rates: any /*object*/[];
+    readonly status: io.flow.catalog.v0.enums.SubcatalogItemStatus;
+    readonly attributes?: Record<string, string>;
+    readonly price_attributes?: Record<
+      string,
+      io.flow.common.v0.models.PriceWithBase
+    >;
+  }
+
+  interface LocalizedAdjustment {
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base: io.flow.common.v0.models.Price;
+    readonly reason: io.flow.catalog.v0.models.AdjustmentReason;
+  }
+
+  interface LocalizedItemDuty {
+    readonly key: 'localized_item_duty';
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base: io.flow.common.v0.models.Price;
+    readonly adjustment?: io.flow.catalog.v0.models.LocalizedAdjustment;
+    readonly basis?: io.flow.common.v0.models.MoneyWithBase;
+  }
+
+  interface LocalizedItemPrice {
+    readonly key: 'localized_item_price';
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base: io.flow.common.v0.models.Price;
+    readonly includes?: io.flow.common.v0.models.IncludedLevies;
+  }
+
+  interface LocalizedItemVat {
+    readonly key: 'localized_item_vat';
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base: io.flow.common.v0.models.Price;
+    readonly name: string;
+    readonly adjustment?: io.flow.catalog.v0.models.LocalizedAdjustment;
+    readonly accuracy?: io.flow.price.v0.enums.PriceAccuracy;
+    readonly basis?: io.flow.common.v0.models.MoneyWithBase;
+  }
+
+  interface LocalizedTotal {
+    readonly key: 'localized_total';
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base: io.flow.common.v0.models.Price;
+  }
+
+  interface Options {
+    readonly required: boolean;
+    readonly show_in_catalog: boolean;
+    readonly show_in_harmonization: boolean;
+  }
+
+  interface Subcatalog {
+    readonly discriminator: 'subcatalog';
+    readonly id: string;
+    readonly catalog: io.flow.catalog.v0.models.Catalog;
+    readonly settings: io.flow.catalog.v0.models.SubcatalogSettings;
+  }
+
+  interface SubcatalogForm {
+    readonly settings?: io.flow.catalog.v0.models.SubcatalogSettingsForm;
+  }
+
+  interface SubcatalogItem {
+    readonly id: string;
+    readonly item: io.flow.catalog.v0.models.Item;
+    readonly status: io.flow.catalog.v0.enums.SubcatalogItemStatus;
+  }
+
+  interface SubcatalogItemVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly subcatalog_item: io.flow.catalog.v0.models.SubcatalogItem;
+  }
+
+  interface SubcatalogReference {
+    readonly discriminator: 'subcatalog_reference';
+    readonly id: string;
+  }
+
+  interface SubcatalogSettings {
+    readonly update_policy: io.flow.catalog.v0.enums.UpdatePolicy;
+  }
+
+  interface SubcatalogSettingsForm {
+    readonly update_policy?: io.flow.catalog.v0.enums.UpdatePolicy;
+  }
+
+  interface SubcatalogStatistics {
+    readonly excluded: io.flow.catalog.v0.models.ItemStatistics;
+    readonly included: io.flow.catalog.v0.models.ItemStatistics;
+    readonly restricted: io.flow.catalog.v0.models.ItemStatistics;
+    readonly queue: io.flow.catalog.v0.models.ItemStatistics;
+    readonly catalog: io.flow.catalog.v0.models.CatalogStatistics;
+  }
+
+  interface SubcatalogVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly subcatalog: io.flow.catalog.v0.models.Subcatalog;
+  }
+}
+
+declare namespace io.flow.catalog.v0.unions {
+  type ExpandableSubcatalog =
+    | io.flow.catalog.v0.models.Subcatalog
+    | io.flow.catalog.v0.models.SubcatalogReference;
+  type LocalizedPrice =
+    | io.flow.catalog.v0.models.LocalizedItemPrice
+    | io.flow.catalog.v0.models.LocalizedItemVat
+    | io.flow.catalog.v0.models.LocalizedItemDuty
+    | io.flow.catalog.v0.models.LocalizedTotal;
+}
+
+declare namespace io.flow.inventory.v0.enums {
+  type Aggregate = 'maximum' | 'minimum';
+  type InventoryStatus = 'has_inventory' | 'no_inventory';
+  type UpdateType = 'change' | 'set';
+}
+
+declare namespace io.flow.inventory.v0.models {
+  interface ExternalApiTimeoutReservationError {
+    readonly code: 'external_api_timeout';
+    readonly messages: string[];
+  }
+
+  interface GenericReservationError {
+    readonly code: 'generic_reservation_error';
+    readonly messages: string[];
+  }
+
+  interface InventoryBackorder {
+    readonly discriminator: 'inventory_backorder';
+    readonly quantity: number;
+  }
+
+  interface InventoryCenterReference {
+    readonly key: string;
+  }
+
+  interface InventoryCheckResponse {
+    readonly items: io.flow.inventory.v0.models.InventoryCheckResponseItem[];
+  }
+
+  interface InventoryCheckResponseItem {
+    readonly number: string;
+    readonly quantity: number;
+    readonly inventory_status: io.flow.inventory.v0.enums.InventoryStatus;
+  }
+
+  interface InventoryExperienceReference {
+    readonly key: string;
+  }
+
+  interface InventoryFollowEcommercePlatform {
+    readonly discriminator: 'inventory_follow_ecommerce_platform';
+    readonly quantity: number;
+  }
+
+  interface InventoryItemReference {
+    readonly number: string;
+  }
+
+  interface InventoryRequest {
+    readonly items: io.flow.inventory.v0.models.InventoryRequestItem[];
+  }
+
+  interface InventoryRequestItem {
+    readonly number: string;
+    readonly quantity: number;
+  }
+
+  interface InventoryRule {
+    readonly id: string;
+    readonly position: number;
+    readonly query: string;
+    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+  }
+
+  interface InventoryRuleForm {
+    readonly position: number;
+    readonly query: string;
+    readonly strategy: io.flow.inventory.v0.unions.InventoryStrategy;
+  }
+
+  interface InventoryRuleVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly inventory_rule: io.flow.inventory.v0.models.InventoryRule;
+  }
+
+  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 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 InventoryStock {
+    readonly discriminator: 'inventory_stock';
+    readonly quantity: number;
+  }
+
+  interface InventoryUnlimited {
+    readonly discriminator: 'inventory_unlimited';
+    readonly placeholder?: 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 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 InventoryUpdateVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly inventory_update: io.flow.inventory.v0.models.InventoryUpdate;
+  }
+
+  interface NoInventoryReservationError {
+    readonly code: 'no_inventory';
+    readonly messages: string[];
+    readonly items: io.flow.inventory.v0.models.NoInventoryReservationErrorItem[];
+  }
+
+  interface NoInventoryReservationErrorItem {
+    readonly number: string;
+    readonly requested_quantity: number;
+    readonly available_quantity: number;
+  }
+
+  interface PfsInventoryCheckResponse {
+    readonly items: Record<
+      string,
+      io.flow.inventory.v0.models.PfsInventoryCheckResponseItem
+    >;
+  }
+
+  interface PfsInventoryCheckResponseItem {
+    readonly number: string;
+    readonly ats: number;
+    readonly in_stock: boolean;
+  }
+
+  interface PfsInventoryStatus {
+    readonly status: string;
+  }
+
+  interface Reservation {
+    readonly id: string;
+    readonly key: string;
+    readonly order?: io.flow.inventory.v0.models.ReservationOrderReference;
+    readonly items: io.flow.inventory.v0.models.ReservationItem[];
+    readonly reserved_until?: string;
+  }
+
+  interface ReservationForm {
+    readonly order_number?: string;
+    readonly items: io.flow.inventory.v0.models.ReservationItemForm[];
+  }
+
+  interface ReservationItem {
+    readonly item: io.flow.inventory.v0.models.ReservationItemReference;
+    readonly quantity: number;
+  }
+
+  interface ReservationItemForm {
+    readonly item_number: string;
+    readonly quantity: number;
+  }
+
+  interface ReservationItemReference {
+    readonly number: string;
+  }
+
+  interface ReservationOrderReference {
+    readonly number: string;
+  }
+}
+
+declare namespace io.flow.inventory.v0.unions {
+  type InventoryStrategy =
+    | io.flow.inventory.v0.models.InventoryBackorder
+    | io.flow.inventory.v0.models.InventoryStock
+    | io.flow.inventory.v0.models.InventoryUnlimited
+    | io.flow.inventory.v0.models.InventoryFollowEcommercePlatform;
+  type ReservationError =
+    | io.flow.inventory.v0.models.NoInventoryReservationError
+    | io.flow.inventory.v0.models.ExternalApiTimeoutReservationError
+    | io.flow.inventory.v0.models.GenericReservationError;
+}
+
+declare namespace io.flow.permission.v0.enums {
+  type AuthenticationTechnique =
+    | 'anonymous'
+    | 'session'
+    | 'token'
+    | 'partner_token'
+    | 'user';
+  type FlowBehavior = 'view_consumer_data';
+  type FlowRole =
+    | 'organization_admin'
+    | 'organization_merchant'
+    | 'organization_customer_service'
+    | 'organization_fulfillment'
+    | 'organization_marketing'
+    | 'organization_finance'
+    | 'organization_classification'
+    | 'flow_operations'
+    | 'channel_admin'
+    | 'channel_organization_admin';
+  type PermittedHttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+}
+
+declare namespace io.flow.permission.v0.models {
+  interface BehaviorAudit {
+    readonly behavior: io.flow.permission.v0.enums.FlowBehavior;
+    readonly authentication_techniques: io.flow.permission.v0.enums.AuthenticationTechnique[];
+    readonly roles: io.flow.permission.v0.enums.FlowRole[];
+  }
+
+  interface PermissionAudit {
+    readonly routes: io.flow.permission.v0.models.RouteAudit[];
+    readonly behaviors: io.flow.permission.v0.models.BehaviorAudit[];
+  }
+
+  interface PermissionCheck {
+    readonly authentication_technique: io.flow.permission.v0.enums.AuthenticationTechnique;
+    readonly user?: io.flow.common.v0.unions.ExpandableUser;
+    readonly roles: io.flow.permission.v0.enums.FlowRole[];
+    readonly behaviors: io.flow.permission.v0.enums.FlowBehavior[];
+    readonly routes: io.flow.permission.v0.models.PermittedRoute[];
+  }
+
+  interface PermittedRoute {
+    readonly method: io.flow.permission.v0.enums.PermittedHttpMethod;
+    readonly path: string;
+  }
+
+  interface RouteAudit {
+    readonly method: io.flow.permission.v0.enums.PermittedHttpMethod;
+    readonly path: string;
+    readonly authentication_techniques: io.flow.permission.v0.enums.AuthenticationTechnique[];
+    readonly roles: io.flow.permission.v0.enums.FlowRole[];
+  }
+
+  interface SimplePermissionCheck {
+    readonly behaviors: io.flow.permission.v0.enums.FlowBehavior[];
+  }
+}
+
+declare namespace io.flow.query.builder.v0.enums {
+  type AvailableFilterFormat =
+    | 'boolean'
+    | 'date'
+    | 'money'
+    | 'decimal'
+    | 'string'
+    | 'unit_of_length'
+    | 'unit_of_mass';
+}
+
+declare namespace io.flow.query.builder.v0.models {
+  interface AvailableFilterStructured {
+    readonly discriminator: 'structured';
+    readonly field: string;
+    readonly operators: string[];
+    readonly format: io.flow.query.builder.v0.enums.AvailableFilterFormat;
+    readonly valid_values?: string[];
+    readonly placeholder?: string;
+  }
+
+  interface AvailableFilterUnstructured {
+    readonly discriminator: 'unstructured';
+    readonly placeholder?: string;
+  }
+
+  interface Query {
+    readonly q: string;
+    readonly filters: io.flow.query.builder.v0.unions.QueryFilter[];
+  }
+
+  interface QueryBuilder {
+    readonly q: string;
+    readonly filters: io.flow.query.builder.v0.unions.QueryFilter[];
+    readonly available: io.flow.query.builder.v0.unions.AvailableFilter[];
+  }
+
+  interface QueryBuilderFilterForm {
+    readonly discriminator: 'filter';
+    readonly filters: io.flow.query.builder.v0.unions.QueryFilterForm[];
   }
 
-  interface ApplePayPaymentData {
-    readonly applicationPrimaryAccountNumber: string;
-    readonly applicationExpirationDate: string;
-    readonly currencyCode: string;
-    readonly transactionAmount: number;
-    readonly cardholderName?: string;
-    readonly deviceManufacturerIdentifier: string;
-    readonly paymentDataType: string;
-    readonly paymentData: any /*object*/;
+  interface QueryBuilderQueryForm {
+    readonly discriminator: 'query';
+    readonly q: string;
   }
 
-  interface ApplePayPaymentInfo {
-    readonly total: io.flow.apple.pay.v0.models.ApplePayLineItem;
-    readonly line_items?: io.flow.apple.pay.v0.models.ApplePayLineItem[];
-    readonly country_code: string;
-    readonly currency_code: string;
-    readonly merchant_capabilities: io.flow.apple.pay.v0.enums.ApplePayMerchantCapability[];
-    readonly shipping_methods?: io.flow.apple.pay.v0.models.ApplePayShippingMethod[];
-    readonly shipping_type?: io.flow.apple.pay.v0.enums.ApplePayShippingType;
-    readonly supported_countries?: string[];
-    readonly supported_networks: io.flow.apple.pay.v0.enums.ApplePaySupportedNetworks[];
-    readonly required_billingContactFields?: io.flow.apple.pay.v0.enums.ApplePayContactField[];
-    readonly required_shippingContactFields?: io.flow.apple.pay.v0.enums.ApplePayContactField[];
-    readonly billing_contact?: io.flow.apple.pay.v0.models.ApplePayPaymentContact;
-    readonly shipping_contact?: io.flow.apple.pay.v0.models.ApplePayPaymentContact;
-    readonly application_data?: string;
+  interface QueryFilterStructured {
+    readonly discriminator: 'structured';
+    readonly q: string;
+    readonly field: string;
+    readonly operator: string;
+    readonly values: string[];
   }
 
-  interface ApplePayShippingMethod {
-    readonly label: string;
-    readonly detail: string;
-    readonly amount: string;
-    readonly identifier: string;
+  interface QueryFilterStructuredForm {
+    readonly discriminator: 'structured';
+    readonly field: string;
+    readonly operator: string;
+    readonly values: string[];
+  }
+
+  interface QueryFilterUnstructured {
+    readonly discriminator: 'unstructured';
+    readonly q: string;
+  }
+
+  interface QueryFilterUnstructuredForm {
+    readonly discriminator: 'unstructured';
+    readonly q: string;
   }
 }
 
+declare namespace io.flow.query.builder.v0.unions {
+  type AvailableFilter =
+    | io.flow.query.builder.v0.models.AvailableFilterStructured
+    | io.flow.query.builder.v0.models.AvailableFilterUnstructured;
+  type QueryBuilderForm =
+    | io.flow.query.builder.v0.models.QueryBuilderFilterForm
+    | io.flow.query.builder.v0.models.QueryBuilderQueryForm;
+  type QueryFilter =
+    | io.flow.query.builder.v0.models.QueryFilterStructured
+    | io.flow.query.builder.v0.models.QueryFilterUnstructured;
+  type QueryFilterForm =
+    | io.flow.query.builder.v0.models.QueryFilterStructuredForm
+    | io.flow.query.builder.v0.models.QueryFilterUnstructuredForm;
+}
+
 declare namespace io.flow.v0.enums {
   type AbandonedOrderPromotionStatus = 'active' | 'inactive';
   type AbandonedOrderSettingStatus = 'active' | 'inactive';
@@ -3004,7 +5472,6 @@ declare namespace io.flow.v0.enums {
     | 'not_checked'
     | 'not_matched';
   type AdjustmentReasonKey = 'duty_deminimis' | 'vat_deminimis';
-  type Aggregate = 'maximum' | 'minimum';
   type AttributeDataType =
     | 'boolean'
     | 'integer'
@@ -3194,7 +5661,7 @@ declare namespace io.flow.v0.enums {
     | 'solidus'
     | 'workarea';
   type EconomicTitleLocation = 'high_seas' | 'origination' | 'destination';
-  type EntityIdentifierType = 'ioss' | 'voec';
+  type EntityIdentifierType = 'ioss' | 'voec' | 'zaz';
   type Environment = 'sandbox' | 'production';
   type EventType =
     | 'test_upserted'
@@ -3322,10 +5789,6 @@ declare namespace io.flow.v0.enums {
     | 'fully_harmonized_item_upserted'
     | 'import_completed_v2'
     | 'import_failed_v2'
-    | 'rule_upserted'
-    | 'rule_deleted'
-    | 'snapshot_upserted'
-    | 'snapshot_deleted'
     | 'label_upserted'
     | 'label_deleted_v2'
     | 'label_upserted_v2'
@@ -3476,6 +5939,7 @@ declare namespace io.flow.v0.enums {
     | 'DES'
     | 'DEQ'
     | 'DDU';
+  type IncotermConfiguration = 'DDP' | 'DAP' | 'DDU' | 'UNSUPPORTED';
   type InlineWindowViewportSize =
     | 'xxx_small'
     | 'xx_small'
@@ -3484,7 +5948,6 @@ declare namespace io.flow.v0.enums {
     | 'fullscreen'
     | 'responsive';
   type InputSpecificationType = 'text' | 'number';
-  type InventoryStatus = 'has_inventory' | 'no_inventory';
   type InvitationErrorCode = 'expired' | 'invalid_email';
   type ItemAvailabilityStatus = 'available' | 'low' | 'out_of_stock';
   type ItemIdentifier = 'item_number' | 'sku';
@@ -4065,7 +6528,6 @@ declare namespace io.flow.v0.enums {
   type UnitOfVolume = 'cubic_inch' | 'cubic_meter';
   type UnitOfWeight = 'gram' | 'kilogram' | 'ounce' | 'pound';
   type UpdatePolicy = 'auto' | 'queue' | 'discard';
-  type UpdateType = 'change' | 'set';
   type UserStatus = 'pending' | 'active' | 'inactive';
   type ValueAddedService = 'Hazardous Material';
   type Visibility = 'public' | 'private';
@@ -7405,11 +9867,6 @@ declare namespace io.flow.v0.models {
     readonly export: io.flow.v0.models.Export;
   }
 
-  interface ExternalApiTimeoutReservationError {
-    readonly code: 'external_api_timeout';
-    readonly messages: string[];
-  }
-
   interface FeeDeduction {
     readonly type: io.flow.v0.enums.FeeDeductionType;
     readonly amount: number;
@@ -7722,11 +10179,6 @@ declare namespace io.flow.v0.models {
     readonly messages: string[];
   }
 
-  interface GenericReservationError {
-    readonly code: 'generic_reservation_error';
-    readonly messages: string[];
-  }
-
   interface GeoForm {
     readonly country: string;
     readonly currency: string;
@@ -8058,6 +10510,17 @@ declare namespace io.flow.v0.models {
     readonly label: string;
   }
 
+  interface IncotermIncludes {
+    readonly duties: boolean;
+    readonly taxes: boolean;
+  }
+
+  interface IncotermSummary {
+    readonly configuration: io.flow.v0.enums.IncotermConfiguration;
+    readonly includes: io.flow.v0.models.IncotermIncludes;
+    readonly reason?: string;
+  }
+
   interface IndirectTax {
     readonly number?: string;
     readonly id?: string;
@@ -8115,118 +10578,6 @@ declare namespace io.flow.v0.models {
     readonly limitations?: io.flow.v0.unions.InputSpecificationLimitation[];
   }
 
-  interface InventoryBackorder {
-    readonly discriminator: 'inventory_backorder';
-    readonly quantity: number;
-  }
-
-  interface InventoryCenterReference {
-    readonly key: string;
-  }
-
-  interface InventoryCheckResponse {
-    readonly items: io.flow.v0.models.InventoryCheckResponseItem[];
-  }
-
-  interface InventoryCheckResponseItem {
-    readonly number: string;
-    readonly quantity: number;
-    readonly inventory_status: io.flow.v0.enums.InventoryStatus;
-  }
-
-  interface InventoryExperienceReference {
-    readonly key: string;
-  }
-
-  interface InventoryFollowEcommercePlatform {
-    readonly discriminator: 'inventory_follow_ecommerce_platform';
-    readonly quantity: number;
-  }
-
-  interface InventoryItemReference {
-    readonly number: string;
-  }
-
-  interface InventoryRequest {
-    readonly items: io.flow.v0.models.InventoryRequestItem[];
-  }
-
-  interface InventoryRequestItem {
-    readonly number: string;
-    readonly quantity: number;
-  }
-
-  interface InventoryRule {
-    readonly id: string;
-    readonly position: number;
-    readonly query: string;
-    readonly strategy: io.flow.v0.unions.InventoryStrategy;
-  }
-
-  interface InventoryRuleForm {
-    readonly position: number;
-    readonly query: string;
-    readonly strategy: io.flow.v0.unions.InventoryStrategy;
-  }
-
-  interface InventoryRuleVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.v0.enums.ChangeType;
-    readonly inventory_rule: io.flow.v0.models.InventoryRule;
-  }
-
-  interface InventorySnapshot {
-    readonly id: string;
-    readonly available: number;
-    readonly center: io.flow.v0.models.InventoryCenterReference;
-    readonly item: io.flow.v0.models.InventoryItemReference;
-    readonly quantity: number;
-  }
-
-  interface InventorySnapshotVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.v0.enums.ChangeType;
-    readonly inventory_snapshot: io.flow.v0.models.InventorySnapshot;
-  }
-
-  interface InventoryStock {
-    readonly discriminator: 'inventory_stock';
-    readonly quantity: number;
-  }
-
-  interface InventoryUnlimited {
-    readonly discriminator: 'inventory_unlimited';
-    readonly placeholder?: string;
-  }
-
-  interface InventoryUpdate {
-    readonly id: string;
-    readonly idempotency_key: string;
-    readonly center: io.flow.v0.models.InventoryCenterReference;
-    readonly item: io.flow.v0.models.InventoryItemReference;
-    readonly notes: any /*object*/;
-    readonly quantity: number;
-    readonly type: io.flow.v0.enums.UpdateType;
-  }
-
-  interface InventoryUpdateForm {
-    readonly center: string;
-    readonly idempotency_key: string;
-    readonly item_number: string;
-    readonly quantity: number;
-    readonly type: io.flow.v0.enums.UpdateType;
-    readonly notes?: any /*object*/;
-  }
-
-  interface InventoryUpdateVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.v0.enums.ChangeType;
-    readonly inventory_update: io.flow.v0.models.InventoryUpdate;
-  }
-
   interface Invitation {
     readonly id: string;
     readonly organization: io.flow.v0.unions.ExpandableOrganization;
@@ -9256,18 +11607,6 @@ declare namespace io.flow.v0.models {
     readonly last?: string;
   }
 
-  interface NoInventoryReservationError {
-    readonly code: 'no_inventory';
-    readonly messages: string[];
-    readonly items: io.flow.v0.models.NoInventoryReservationErrorItem[];
-  }
-
-  interface NoInventoryReservationErrorItem {
-    readonly number: string;
-    readonly requested_quantity: number;
-    readonly available_quantity: number;
-  }
-
   interface NotificationDeletedV2 {
     readonly discriminator: 'notification_deleted_v2';
     readonly event_id: string;
@@ -9417,6 +11756,7 @@ declare namespace io.flow.v0.models {
     readonly geo?: io.flow.v0.models.OrderGeo;
     readonly device_details?: io.flow.v0.unions.DeviceDetails;
     readonly destination_contact_details?: io.flow.v0.models.DestinationContactDetail[];
+    readonly incoterm_summary?: io.flow.v0.models.IncotermSummary;
   }
 
   interface OrderAddress {
@@ -11260,23 +13600,6 @@ declare namespace io.flow.v0.models {
     readonly path: string;
   }
 
-  interface PfsInventoryCheckResponse {
-    readonly items: Record<
-      string,
-      io.flow.v0.models.PfsInventoryCheckResponseItem
-    >;
-  }
-
-  interface PfsInventoryCheckResponseItem {
-    readonly number: string;
-    readonly ats: number;
-    readonly in_stock: boolean;
-  }
-
-  interface PfsInventoryStatus {
-    readonly status: string;
-  }
-
   interface PhysicalDelivery {
     readonly discriminator: 'physical_delivery';
     readonly id: string;
@@ -12234,37 +14557,6 @@ declare namespace io.flow.v0.models {
     readonly days_of_week: io.flow.v0.enums.DayOfWeek[];
   }
 
-  interface Reservation {
-    readonly id: string;
-    readonly key: string;
-    readonly order?: io.flow.v0.models.ReservationOrderReference;
-    readonly items: io.flow.v0.models.ReservationItem[];
-    readonly reserved_until?: string;
-  }
-
-  interface ReservationForm {
-    readonly order_number?: string;
-    readonly items: io.flow.v0.models.ReservationItemForm[];
-  }
-
-  interface ReservationItem {
-    readonly item: io.flow.v0.models.ReservationItemReference;
-    readonly quantity: number;
-  }
-
-  interface ReservationItemForm {
-    readonly item_number: string;
-    readonly quantity: number;
-  }
-
-  interface ReservationItemReference {
-    readonly number: string;
-  }
-
-  interface ReservationOrderReference {
-    readonly number: string;
-  }
-
   interface Return {
     readonly id: string;
     readonly key: string;
@@ -12498,21 +14790,6 @@ declare namespace io.flow.v0.models {
     readonly roles: io.flow.v0.enums.FlowRole[];
   }
 
-  interface RuleDeleted {
-    readonly discriminator: 'rule_deleted';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly id: string;
-  }
-
-  interface RuleUpserted {
-    readonly discriminator: 'rule_upserted';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization_id: string;
-    readonly rule: io.flow.v0.models.InventoryRule;
-  }
-
   interface Schedule {
     readonly calendar?: io.flow.v0.enums.Calendar;
     readonly holiday: io.flow.v0.enums.HolidayCalendar;
@@ -13347,25 +15624,6 @@ declare namespace io.flow.v0.models {
     readonly shipment_recipient?: io.flow.v0.enums.ShipmentRecipient;
   }
 
-  interface SnapshotDeleted {
-    readonly discriminator: 'snapshot_deleted';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly snapshot_id: string;
-  }
-
-  interface SnapshotUpserted {
-    readonly discriminator: 'snapshot_upserted';
-    readonly event_id: string;
-    readonly timestamp: string;
-    readonly organization: string;
-    readonly snapshot_id: string;
-    readonly available: number;
-    readonly center_key: string;
-    readonly item_number: string;
-    readonly quantity: number;
-  }
-
   interface SolidusProductExportType {
     readonly discriminator: 'solidus_product_export_type';
     readonly numbers?: string[];
@@ -13770,6 +16028,11 @@ declare namespace io.flow.v0.models {
     readonly eci?: string;
     readonly liability_sift?: boolean;
     readonly version?: string;
+    readonly authenticated?: boolean;
+    readonly authenticated_result?: string;
+    readonly offered?: boolean;
+    readonly offered_result?: string;
+    readonly sca_exemption?: string;
   }
 
   interface ThreedsChallengeActionDetails {
@@ -13955,6 +16218,7 @@ declare namespace io.flow.v0.models {
     readonly status: io.flow.v0.enums.TrackingStatus;
     readonly timestamp: string;
     readonly description?: string;
+    readonly aggregator_status_code?: string;
   }
 
   interface TrackingEventForm {
@@ -14745,10 +17009,6 @@ declare namespace io.flow.v0.unions {
     | io.flow.v0.models.FullyHarmonizedItemUpserted
     | io.flow.v0.models.ImportCompletedV2
     | io.flow.v0.models.ImportFailedV2
-    | io.flow.v0.models.RuleUpserted
-    | io.flow.v0.models.RuleDeleted
-    | io.flow.v0.models.SnapshotUpserted
-    | io.flow.v0.models.SnapshotDeleted
     | io.flow.v0.models.LabelUpserted
     | io.flow.v0.models.LabelDeletedV2
     | io.flow.v0.models.LabelUpsertedV2
@@ -14890,11 +17150,6 @@ declare namespace io.flow.v0.unions {
     io.flow.v0.models.BrowserInlineActionConfiguration;
   type InputSpecificationLimitation =
     io.flow.v0.models.InputSpecificationLimitationMax;
-  type InventoryStrategy =
-    | io.flow.v0.models.InventoryBackorder
-    | io.flow.v0.models.InventoryStock
-    | io.flow.v0.models.InventoryUnlimited
-    | io.flow.v0.models.InventoryFollowEcommercePlatform;
   type KnowYourBusiness = io.flow.v0.models.KnowYourBusinessUsa;
   type KnowYourBusinessForm = io.flow.v0.models.KnowYourBusinessUsaForm;
   type LabelSurchargeDetail =
@@ -15069,10 +17324,6 @@ declare namespace io.flow.v0.unions {
     | io.flow.v0.models.RepeatDaily
     | io.flow.v0.models.RepeatWeekly
     | io.flow.v0.models.RepeatMonthly;
-  type ReservationError =
-    | io.flow.v0.models.NoInventoryReservationError
-    | io.flow.v0.models.ExternalApiTimeoutReservationError
-    | io.flow.v0.models.GenericReservationError;
   type ReturnSource =
     | io.flow.v0.models.ReturnSourceFlow
     | io.flow.v0.models.ReturnSourceExternalVendor;
@@ -15229,7 +17480,6 @@ export type AdyenNativeActionDetails =
 export type AdyenNativeData = io.flow.v0.unions.AdyenNativeData;
 export type AdyenV3ChallengeToken = io.flow.v0.models.AdyenV3ChallengeToken;
 export type AdyenV3FingerprintToken = io.flow.v0.models.AdyenV3FingerprintToken;
-export type Aggregate = io.flow.v0.enums.Aggregate;
 export type Allocation = io.flow.v0.models.Allocation;
 export type AllocationComponent = io.flow.v0.unions.AllocationComponent;
 export type AllocationDeletedV2 = io.flow.v0.models.AllocationDeletedV2;
@@ -15889,8 +18139,6 @@ export type ExportStatus = io.flow.v0.enums.ExportStatus;
 export type ExportType = io.flow.v0.unions.ExportType;
 export type ExportVersion = io.flow.v0.models.ExportVersion;
 export type ExporterOfRecord = io.flow.v0.enums.ExporterOfRecord;
-export type ExternalApiTimeoutReservationError =
-  io.flow.v0.models.ExternalApiTimeoutReservationError;
 export type FeeDeduction = io.flow.v0.models.FeeDeduction;
 export type FeeDeductionType = io.flow.v0.enums.FeeDeductionType;
 export type FeeWeight = io.flow.v0.models.FeeWeight;
@@ -15977,7 +18225,6 @@ export type GatewayAuthenticationDataForm =
 export type GenerateLoad = io.flow.v0.models.GenerateLoad;
 export type GenericError = io.flow.v0.models.GenericError;
 export type GenericErrorCode = io.flow.v0.enums.GenericErrorCode;
-export type GenericReservationError = io.flow.v0.models.GenericReservationError;
 export type GeoForm = io.flow.v0.models.GeoForm;
 export type GoodsSupply = io.flow.v0.enums.GoodsSupply;
 export type GooglePayAuthorizationPayload =
@@ -16039,6 +18286,9 @@ export type InboundCartonFee = io.flow.v0.models.InboundCartonFee;
 export type IncludedLevies = io.flow.v0.models.IncludedLevies;
 export type IncludedLevyKey = io.flow.v0.enums.IncludedLevyKey;
 export type Incoterm = io.flow.v0.enums.Incoterm;
+export type IncotermConfiguration = io.flow.v0.enums.IncotermConfiguration;
+export type IncotermIncludes = io.flow.v0.models.IncotermIncludes;
+export type IncotermSummary = io.flow.v0.models.IncotermSummary;
 export type IndirectTax = io.flow.v0.models.IndirectTax;
 export type Individual = io.flow.v0.models.Individual;
 export type InlineActionConfiguration =
@@ -16058,32 +18308,6 @@ export type InputSpecificationLimitationMax =
 export type InputSpecificationLimitations =
   io.flow.v0.models.InputSpecificationLimitations;
 export type InputSpecificationType = io.flow.v0.enums.InputSpecificationType;
-export type InventoryBackorder = io.flow.v0.models.InventoryBackorder;
-export type InventoryCenterReference =
-  io.flow.v0.models.InventoryCenterReference;
-export type InventoryCheckResponse = io.flow.v0.models.InventoryCheckResponse;
-export type InventoryCheckResponseItem =
-  io.flow.v0.models.InventoryCheckResponseItem;
-export type InventoryExperienceReference =
-  io.flow.v0.models.InventoryExperienceReference;
-export type InventoryFollowEcommercePlatform =
-  io.flow.v0.models.InventoryFollowEcommercePlatform;
-export type InventoryItemReference = io.flow.v0.models.InventoryItemReference;
-export type InventoryRequest = io.flow.v0.models.InventoryRequest;
-export type InventoryRequestItem = io.flow.v0.models.InventoryRequestItem;
-export type InventoryRule = io.flow.v0.models.InventoryRule;
-export type InventoryRuleForm = io.flow.v0.models.InventoryRuleForm;
-export type InventoryRuleVersion = io.flow.v0.models.InventoryRuleVersion;
-export type InventorySnapshot = io.flow.v0.models.InventorySnapshot;
-export type InventorySnapshotVersion =
-  io.flow.v0.models.InventorySnapshotVersion;
-export type InventoryStatus = io.flow.v0.enums.InventoryStatus;
-export type InventoryStock = io.flow.v0.models.InventoryStock;
-export type InventoryStrategy = io.flow.v0.unions.InventoryStrategy;
-export type InventoryUnlimited = io.flow.v0.models.InventoryUnlimited;
-export type InventoryUpdate = io.flow.v0.models.InventoryUpdate;
-export type InventoryUpdateForm = io.flow.v0.models.InventoryUpdateForm;
-export type InventoryUpdateVersion = io.flow.v0.models.InventoryUpdateVersion;
 export type Invitation = io.flow.v0.models.Invitation;
 export type InvitationError = io.flow.v0.models.InvitationError;
 export type InvitationErrorCode = io.flow.v0.enums.InvitationErrorCode;
@@ -16280,10 +18504,6 @@ export type MonthlyAverage = io.flow.v0.models.MonthlyAverage;
 export type MonthlyAverageVolume = io.flow.v0.models.MonthlyAverageVolume;
 export type Name = io.flow.v0.models.Name;
 export type NameForm = io.flow.v0.models.NameForm;
-export type NoInventoryReservationError =
-  io.flow.v0.models.NoInventoryReservationError;
-export type NoInventoryReservationErrorItem =
-  io.flow.v0.models.NoInventoryReservationErrorItem;
 export type NotificationDeletedV2 = io.flow.v0.models.NotificationDeletedV2;
 export type NotificationUpsertedV2 = io.flow.v0.models.NotificationUpsertedV2;
 export type NumberRange = io.flow.v0.models.NumberRange;
@@ -16775,11 +18995,6 @@ export type PermissionAudit = io.flow.v0.models.PermissionAudit;
 export type PermissionCheck = io.flow.v0.models.PermissionCheck;
 export type PermittedHttpMethod = io.flow.v0.enums.PermittedHttpMethod;
 export type PermittedRoute = io.flow.v0.models.PermittedRoute;
-export type PfsInventoryCheckResponse =
-  io.flow.v0.models.PfsInventoryCheckResponse;
-export type PfsInventoryCheckResponseItem =
-  io.flow.v0.models.PfsInventoryCheckResponseItem;
-export type PfsInventoryStatus = io.flow.v0.models.PfsInventoryStatus;
 export type PhysicalDelivery = io.flow.v0.models.PhysicalDelivery;
 export type PhysicalDeliveryPreferredService =
   io.flow.v0.models.PhysicalDeliveryPreferredService;
@@ -16946,15 +19161,6 @@ export type RepeatHourly = io.flow.v0.models.RepeatHourly;
 export type RepeatMonthly = io.flow.v0.models.RepeatMonthly;
 export type RepeatSchedule = io.flow.v0.unions.RepeatSchedule;
 export type RepeatWeekly = io.flow.v0.models.RepeatWeekly;
-export type Reservation = io.flow.v0.models.Reservation;
-export type ReservationError = io.flow.v0.unions.ReservationError;
-export type ReservationForm = io.flow.v0.models.ReservationForm;
-export type ReservationItem = io.flow.v0.models.ReservationItem;
-export type ReservationItemForm = io.flow.v0.models.ReservationItemForm;
-export type ReservationItemReference =
-  io.flow.v0.models.ReservationItemReference;
-export type ReservationOrderReference =
-  io.flow.v0.models.ReservationOrderReference;
 export type RestrictedReviewStatus = io.flow.v0.enums.RestrictedReviewStatus;
 export type Return = io.flow.v0.models.Return;
 export type ReturnDeleted = io.flow.v0.models.ReturnDeleted;
@@ -17001,8 +19207,6 @@ export type Rounding = io.flow.v0.models.Rounding;
 export type RoundingMethod = io.flow.v0.enums.RoundingMethod;
 export type RoundingType = io.flow.v0.enums.RoundingType;
 export type RouteAudit = io.flow.v0.models.RouteAudit;
-export type RuleDeleted = io.flow.v0.models.RuleDeleted;
-export type RuleUpserted = io.flow.v0.models.RuleUpserted;
 export type Schedule = io.flow.v0.models.Schedule;
 export type ScheduleExceptionStatus = io.flow.v0.enums.ScheduleExceptionStatus;
 export type ScheduledExport = io.flow.v0.models.ScheduledExport;
@@ -17186,8 +19390,6 @@ export type ShopifyVariantInventoryMetafield =
 export type SimplePermissionCheck = io.flow.v0.models.SimplePermissionCheck;
 export type SinglePackageShippingNotificationForm =
   io.flow.v0.models.SinglePackageShippingNotificationForm;
-export type SnapshotDeleted = io.flow.v0.models.SnapshotDeleted;
-export type SnapshotUpserted = io.flow.v0.models.SnapshotUpserted;
 export type SolidusProductExportType =
   io.flow.v0.models.SolidusProductExportType;
 export type SolidusVariantExportType =
@@ -17407,7 +19609,6 @@ export type UnitOfTime = io.flow.v0.enums.UnitOfTime;
 export type UnitOfVolume = io.flow.v0.enums.UnitOfVolume;
 export type UnitOfWeight = io.flow.v0.enums.UnitOfWeight;
 export type UpdatePolicy = io.flow.v0.enums.UpdatePolicy;
-export type UpdateType = io.flow.v0.enums.UpdateType;
 export type Upload = io.flow.v0.models.Upload;
 export type User = io.flow.v0.models.User;
 export type UserForm = io.flow.v0.models.UserForm;