@flowio/types 11.24.79 → 11.24.81

package/src/api-internal.ts

@@ -2400,10 +2400,18 @@ declare namespace io.flow.billing.csv.v0.models {
   interface BillingCsvTransactionMetadata {
     readonly channel?: io.flow.billing.csv.v0.models.BillingCsvTransactionMetadataChannel;
     readonly shipping_label?: io.flow.billing.csv.v0.models.BillingCsvTransactionMetadataShippingLabel;
+    readonly shipping_label_revenue_share?: io.flow.billing.csv.v0.models.BillingCsvTransactionMetadataShippingLabelRevenueShare;
     readonly trueup?: io.flow.billing.csv.v0.models.BillingCsvTransactionMetadataTrueup;
+    readonly carrier_charge?: io.flow.billing.csv.v0.models.BillingCsvTransactionMetadataCarrierCharge;
     readonly manual?: io.flow.billing.csv.v0.models.BillingCsvTransactionMetadataManual;
   }
 
+  interface BillingCsvTransactionMetadataCarrierCharge {
+    readonly reason: io.flow.trueup.v0.enums.CarrierChargeReason;
+    readonly carrier_id: string;
+    readonly carrier_tracking_number: string;
+  }
+
   interface BillingCsvTransactionMetadataChannel {
     readonly method: string;
     readonly card?: io.flow.billing.v0.models.TransactionMetadataChannelCardMetadata;
@@ -2418,6 +2426,12 @@ declare namespace io.flow.billing.csv.v0.models {
     readonly request_method?: io.flow.label.v0.enums.LabelRequestMethod;
   }
 
+  interface BillingCsvTransactionMetadataShippingLabelRevenueShare {
+    readonly label_id: string;
+    readonly base_amount?: number;
+    readonly percentage?: number;
+  }
+
   interface BillingCsvTransactionMetadataTrueup {
     readonly original: io.flow.billing.v0.models.TransactionMetadataOriginalTransaction;
   }
@@ -7250,6 +7264,19 @@ declare namespace io.flow.shopify.external.v0.models {
 }
 
 declare namespace io.flow.shopify.markets.v0.enums {
+  type BulkOperationErrorCode =
+    | 'access_denied'
+    | 'internal_server_error'
+    | 'timeout';
+  type BulkOperationStatus =
+    | 'canceled'
+    | 'canceling'
+    | 'completed'
+    | 'created'
+    | 'expired'
+    | 'failed'
+    | 'running';
+  type BulkOperationType = 'mutation' | 'query';
   type CancelReason = 'customer' | 'fraud' | 'inventory' | 'declined' | 'other';
   type FulfillmentOrderDeliveryMethodType =
     | 'local'
@@ -7428,7 +7455,8 @@ declare namespace io.flow.shopify.markets.v0.enums {
     | 'shop/redact'
     | 'themes/create'
     | 'themes/publish'
-    | 'themes/update';
+    | 'themes/update'
+    | 'bulk_operations/finish';
 }
 
 declare namespace io.flow.shopify.markets.v0.models {
@@ -7502,6 +7530,15 @@ declare namespace io.flow.shopify.markets.v0.models {
     readonly amount?: number;
   }
 
+  interface ShopifyBulkOperationsFinish {
+    readonly admin_graphql_api_id: string;
+    readonly completed_at?: string;
+    readonly created_at: string;
+    readonly error_code?: io.flow.shopify.markets.v0.enums.BulkOperationErrorCode;
+    readonly status: io.flow.shopify.markets.v0.enums.BulkOperationStatus;
+    readonly type: io.flow.shopify.markets.v0.enums.BulkOperationType;
+  }
+
   interface ShopifyCountryHarmonizedSystemCode {
     readonly country_code: string;
     readonly harmonized_system_code: string;
@@ -8571,6 +8608,8 @@ declare namespace io.flow.payment.gateway.v0.models {
     readonly status: io.flow.payment.gateway.v0.models.PaymentAuthorizationStatus;
     readonly amount: number;
     readonly currency: string;
+    readonly base_amount?: number;
+    readonly base_currency?: string;
   }
 
   interface PaymentAuthorizationStatus {
@@ -8582,6 +8621,8 @@ declare namespace io.flow.payment.gateway.v0.models {
     readonly id: string;
     readonly amount: number;
     readonly currency: string;
+    readonly base_amount?: number;
+    readonly base_currency?: string;
     readonly created_at: string;
     readonly updated_at: string;
     readonly status: io.flow.payment.gateway.v0.models.PaymentCaptureStatus;
@@ -8888,6 +8929,8 @@ declare namespace io.flow.payment.gateway.v0.models {
     readonly id: string;
     readonly amount: number;
     readonly currency: string;
+    readonly base_amount?: number;
+    readonly base_currency?: string;
     readonly created_at: string;
     readonly updated_at: string;
     readonly status: io.flow.payment.gateway.v0.models.PaymentRefundStatus;
@@ -8913,6 +8956,8 @@ declare namespace io.flow.payment.gateway.v0.models {
     readonly next_action?: io.flow.payment.gateway.v0.unions.Action;
     readonly amount: number;
     readonly currency: string;
+    readonly base_amount?: number;
+    readonly base_currency?: string;
     readonly order_information: io.flow.payment.gateway.v0.unions.OrderInformation;
     readonly device_details: io.flow.payment.v0.unions.DeviceDetails;
     readonly locale?: string;
@@ -8958,6 +9003,8 @@ declare namespace io.flow.payment.gateway.v0.models {
     readonly id: string;
     readonly amount: number;
     readonly currency: string;
+    readonly base_amount?: number;
+    readonly base_currency?: string;
     readonly created_at: string;
     readonly updated_at: string;
     readonly status: io.flow.payment.gateway.v0.models.PaymentReversalStatus;
@@ -9201,6 +9248,11 @@ declare namespace io.flow.channel.internal.v0.models {
     readonly order_updated_at?: string;
   }
 
+  interface ChannelOrderAcceptanceDetails {
+    readonly order_acceptance: io.flow.channel.internal.v0.models.ChannelOrderAcceptance;
+    readonly external_order: any /*object*/;
+  }
+
   interface ChannelOrderAcceptanceForm {
     readonly status: io.flow.channel.internal.v0.enums.ChannelOrderAcceptanceStatus;
   }
@@ -9215,806 +9267,1050 @@ declare namespace io.flow.channel.internal.v0.models {
   }
 }
 
-declare namespace io.flow.payment.internal.v0.enums {
-  type AdyenIntegrationType =
-    | 'hosted_payment_page'
-    | 'checkout_payments_api'
-    | 'classic_authorise_api';
-  type ChargebackPaymentStatus = 'captured' | 'refunded';
-  type ChargebackProcessStatus = 'inquiry' | 'open' | 'closed';
-  type HttpMethod = 'get' | 'post';
-  type OrganizationCapability = 'organization' | 'flow' | 'dynamic';
-  type OrganizationPaymentStatus = 'active' | 'archived';
-  type Owner = 'flow' | 'organization';
-  type Processor =
-    | 'adyen'
-    | 'afterpay'
-    | 'bitpay'
-    | 'stripe'
-    | 'paypal'
-    | 'flow_sandbox'
-    | 'fiserv'
-    | 'crypto';
-  type ProcessorEntityStatus = 'active' | 'draft' | 'archived';
-  type RedirectReason = 'three_d_secure';
-  type RiskCheck = 'three_d_secure';
+declare namespace io.flow.partner.v0.enums {
+  type LabelFormat = 'pdf' | 'zpl' | 'all';
 }
 
-declare namespace io.flow.payment.internal.v0.models {
-  interface AdyenAccount {
-    readonly discriminator: 'adyen_account';
-    readonly id: string;
-    readonly organization_id: string;
-    readonly key: string;
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly name: string;
-    readonly ui_reference: string;
-    readonly authentication: io.flow.payment.internal.v0.models.AdyenAuthentication;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
+declare namespace io.flow.partner.v0.models {
+  interface BridgeHub {
+    readonly hub_code: string;
+    readonly address: io.flow.fulfillment.v0.models.ShippingAddress;
   }
 
-  interface AdyenAccountModificationForm {
-    readonly discriminator: 'adyen_account_modification_form';
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly name: string;
-    readonly ui_reference: string;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  interface BridgeLabelForm {
+    readonly discriminator: 'bridge_label_form';
+    readonly organization: string;
+    readonly order_number: string;
+    readonly package: io.flow.partner.v0.models.BridgeLabelPackage;
+    readonly hub?: io.flow.partner.v0.models.BridgeHub;
   }
 
-  interface AdyenAccountPutForm {
-    readonly discriminator: 'adyen_account_put_form';
-    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
-    readonly name: string;
-    readonly ui_reference: string;
-    readonly authentication: io.flow.payment.internal.v0.models.AdyenAuthenticationForm;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface BridgeLabelPackage {
+    readonly dimensions?: io.flow.common.v0.models.Dimension;
+    readonly items: io.flow.common.v0.models.LineItemForm[];
+    readonly reference_number: string;
   }
 
-  interface AdyenAuthentication {
-    readonly username: string;
-    readonly password_reference: string;
-    readonly signature_secret_reference: string;
+  interface DetailedLabelForm {
+    readonly discriminator: 'detailed_label_form';
+    readonly organization: string;
+    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly order_number: string;
+    readonly origin: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly package: io.flow.label.v0.models.ShippingLabelPackage;
+    readonly service?: string;
+    readonly references?: string[];
   }
 
-  interface AdyenAuthenticationDataReference {
-    readonly account_id: string;
-    readonly merchant_account: string;
-    readonly origin_key?: string;
-    readonly integration_type?: io.flow.payment.internal.v0.enums.AdyenIntegrationType;
+  interface Label {
+    readonly id: string;
+    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
+    readonly order_number: string;
+    readonly package: io.flow.label.v0.models.ShippingLabelPackage;
+    readonly carrier_tracking_number: string;
+    readonly carrier_tracking_number_url: string;
+    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly flow_tracking_number: string;
+    readonly flow_tracking_number_url: string;
+    readonly origin: io.flow.fulfillment.v0.models.ShippingAddress;
+    readonly service: io.flow.fulfillment.v0.models.ServiceSummary;
+    readonly window: io.flow.common.v0.models.DatetimeRange;
+    readonly zpl?: string;
+    readonly pdf?: string;
+    readonly png?: string;
+    readonly commercial_invoice?: string;
+    readonly references?: string[];
+    readonly label?: io.flow.label.v0.models.ShippingLabelDocument;
+    readonly invoice?: io.flow.label.v0.models.ShippingLabelDocument;
+    readonly cost?: io.flow.common.v0.models.Price;
+    readonly shipment_recipient?: io.flow.label.v0.enums.ShipmentRecipient;
   }
 
-  interface AdyenAuthenticationForm {
-    readonly username: string;
-    readonly password: string;
-    readonly signature_secret: string;
+  interface PartnerBridgeManifest {
+    readonly id: string;
+    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
+    readonly service: io.flow.fulfillment.v0.models.ServiceSummary;
+    readonly pdf: string;
+    readonly data: string;
   }
 
-  interface AdyenMerchant {
-    readonly discriminator: 'adyen_merchant';
-    readonly id: string;
+  interface PartnerBridgeManifestForm {
+    readonly order_numbers: string[];
+  }
+
+  interface PartnerFulfillment {
+    readonly organization: string;
     readonly key: string;
-    readonly organization_id: string;
-    readonly external_id: string;
-    readonly processor_account_reference: io.flow.payment.internal.v0.models.ProcessorAccountReference;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
+    readonly number: string;
+    readonly items: io.flow.order.management.v0.models.FulfillmentItem[];
+    readonly center?: io.flow.fulfillment.v0.models.CenterSummary[];
   }
 
-  interface AdyenMerchantModificationForm {
-    readonly discriminator: 'adyen_merchant_modification_form';
-    readonly external_id: string;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  interface PartnerFulfillmentCancellationForm {
+    readonly change_source: io.flow.order.management.v0.enums.OrderChangeSource;
+    readonly reason: io.flow.order.management.v0.enums.CancelReason;
+    readonly lines: io.flow.order.management.v0.models.FulfillmentLineCancelForm[];
   }
 
-  interface AdyenMerchantPutForm {
-    readonly discriminator: 'adyen_merchant_put_form';
-    readonly organization_id: string;
-    readonly external_id: string;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface PartnerFulfillmentCompleteCancellationForm {
+    readonly change_source: io.flow.order.management.v0.enums.OrderChangeSource;
+    readonly reason: io.flow.order.management.v0.enums.CancelReason;
   }
 
-  interface AdyenPaymentDetailsForm {
-    readonly fingerprint?: string;
-    readonly challenge_result?: string;
+  interface PartnerManifest {
+    readonly id: string;
+    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
+    readonly service?: io.flow.fulfillment.v0.models.ServiceSummary;
+    readonly timestamp: string;
+    readonly shipping_labels: io.flow.label.v0.models.ShippingLabelSummary[];
+    readonly pdf?: string;
   }
 
-  interface AdyenRefundForm {
-    readonly discriminator: 'adyen_refund_form';
-    readonly amount: number;
-    readonly authorization_id: string;
-    readonly capture_id: string;
-    readonly currency: string;
-    readonly psp_reference: string;
-    readonly key?: string;
+  interface PartnerManifestForm {
+    readonly tracking_numbers: string[];
+    readonly service?: string;
   }
 
-  interface AfterpayAccount {
-    readonly discriminator: 'afterpay_account';
+  interface PartnerOrderIdentifier {
     readonly id: string;
-    readonly organization_id: string;
-    readonly key: string;
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly country: string;
-    readonly authentication: io.flow.payment.internal.v0.models.AfterpayAuthentication;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
+    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
+    readonly order: io.flow.partner.v0.models.PartnerOrderReference;
+    readonly number: string;
   }
 
-  interface AfterpayAccountModificationForm {
-    readonly discriminator: 'afterpay_account_modification_form';
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  interface PartnerOrderIdentifierForm {
+    readonly number: string;
+    readonly order_number: string;
   }
 
-  interface AfterpayAccountPutForm {
-    readonly discriminator: 'afterpay_account_put_form';
-    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
-    readonly country: string;
-    readonly authentication: io.flow.payment.internal.v0.models.AfterpayAuthenticationForm;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface PartnerOrderIdentifierPutForm {
+    readonly order_number: string;
   }
 
-  interface AfterpayAuthentication {
-    readonly username: string;
-    readonly password_reference: string;
+  interface PartnerOrderReference {
+    readonly id: string;
+    readonly number: string;
   }
 
-  interface AfterpayAuthenticationDataReference {
-    readonly account_id: string;
+  interface PartnerOrganizationReference {
+    readonly id: string;
   }
 
-  interface AfterpayAuthenticationForm {
-    readonly username: string;
-    readonly password: string;
+  interface SummaryLabelForm {
+    readonly discriminator: 'summary_label_form';
+    readonly organization: string;
+    readonly order_number: string;
+    readonly items?: io.flow.common.v0.models.LineItemForm[];
+    readonly package?: io.flow.label.v0.models.ShippingLabelPackage;
+    readonly center_key?: string;
   }
+}
 
-  interface ApplePayAuthorizationPayload {
-    readonly discriminator: 'apple_pay_authorization_payload';
-    readonly apple_pay_token: string;
+declare namespace io.flow.partner.v0.unions {
+  type LabelForm =
+    | io.flow.partner.v0.models.DetailedLabelForm
+    | io.flow.partner.v0.models.SummaryLabelForm
+    | io.flow.partner.v0.models.BridgeLabelForm;
+}
+
+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';
+  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 AuthenticationForm {
-    readonly password: string;
+  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 AuthorizationBundle {
+  interface CatalogItemReference {
     readonly id: string;
-    readonly organization_id: string;
-    readonly authorization_reference: io.flow.payment.v0.models.AuthorizationReference;
-    readonly payment_request_reference: io.flow.payment.gateway.v0.models.PaymentRequestReference;
-    readonly billing?: io.flow.payment.request.bundle.v0.models.PaymentRequestBilling;
+    readonly number: string;
   }
 
-  interface AuthorizationMetadata {
-    readonly limit?: number;
+  interface CatalogItemSummary {
+    readonly number: string;
+    readonly name: string;
+    readonly attributes: Record<string, string>;
   }
 
-  interface AuthorizationParameters {
-    readonly method: string;
-    readonly parameters: any /*object*/;
+  interface ChannelReference {
+    readonly id: string;
   }
 
-  interface AuthorizationParametersForm {
-    readonly order_number: string;
-    readonly amount: number;
-    readonly currency: string;
-    readonly billing_address?: io.flow.common.v0.models.BillingAddress;
-    readonly ip?: string;
-    readonly origin_url?: string;
+  interface CheckoutReference {
+    readonly id: string;
   }
 
-  interface BitpayAccount {
-    readonly discriminator: 'bitpay_account';
-    readonly id: string;
-    readonly organization_id: string;
-    readonly key: string;
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly authentication: io.flow.payment.internal.v0.models.BitpayAuthentication;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
+  interface Contact {
+    readonly name: io.flow.common.v0.models.Name;
+    readonly company?: string;
+    readonly email?: string;
+    readonly phone?: string;
   }
 
-  interface BitpayAccountModificationForm {
-    readonly discriminator: 'bitpay_account_modification_form';
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  interface CustomerInvoice {
+    readonly address?: io.flow.common.v0.models.BillingAddress;
   }
 
-  interface BitpayAccountPutForm {
-    readonly discriminator: 'bitpay_account_put_form';
-    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
-    readonly authentication: io.flow.payment.internal.v0.models.BitpayAuthenticationForm;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface CustomerReference {
+    readonly number: string;
   }
 
-  interface BitpayAuthentication {
-    readonly api_token: string;
-    readonly public_key: string;
-    readonly secret_key_reference: string;
+  interface DatetimeRange {
+    readonly from: string;
+    readonly to: string;
   }
 
-  interface BitpayAuthenticationDataReference {
-    readonly id: 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 BitpayAuthenticationForm {
-    readonly api_token: string;
-    readonly public_key: string;
-    readonly secret_key: string;
+  interface Dimensions {
+    readonly product?: io.flow.common.v0.models.Dimension;
+    readonly packaging?: io.flow.common.v0.models.Dimension;
   }
 
-  interface Chargeback {
-    readonly id: string;
-    readonly key: string;
-    readonly authorization: io.flow.payment.v0.models.AuthorizationReference;
-    readonly amount: number;
-    readonly currency: string;
-    readonly base?: io.flow.common.v0.models.Money;
-    readonly chargeback_issued_at: string;
-    readonly created_at: string;
-    readonly payment_status: io.flow.payment.internal.v0.enums.ChargebackPaymentStatus;
-    readonly process_status: io.flow.payment.internal.v0.enums.ChargebackProcessStatus;
-    readonly processor: io.flow.payment.internal.v0.enums.Processor;
-    readonly processor_reason: string;
-    readonly processor_status: string;
-    readonly processor_reference?: string;
-    readonly provider_reference?: string;
-    readonly provider_reason_code?: string;
+  interface DiscountForm {
+    readonly offer: io.flow.common.v0.unions.DiscountOffer;
+    readonly target?: io.flow.common.v0.enums.DiscountTarget;
+    readonly label?: string;
   }
 
-  interface ChargebackVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly chargeback: io.flow.payment.internal.v0.models.Chargeback;
+  interface DiscountOfferFixed {
+    readonly discriminator: 'discount_offer_fixed';
+    readonly money: io.flow.common.v0.models.Money;
   }
 
-  interface Cipher {
-    readonly id: string;
-    readonly attributes: Record<string, string>;
+  interface DiscountOfferPercent {
+    readonly discriminator: 'discount_offer_percent';
+    readonly percent: number;
   }
 
-  interface CipherForm {
-    readonly text: string;
-    readonly attributes?: Record<string, string>;
-    readonly password?: string;
+  interface DiscountsForm {
+    readonly discounts: io.flow.common.v0.models.DiscountForm[];
   }
 
-  interface CipherReference {
-    readonly id: string;
+  interface Duration {
+    readonly unit: io.flow.common.v0.enums.UnitOfTime;
+    readonly value: number;
   }
 
-  interface ClassicPaymentRedirectForm {
-    readonly MD: string;
-    readonly PaRes: string;
+  interface EntityIdentifier {
+    readonly name: io.flow.common.v0.enums.EntityIdentifierType;
+    readonly number: string;
+    readonly issuing_country?: string;
   }
 
-  interface CryptoAccount {
-    readonly discriminator: 'crypto_account';
+  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 organization_id: string;
     readonly key: string;
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly authentication: io.flow.payment.internal.v0.models.CryptoAuthentication;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
+    readonly name: string;
+    readonly country?: string;
+    readonly currency?: string;
+    readonly language?: string;
   }
 
-  interface CryptoAccountModificationForm {
-    readonly discriminator: 'crypto_account_modification_form';
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  interface IncludedLevies {
+    readonly key: io.flow.common.v0.enums.IncludedLevyKey;
+    readonly label: string;
   }
 
-  interface CryptoAccountPutForm {
-    readonly discriminator: 'crypto_account_put_form';
-    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
-    readonly authentication: io.flow.payment.internal.v0.models.CryptoAuthenticationForm;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface InputForm {
+    readonly values?: Record<string, string>;
   }
 
-  interface CryptoAuthentication {
-    readonly public_key: string;
-    readonly secret_key_reference: string;
-    readonly signature_secret_reference: string;
+  interface InputFormSpecification {
+    readonly inputs?: io.flow.common.v0.models.InputSpecification[];
+    readonly limitations?: io.flow.common.v0.models.InputSpecificationLimitations;
   }
 
-  interface CryptoAuthenticationForm {
-    readonly public_key: string;
-    readonly secret_key: string;
-    readonly signature_secret: string;
+  interface InputSpecification {
+    readonly type: io.flow.common.v0.enums.InputSpecificationType;
+    readonly name: string;
+    readonly display_text?: string;
   }
 
-  interface DecryptCipherForm {
-    readonly id: string;
-    readonly password: string;
+  interface InputSpecificationLimitationMax {
+    readonly discriminator: 'input_specification_limitation_max';
+    readonly max: number;
   }
 
-  interface DecryptedCipher {
-    readonly id: string;
-    readonly cleartext: string;
+  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 Encryption {
-    readonly id: string;
-    readonly key: io.flow.payment.internal.v0.models.KeyReference;
-    readonly iv: string;
-    readonly cipher: string;
-    readonly passphrase_ids: string[];
+  interface LineItemAttributesForm {
+    readonly attributes: Record<string, string>;
   }
 
-  interface FinancialMerchantCategory {
-    readonly id: string;
-    readonly iso_18245_4: string;
-    readonly title: string;
-    readonly category_group: string;
-    readonly description?: 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 FiservAccount {
-    readonly discriminator: 'fiserv_account';
-    readonly id: string;
-    readonly organization_id: string;
-    readonly key: string;
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly region: string;
-    readonly authentication: io.flow.payment.internal.v0.models.FiservAuthentication;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
+  interface LineItemQuantityForm {
+    readonly quantity: number;
   }
 
-  interface FiservAccountModificationForm {
-    readonly discriminator: 'fiserv_account_modification_form';
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly region: string;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  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 FiservAccountPutForm {
-    readonly discriminator: 'fiserv_account_put_form';
-    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
-    readonly region: string;
-    readonly authentication: io.flow.payment.internal.v0.models.FiservAuthenticationForm;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface LogoImageStatic {
+    readonly url: string;
+    readonly width: number;
+    readonly height: number;
   }
 
-  interface FiservAuthentication {
-    readonly public_key: string;
-    readonly secret_key_reference: string;
+  interface LogoImageSvg {
+    readonly discriminator: 'svg';
+    readonly url: string;
   }
 
-  interface FiservAuthenticationDataReference {
-    readonly account_id: string;
-    readonly store_id: string;
+  interface Margin {
+    readonly type: io.flow.common.v0.enums.MarginType;
+    readonly value: number;
   }
 
-  interface FiservAuthenticationForm {
-    readonly public_key: string;
-    readonly secret_key: string;
+  interface Measurement {
+    readonly value: string;
+    readonly units: io.flow.common.v0.enums.UnitOfMeasurement;
   }
 
-  interface FiservMerchant {
-    readonly discriminator: 'fiserv_merchant';
-    readonly id: string;
-    readonly key: string;
-    readonly organization_id: string;
-    readonly external_id: string;
-    readonly processor_account_reference: io.flow.payment.internal.v0.models.ProcessorAccountReference;
-    readonly base_currency: string;
-    readonly funding_currency: string;
+  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 status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
+    readonly phone?: string;
+    readonly email?: string;
   }
 
-  interface FiservMerchantModificationForm {
-    readonly discriminator: 'fiserv_merchant_modification_form';
-    readonly external_id: string;
-    readonly base_currency: string;
-    readonly funding_currency: string;
+  interface MerchantOfRecordEntityRegistration {
+    readonly number: string;
     readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface FiservMerchantPutForm {
-    readonly discriminator: 'fiserv_merchant_put_form';
-    readonly organization_id: string;
-    readonly external_id: string;
-    readonly base_currency: string;
-    readonly funding_currency: string;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface Money {
+    readonly amount: number;
+    readonly currency: string;
   }
 
-  interface InternalAdyenAuthorizationDetails {
-    readonly discriminator: 'internal_adyen_authorization_details';
-    readonly adyen_authentication_data: io.flow.payment.internal.v0.models.AdyenAuthenticationDataReference;
+  interface MoneyWithBase {
+    readonly currency: string;
+    readonly amount: number;
+    readonly base: io.flow.common.v0.models.Money;
   }
 
-  interface InternalAfterpayAuthorizationDetails {
-    readonly discriminator: 'internal_afterpay_authorization_details';
-    readonly afterpay_authentication_data: io.flow.payment.internal.v0.models.AfterpayAuthenticationDataReference;
+  interface MoneyWithOptionalBase {
+    readonly currency: string;
+    readonly amount: number;
+    readonly base?: io.flow.common.v0.models.Money;
   }
 
-  interface InternalBitpayAuthorizationDetails {
-    readonly discriminator: 'internal_bitpay_authorization_details';
-    readonly bitpay_authentication_data: io.flow.payment.internal.v0.models.BitpayAuthenticationDataReference;
+  interface Name {
+    readonly first?: string;
+    readonly last?: string;
   }
 
-  interface InternalFiservAuthorizationDetails {
-    readonly discriminator: 'internal_fiserv_authorization_details';
-    readonly fiserv_authentication_data: io.flow.payment.internal.v0.models.FiservAuthenticationDataReference;
+  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 InternalPaymentRequest {
-    readonly payment_request: io.flow.payment.gateway.v0.models.PaymentRequest;
-    readonly actual_action?: io.flow.payment.gateway.v0.unions.Action;
+  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 InternalPaypalAuthorizationDetails {
-    readonly discriminator: 'internal_paypal_authorization_details';
-    readonly paypal_authentication_data: io.flow.payment.internal.v0.models.PaypalAccountReference;
+  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 InternalStripeAuthorizationDetails {
-    readonly discriminator: 'internal_stripe_authorization_details';
-    readonly stripe_authentication_data: io.flow.payment.internal.v0.models.StripeAuthenticationDataReference;
+  interface OrganizationDefaults {
+    readonly country: string;
+    readonly base_currency: string;
+    readonly language: string;
+    readonly locale: string;
+    readonly timezone: string;
   }
 
-  interface InternalTransactionDetailsCard {
-    readonly type: 'card';
-    readonly address_verification_result?: io.flow.payment.v0.models.AddressVerificationResult;
-    readonly cvv_result?: io.flow.payment.v0.models.CvvResult;
-    readonly network_details?: io.flow.payment.v0.models.TransactionNetworkDetailsCard;
+  interface OrganizationReference {
+    readonly discriminator: 'organization_reference';
+    readonly id: string;
   }
 
-  interface Key {
+  interface OrganizationSummary {
     readonly id: string;
-    readonly created_at: string;
+    readonly name: string;
+    readonly environment: io.flow.common.v0.enums.Environment;
   }
 
-  interface KeyReference {
+  interface PartnerReference {
     readonly id: string;
   }
 
-  interface KlarnaAuthorizationParameters {
-    readonly discriminator: 'klarna_authorization_parameters';
-    readonly client_token: string;
-    readonly payment_method_categories: io.flow.payment.internal.v0.models.KlarnaPaymentMethodCategory[];
+  interface Price {
+    readonly amount: number;
+    readonly currency: string;
+    readonly label: string;
   }
 
-  interface KlarnaPaymentMethodCategory {
-    readonly id: string;
-    readonly name?: string;
-    readonly standard_asset_urls?: string;
-    readonly descriptive_asset_urls?: string;
+  interface PriceForm {
+    readonly amount: number;
+    readonly currency: string;
   }
 
-  interface OnlineAuthorizationCompleted {
-    readonly discriminator: 'online_authorization_completed';
+  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 organization: string;
     readonly key: string;
-    readonly expires_at: string;
   }
 
-  interface OrganizationPaymentSetting {
-    readonly id: string;
-    readonly organization_id: string;
-    readonly default_capture_option: io.flow.payment.gateway.v0.unions.PaymentCaptureOption;
-    readonly status: io.flow.payment.internal.v0.enums.OrganizationPaymentStatus;
-    readonly checkout_domain?: string;
-    readonly merchant_category_code?: string;
-    readonly payment_statement_suffix?: string;
-    readonly payment_statement_condensed?: string;
-    readonly created_at: string;
-    readonly updated_at: string;
+  interface PriceSourceProvided {
+    readonly discriminator: 'provided';
+    readonly price: io.flow.common.v0.models.Money;
   }
 
-  interface OrganizationPaymentSettingForm {
-    readonly default_capture_option: io.flow.payment.gateway.v0.unions.PaymentCaptureOption;
-    readonly status: io.flow.payment.internal.v0.enums.OrganizationPaymentStatus;
-    readonly checkout_domain?: string;
-    readonly merchant_category_code?: string;
-    readonly payment_statement_suffix?: string;
+  interface PriceWithBase {
+    readonly currency: string;
+    readonly amount: number;
+    readonly label: string;
+    readonly base?: io.flow.common.v0.models.Price;
   }
 
-  interface OrganizationPaymentSettingVersion {
-    readonly id: string;
-    readonly timestamp: string;
-    readonly type: io.flow.common.v0.enums.ChangeType;
-    readonly organization_payment_setting: io.flow.payment.internal.v0.models.OrganizationPaymentSetting;
+  interface RepeatDaily {
+    readonly discriminator: 'repeat_daily';
+    readonly interval: number;
   }
 
-  interface Passphrase {
-    readonly id: string;
-    readonly tribe: io.flow.payment.internal.v0.models.Tribe;
-    readonly salt: string;
-    readonly iv: string;
-    readonly challenge_cipher: string;
-    readonly challenge_text: string;
+  interface RepeatHourly {
+    readonly discriminator: 'repeat_hourly';
+    readonly interval: number;
   }
 
-  interface PassphraseForm {
-    readonly tribe: string;
-    readonly current_password?: string;
-    readonly new_password: string;
+  interface RepeatMonthly {
+    readonly discriminator: 'repeat_monthly';
+    readonly interval: number;
+    readonly days: number[];
   }
 
-  interface PassphraseSummary {
-    readonly id: string;
-    readonly tribe: io.flow.payment.internal.v0.models.Tribe;
+  interface RepeatWeekly {
+    readonly discriminator: 'repeat_weekly';
+    readonly interval: number;
+    readonly days_of_week: io.flow.common.v0.enums.DayOfWeek[];
   }
 
-  interface PaymentMethodDetail {
-    readonly method: io.flow.reference.v0.models.PaymentMethod;
-    readonly method_options?: io.flow.payment.internal.v0.models.PaymentMethodOption[];
+  interface Rounding {
+    readonly type: io.flow.common.v0.enums.RoundingType;
+    readonly method: io.flow.common.v0.enums.RoundingMethod;
+    readonly value: number;
   }
 
-  interface PaymentMethodOption {
-    readonly id: string;
-    readonly name: string;
-    readonly logo?: io.flow.common.v0.unions.LogoImage;
+  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 PaymentOrganizationSettings {
+  interface SessionReference {
     readonly id: string;
-    readonly enable_auto_capture: boolean;
-    readonly link_capture_to_vcc: boolean;
-    readonly purge_ciphers: boolean;
-    readonly domain?: string;
-    readonly merchant_category_code?: number;
-    readonly payment_statement_suffix?: string;
-    readonly payment_statement_condensed?: string;
   }
 
-  interface PaymentOrganizationSettingsPutForm {
-    readonly enable_auto_capture?: boolean;
-    readonly link_capture_to_vcc?: boolean;
-    readonly purge_ciphers?: boolean;
-    readonly domain?: string;
-    readonly merchant_category_code?: number;
-    readonly payment_statement_suffix?: 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 PaypalAccount {
-    readonly discriminator: 'paypal_account';
+  interface UserReference {
+    readonly discriminator: 'user_reference';
     readonly id: string;
-    readonly organization_id: string;
-    readonly key: string;
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly country: string;
-    readonly authentication: io.flow.payment.internal.v0.models.PaypalAuthentication;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
   }
 
-  interface PaypalAccountModificationForm {
-    readonly discriminator: 'paypal_account_modification_form';
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+  interface Zone {
+    readonly postals?: string[];
+    readonly provinces?: string[];
     readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
+}
 
-  interface PaypalAccountPutForm {
-    readonly discriminator: 'paypal_account_put_form';
-    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
-    readonly country: string;
-    readonly authentication: io.flow.payment.internal.v0.models.PaypalAuthenticationForm;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
-  }
+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;
+}
 
-  interface PaypalAccountReference {
-    readonly id: string;
-    readonly flow_merchant_id?: string;
-  }
+declare namespace io.flow.billing.reporting.v0.enums {
+  type ReportStatus =
+    | 'created'
+    | 'completed'
+    | 'completed_no_records'
+    | 'failed';
+  type ReportType =
+    | 'sales_record'
+    | 'trueup_overview'
+    | 'non_channel_payment_bank_account';
+  type ReportingFulfillmentIsVirtual = 'all' | 'mixed' | 'none';
+  type RevenueRecordType = 'sales' | 'refund';
+}
 
-  interface PaypalAuthentication {
-    readonly username: string;
-    readonly password_reference: string;
+declare namespace io.flow.billing.reporting.v0.models {
+  interface FulfillmentShopperBreakdown {
+    readonly shipping: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly fees: io.flow.billing.reporting.v0.models.ReportingShopperFees;
+    readonly product: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly subtotal: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly tax: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly duty: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly discount: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly total: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
   }
 
-  interface PaypalAuthenticationForm {
-    readonly username: string;
-    readonly password: string;
+  interface MarkedAsFinal {
+    readonly products: boolean;
+    readonly shipping: boolean;
   }
 
-  interface PaypalAuthorizationPayload {
-    readonly discriminator: 'paypal_authorization_payload';
-    readonly payment_id: string;
-    readonly payer_id: string;
+  interface NonChannelPaymentBankAccount {
+    readonly payment: io.flow.billing.reporting.v0.models.ReportPayment;
+    readonly bank_account: io.flow.billing.reporting.v0.models.ReportBankAccount;
+    readonly account: io.flow.billing.reporting.v0.models.ReportAccount;
   }
 
-  interface PaypalMerchant {
-    readonly discriminator: 'paypal_merchant';
+  interface RecordReference {
     readonly id: string;
-    readonly key: string;
-    readonly organization_id: string;
-    readonly external_id: string;
-    readonly processor_account_reference: io.flow.payment.internal.v0.models.ProcessorAccountReference;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
-    readonly created_at: string;
-    readonly updated_at: string;
   }
 
-  interface PaypalMerchantModificationForm {
-    readonly discriminator: 'paypal_merchant_modification_form';
-    readonly external_id: string;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  interface Report {
+    readonly id: string;
+    readonly status: io.flow.billing.reporting.v0.enums.ReportStatus;
+    readonly type: io.flow.billing.reporting.v0.enums.ReportType;
+    readonly from: string;
+    readonly to: string;
+    readonly url?: string;
+    readonly processed_at?: string;
   }
 
-  interface PaypalMerchantPutForm {
-    readonly discriminator: 'paypal_merchant_put_form';
-    readonly organization_id: string;
-    readonly external_id: string;
-    readonly country: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  interface ReportAccount {
+    readonly id: string;
+    readonly source: io.flow.billing.internal.v0.models.AccountSource;
   }
 
-  interface ProcessorAccountReference {
+  interface ReportBankAccount {
+    readonly id?: string;
+    readonly last4?: string;
+  }
+
+  interface ReportForm {
+    readonly from: string;
+    readonly to: string;
+    readonly type: io.flow.billing.reporting.v0.enums.ReportType;
+  }
+
+  interface ReportPayment {
     readonly id: string;
-    readonly organization_id: string;
-    readonly key: string;
-    readonly processor: io.flow.payment.internal.v0.enums.Processor;
-    readonly country: string;
-    readonly owner: io.flow.payment.internal.v0.enums.Owner;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
   }
 
-  interface ProcessorEntityStatusForm {
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  interface ReportingAuthorizationReference {
+    readonly id: string;
   }
 
-  interface ProcessorMerchantReference {
+  interface ReportingBusiness {
+    readonly vat_registration_number: string;
+    readonly name?: string;
+  }
+
+  interface ReportingConversionRates {
+    readonly merchant: number;
+    readonly entity: number;
+    readonly usd: number;
+    readonly eur: number;
+  }
+
+  interface ReportingCountry {
+    readonly code: string;
+    readonly is_eu: boolean;
+  }
+
+  interface ReportingCurrencies {
+    readonly transaction: string;
+    readonly merchant: string;
+    readonly entity: string;
+  }
+
+  interface ReportingDebug {
+    readonly console_order_link: string;
+    readonly allocation_order_totals_delta?: number;
+    readonly allocation_order_item_discount_delta?: number;
+    readonly missing_item_subsidies?: io.flow.billing.reporting.v0.models.ReportingDebugMissingSubsidies;
+    readonly missing_shipping_subsidies?: io.flow.billing.reporting.v0.models.ReportingDebugMissingSubsidies;
+  }
+
+  interface ReportingDebugMissingSubsidies {
+    readonly price?: boolean;
+    readonly tax?: boolean;
+    readonly duty?: boolean;
+  }
+
+  interface ReportingDestination {
+    readonly country: io.flow.billing.reporting.v0.models.ReportingCountry;
+    readonly province?: io.flow.billing.reporting.v0.models.ReportingProvince;
+  }
+
+  interface ReportingEntity {
     readonly id: string;
-    readonly organization_id: string;
-    readonly key: string;
-    readonly processor: io.flow.payment.internal.v0.enums.Processor;
-    readonly country: string;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface Redirect {
+  interface ReportingFulfillment {
     readonly id: string;
-    readonly post_payment_redirect_urls: io.flow.payment.v0.models.PostPaymentRedirectUrls;
-    readonly reason: io.flow.payment.internal.v0.enums.RedirectReason;
+    readonly sequence_number: number;
+    readonly fulfilled_at: string;
+    readonly completes_order: boolean;
+    readonly payment: io.flow.billing.reporting.v0.models.ReportingPayment;
+    readonly refund?: io.flow.billing.reporting.v0.models.ReportingRefundReference;
+    readonly value: io.flow.billing.reporting.v0.models.FulfillmentShopperBreakdown;
+    readonly dispatch_country?: io.flow.billing.reporting.v0.models.ReportingCountry;
+    readonly destination?: io.flow.billing.reporting.v0.models.ReportingDestination;
+    readonly shipment?: io.flow.billing.reporting.v0.models.ReportingShipment;
+    readonly is: io.flow.billing.reporting.v0.models.ReportingFulfillmentIs;
+    readonly has: io.flow.billing.reporting.v0.models.ReportingFulfillmentHas;
+    readonly fx: io.flow.billing.reporting.v0.models.ReportingFx;
+    readonly business?: io.flow.billing.reporting.v0.models.ReportingBusiness;
   }
 
-  interface RedirectActionCompleted {
-    readonly discriminator: 'redirect_action_completed';
+  interface ReportingFulfillmentHas {
+    readonly zero_vat_product: boolean;
+  }
+
+  interface ReportingFulfillmentIs {
+    readonly replacement: boolean;
+    readonly virtual: io.flow.billing.reporting.v0.enums.ReportingFulfillmentIsVirtual;
+    readonly duties_guaranteed: boolean;
+    readonly wyol: boolean;
+    readonly b2b: boolean;
+    readonly domestic: boolean;
+  }
+
+  interface ReportingFx {
+    readonly shipping: io.flow.billing.reporting.v0.models.ReportingUsd;
+    readonly fees: io.flow.billing.reporting.v0.models.ReportingUsd;
+    readonly product: io.flow.billing.reporting.v0.models.ReportingUsd;
+    readonly tax: io.flow.billing.reporting.v0.models.ReportingUsd;
+    readonly duty: io.flow.billing.reporting.v0.models.ReportingUsd;
+    readonly total: io.flow.billing.reporting.v0.models.ReportingUsd;
+  }
+
+  interface ReportingMerchantBreakdown {
+    readonly subsidies: io.flow.billing.reporting.v0.models.ReportingMerchantSubsidies;
+    readonly fees: io.flow.billing.reporting.v0.models.ReportingMerchantFees;
+    readonly transactions: io.flow.billing.reporting.v0.models.ReportingMerchantTransactions;
+  }
+
+  interface ReportingMerchantFees {
+    readonly duty_guarantee: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly mor: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly fraud: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly fx: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly processing: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly rate_lock: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly transfer: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingMerchantSubsidies {
+    readonly shipping: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly tax: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly duty: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly ccf: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingMerchantTransactions {
+    readonly adjustment: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly reversal: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly tax: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly duty: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly freight: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly refund: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingMonetaryValue {
+    readonly transaction: number;
+    readonly merchant: number;
+    readonly entity: number;
+    readonly usd: number;
+    readonly eur: number;
+  }
+
+  interface ReportingOrderSummary {
     readonly id: string;
-    readonly organization: string;
-    readonly key: string;
-    readonly expires_at: string;
-    readonly post_payment_redirect_urls: io.flow.payment.v0.models.PostPaymentRedirectUrls;
-    readonly inline_notification_urls?: io.flow.payment.v0.models.PostPaymentRedirectUrls;
+    readonly number: string;
+    readonly submitted_at: string;
   }
 
-  interface RoutingAccount {
-    readonly discriminator: 'routing_account';
-    readonly processor: io.flow.payment.internal.v0.enums.Processor;
-    readonly processor_account: io.flow.payment.internal.v0.models.ProcessorAccountReference;
+  interface ReportingOrganizationSummary {
+    readonly id: string;
+    readonly name: string;
   }
 
-  interface RoutingMerchant {
-    readonly discriminator: 'routing_merchant';
-    readonly processor: io.flow.payment.internal.v0.enums.Processor;
-    readonly processor_account: io.flow.payment.internal.v0.models.ProcessorAccountReference;
-    readonly processor_merchant: io.flow.payment.internal.v0.models.ProcessorMerchantReference;
+  interface ReportingPayment {
+    readonly metadata?: io.flow.billing.reporting.v0.models.ReportingPaymentMetadata;
+    readonly psp: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly credit: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly total: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
   }
 
-  interface RoutingProcessor {
-    readonly discriminator: 'routing_processor';
-    readonly processor: io.flow.payment.internal.v0.enums.Processor;
+  interface ReportingPaymentMetadata {
+    readonly gateway: io.flow.payment.internal.v0.enums.Processor;
+    readonly method: string;
+    readonly psp_reference?: string;
+    readonly authorization?: io.flow.billing.reporting.v0.models.ReportingAuthorizationReference;
+    readonly settlement_date: string;
+    readonly additional_authorizations?: io.flow.billing.reporting.v0.models.ReportingPaymentMetadataAdditionalAuthorizations;
   }
 
-  interface StripeAccount {
-    readonly discriminator: 'stripe_account';
+  interface ReportingPaymentMetadataAdditionalAuthorizations {
+    readonly ids: string;
+  }
+
+  interface ReportingProvince {
+    readonly code?: string;
+    readonly name: string;
+  }
+
+  interface ReportingReconciliation {
+    readonly date: string;
+    readonly month: number;
+    readonly year: number;
+  }
+
+  interface ReportingRefundReference {
+    readonly id: string;
+  }
+
+  interface ReportingShipment {
+    readonly carrier: string;
+    readonly tracking_number?: string;
+  }
+
+  interface ReportingShopperFees {
+    readonly fuel: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly remote_area: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly oversize: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly ccf: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly emergency: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+    readonly peak: io.flow.billing.reporting.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingUsd {
+    readonly usd: number;
+  }
+
+  interface ReportingVatRemittance {
+    readonly currency: string;
+    readonly rate: io.flow.billing.reporting.v0.models.ReportingVatRemittanceRate;
+  }
+
+  interface ReportingVatRemittanceRate {
+    readonly entity: number;
+  }
+
+  interface ReportingVendor {
+    readonly id: string;
+  }
+
+  interface RevenueRecord {
+    readonly id: string;
+    readonly organization: io.flow.billing.reporting.v0.models.ReportingOrganizationSummary;
+    readonly parent?: io.flow.billing.reporting.v0.models.RecordReference;
+    readonly type: io.flow.billing.reporting.v0.enums.RevenueRecordType;
+    readonly order: io.flow.billing.reporting.v0.models.ReportingOrderSummary;
+    readonly entity: io.flow.billing.reporting.v0.models.ReportingEntity;
+    readonly vendor: io.flow.billing.reporting.v0.models.ReportingVendor;
+    readonly currencies: io.flow.billing.reporting.v0.models.ReportingCurrencies;
+    readonly conversion_rate: io.flow.billing.reporting.v0.models.ReportingConversionRates;
+    readonly reconciliation: io.flow.billing.reporting.v0.models.ReportingReconciliation;
+    readonly merchant: io.flow.billing.reporting.v0.models.ReportingMerchantBreakdown;
+    readonly fulfillment: io.flow.billing.reporting.v0.models.ReportingFulfillment;
+    readonly vat_remittance: io.flow.billing.reporting.v0.models.ReportingVatRemittance;
+    readonly marked_as_final: io.flow.billing.reporting.v0.models.MarkedAsFinal;
+    readonly debug: io.flow.billing.reporting.v0.models.ReportingDebug;
+  }
+}
+
+declare namespace io.flow.payment.internal.v0.enums {
+  type AdyenIntegrationType =
+    | 'hosted_payment_page'
+    | 'checkout_payments_api'
+    | 'classic_authorise_api';
+  type ChargebackPaymentStatus = 'captured' | 'refunded';
+  type ChargebackProcessStatus = 'inquiry' | 'open' | 'closed';
+  type HttpMethod = 'get' | 'post';
+  type OrganizationCapability = 'organization' | 'flow' | 'dynamic';
+  type OrganizationPaymentStatus = 'active' | 'archived';
+  type Owner = 'flow' | 'organization';
+  type Processor =
+    | 'adyen'
+    | 'afterpay'
+    | 'bitpay'
+    | 'stripe'
+    | 'paypal'
+    | 'flow_sandbox'
+    | 'fiserv'
+    | 'crypto';
+  type ProcessorEntityStatus = 'active' | 'draft' | 'archived';
+  type RedirectReason = 'three_d_secure';
+  type RiskCheck = 'three_d_secure';
+}
+
+declare namespace io.flow.payment.internal.v0.models {
+  interface AdyenAccount {
+    readonly discriminator: 'adyen_account';
     readonly id: string;
     readonly organization_id: string;
     readonly key: string;
     readonly owner: io.flow.payment.internal.v0.enums.Owner;
     readonly name: string;
-    readonly external_id: string;
+    readonly ui_reference: string;
+    readonly authentication: io.flow.payment.internal.v0.models.AdyenAuthentication;
     readonly country: string;
-    readonly authentication: io.flow.payment.internal.v0.models.StripeAuthentication;
     readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
     readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
     readonly created_at: string;
     readonly updated_at: string;
   }
 
-  interface StripeAccountModificationForm {
-    readonly discriminator: 'stripe_account_modification_form';
+  interface AdyenAccountModificationForm {
+    readonly discriminator: 'adyen_account_modification_form';
     readonly owner: io.flow.payment.internal.v0.enums.Owner;
     readonly name: string;
-    readonly external_id: string;
+    readonly ui_reference: string;
     readonly country: string;
     readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface StripeAccountPutForm {
-    readonly discriminator: 'stripe_account_put_form';
+  interface AdyenAccountPutForm {
+    readonly discriminator: 'adyen_account_put_form';
     readonly owner?: io.flow.payment.internal.v0.enums.Owner;
     readonly name: string;
-    readonly external_id: string;
+    readonly ui_reference: string;
+    readonly authentication: io.flow.payment.internal.v0.models.AdyenAuthenticationForm;
     readonly country: string;
-    readonly authentication: io.flow.payment.internal.v0.models.StripeAuthenticationForm;
     readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
     readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface StripeAuthentication {
-    readonly public_key: string;
-    readonly secret_key_reference: string;
+  interface AdyenAuthentication {
+    readonly username: string;
+    readonly password_reference: string;
+    readonly signature_secret_reference: string;
   }
 
-  interface StripeAuthenticationDataReference {
-    readonly id: string;
+  interface AdyenAuthenticationDataReference {
+    readonly account_id: string;
+    readonly merchant_account: string;
+    readonly origin_key?: string;
+    readonly integration_type?: io.flow.payment.internal.v0.enums.AdyenIntegrationType;
   }
 
-  interface StripeAuthenticationForm {
-    readonly public_key: string;
-    readonly secret_key: string;
+  interface AdyenAuthenticationForm {
+    readonly username: string;
+    readonly password: string;
+    readonly signature_secret: string;
   }
 
-  interface StripeMerchant {
-    readonly discriminator: 'stripe_merchant';
+  interface AdyenMerchant {
+    readonly discriminator: 'adyen_merchant';
     readonly id: string;
     readonly key: string;
     readonly organization_id: string;
     readonly external_id: string;
     readonly processor_account_reference: io.flow.payment.internal.v0.models.ProcessorAccountReference;
-    readonly name: string;
-    readonly account_type: io.flow.stripe.v0.enums.AccountType;
     readonly country: string;
     readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
     readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
@@ -10022,775 +10318,828 @@ declare namespace io.flow.payment.internal.v0.models {
     readonly updated_at: string;
   }
 
-  interface StripeMerchantForm {
-    readonly discriminator: 'stripe_merchant_form';
-    readonly key?: string;
-    readonly organization_id: string;
-    readonly name: string;
-    readonly account_type: io.flow.stripe.v0.enums.AccountType;
-    readonly country: string;
-    readonly payment_statement: string;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
-  }
-
-  interface StripeMerchantModificationForm {
-    readonly discriminator: 'stripe_merchant_modification_form';
+  interface AdyenMerchantModificationForm {
+    readonly discriminator: 'adyen_merchant_modification_form';
     readonly external_id: string;
-    readonly name: string;
-    readonly account_type: io.flow.stripe.v0.enums.AccountType;
-    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
     readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface StripeMerchantPutForm {
-    readonly discriminator: 'stripe_merchant_put_form';
+  interface AdyenMerchantPutForm {
+    readonly discriminator: 'adyen_merchant_put_form';
     readonly organization_id: string;
     readonly external_id: string;
-    readonly name: string;
-    readonly account_type: io.flow.stripe.v0.enums.AccountType;
-    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
     readonly country: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
     readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface Tribe {
-    readonly id: string;
-    readonly description: string;
+  interface AdyenPaymentDetailsForm {
+    readonly fingerprint?: string;
+    readonly challenge_result?: string;
   }
 
-  interface VirtualCardProvider {
+  interface AdyenRefundForm {
+    readonly discriminator: 'adyen_refund_form';
+    readonly amount: number;
+    readonly authorization_id: string;
+    readonly capture_id: string;
+    readonly currency: string;
+    readonly psp_reference: string;
+    readonly key?: string;
+  }
+
+  interface AfterpayAccount {
+    readonly discriminator: 'afterpay_account';
     readonly id: string;
     readonly organization_id: string;
-    readonly provider: string;
-    readonly attributes?: Record<string, string>;
+    readonly key: string;
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly country: string;
+    readonly authentication: io.flow.payment.internal.v0.models.AfterpayAuthentication;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
     readonly created_at: string;
     readonly updated_at: string;
   }
-}
-
-declare namespace io.flow.payment.internal.v0.unions {
-  type AuthorizationPayload =
-    | io.flow.payment.internal.v0.models.ApplePayAuthorizationPayload
-    | io.flow.payment.internal.v0.models.PaypalAuthorizationPayload;
-  type InlineAuthorizationParameters =
-    io.flow.payment.internal.v0.models.KlarnaAuthorizationParameters;
-  type InternalAuthorizationDetails =
-    | io.flow.payment.internal.v0.models.InternalPaypalAuthorizationDetails
-    | io.flow.payment.internal.v0.models.InternalBitpayAuthorizationDetails
-    | io.flow.payment.internal.v0.models.InternalStripeAuthorizationDetails
-    | io.flow.payment.internal.v0.models.InternalAdyenAuthorizationDetails
-    | io.flow.payment.internal.v0.models.InternalAfterpayAuthorizationDetails
-    | io.flow.payment.internal.v0.models.InternalFiservAuthorizationDetails;
-  type InternalRefundForm = io.flow.payment.internal.v0.models.AdyenRefundForm;
-  type InternalTransactionDetails =
-    io.flow.payment.internal.v0.models.InternalTransactionDetailsCard;
-  type PaymentRedirect =
-    | io.flow.payment.internal.v0.models.OnlineAuthorizationCompleted
-    | io.flow.payment.internal.v0.models.RedirectActionCompleted;
-  type ProcessorAccount =
-    | io.flow.payment.internal.v0.models.StripeAccount
-    | io.flow.payment.internal.v0.models.AdyenAccount
-    | io.flow.payment.internal.v0.models.PaypalAccount
-    | io.flow.payment.internal.v0.models.AfterpayAccount
-    | io.flow.payment.internal.v0.models.BitpayAccount
-    | io.flow.payment.internal.v0.models.FiservAccount
-    | io.flow.payment.internal.v0.models.CryptoAccount;
-  type ProcessorAccountModificationForm =
-    | io.flow.payment.internal.v0.models.StripeAccountModificationForm
-    | io.flow.payment.internal.v0.models.AdyenAccountModificationForm
-    | io.flow.payment.internal.v0.models.PaypalAccountModificationForm
-    | io.flow.payment.internal.v0.models.AfterpayAccountModificationForm
-    | io.flow.payment.internal.v0.models.BitpayAccountModificationForm
-    | io.flow.payment.internal.v0.models.FiservAccountModificationForm
-    | io.flow.payment.internal.v0.models.CryptoAccountModificationForm;
-  type ProcessorAccountPutForm =
-    | io.flow.payment.internal.v0.models.StripeAccountPutForm
-    | io.flow.payment.internal.v0.models.AdyenAccountPutForm
-    | io.flow.payment.internal.v0.models.PaypalAccountPutForm
-    | io.flow.payment.internal.v0.models.AfterpayAccountPutForm
-    | io.flow.payment.internal.v0.models.BitpayAccountPutForm
-    | io.flow.payment.internal.v0.models.FiservAccountPutForm
-    | io.flow.payment.internal.v0.models.CryptoAccountPutForm;
-  type ProcessorMerchant =
-    | io.flow.payment.internal.v0.models.StripeMerchant
-    | io.flow.payment.internal.v0.models.AdyenMerchant
-    | io.flow.payment.internal.v0.models.FiservMerchant
-    | io.flow.payment.internal.v0.models.PaypalMerchant;
-  type ProcessorMerchantForm =
-    io.flow.payment.internal.v0.models.StripeMerchantForm;
-  type ProcessorMerchantModificationForm =
-    | io.flow.payment.internal.v0.models.StripeMerchantModificationForm
-    | io.flow.payment.internal.v0.models.AdyenMerchantModificationForm
-    | io.flow.payment.internal.v0.models.FiservMerchantModificationForm
-    | io.flow.payment.internal.v0.models.PaypalMerchantModificationForm;
-  type ProcessorMerchantPutForm =
-    | io.flow.payment.internal.v0.models.StripeMerchantPutForm
-    | io.flow.payment.internal.v0.models.AdyenMerchantPutForm
-    | io.flow.payment.internal.v0.models.FiservMerchantPutForm
-    | io.flow.payment.internal.v0.models.PaypalMerchantPutForm;
-  type RoutingEntity =
-    | io.flow.payment.internal.v0.models.RoutingProcessor
-    | io.flow.payment.internal.v0.models.RoutingAccount
-    | io.flow.payment.internal.v0.models.RoutingMerchant;
-}
 
-declare namespace io.flow.partner.v0.enums {
-  type LabelFormat = 'pdf' | 'zpl' | 'all';
-}
+  interface AfterpayAccountModificationForm {
+    readonly discriminator: 'afterpay_account_modification_form';
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  }
 
-declare namespace io.flow.partner.v0.models {
-  interface BridgeHub {
-    readonly hub_code: string;
-    readonly address: io.flow.fulfillment.v0.models.ShippingAddress;
+  interface AfterpayAccountPutForm {
+    readonly discriminator: 'afterpay_account_put_form';
+    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
+    readonly country: string;
+    readonly authentication: io.flow.payment.internal.v0.models.AfterpayAuthenticationForm;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface BridgeLabelForm {
-    readonly discriminator: 'bridge_label_form';
-    readonly organization: string;
-    readonly order_number: string;
-    readonly package: io.flow.partner.v0.models.BridgeLabelPackage;
-    readonly hub?: io.flow.partner.v0.models.BridgeHub;
+  interface AfterpayAuthentication {
+    readonly username: string;
+    readonly password_reference: string;
   }
 
-  interface BridgeLabelPackage {
-    readonly dimensions?: io.flow.common.v0.models.Dimension;
-    readonly items: io.flow.common.v0.models.LineItemForm[];
-    readonly reference_number: string;
+  interface AfterpayAuthenticationDataReference {
+    readonly account_id: string;
   }
 
-  interface DetailedLabelForm {
-    readonly discriminator: 'detailed_label_form';
-    readonly organization: string;
-    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly order_number: string;
-    readonly origin: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly package: io.flow.label.v0.models.ShippingLabelPackage;
-    readonly service?: string;
-    readonly references?: string[];
+  interface AfterpayAuthenticationForm {
+    readonly username: string;
+    readonly password: string;
   }
 
-  interface Label {
-    readonly id: string;
-    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
-    readonly order_number: string;
-    readonly package: io.flow.label.v0.models.ShippingLabelPackage;
-    readonly carrier_tracking_number: string;
-    readonly carrier_tracking_number_url: string;
-    readonly destination: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly flow_tracking_number: string;
-    readonly flow_tracking_number_url: string;
-    readonly origin: io.flow.fulfillment.v0.models.ShippingAddress;
-    readonly service: io.flow.fulfillment.v0.models.ServiceSummary;
-    readonly window: io.flow.common.v0.models.DatetimeRange;
-    readonly zpl?: string;
-    readonly pdf?: string;
-    readonly png?: string;
-    readonly commercial_invoice?: string;
-    readonly references?: string[];
-    readonly label?: io.flow.label.v0.models.ShippingLabelDocument;
-    readonly invoice?: io.flow.label.v0.models.ShippingLabelDocument;
-    readonly cost?: io.flow.common.v0.models.Price;
-    readonly shipment_recipient?: io.flow.label.v0.enums.ShipmentRecipient;
+  interface ApplePayAuthorizationPayload {
+    readonly discriminator: 'apple_pay_authorization_payload';
+    readonly apple_pay_token: string;
   }
 
-  interface PartnerBridgeManifest {
-    readonly id: string;
-    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
-    readonly service: io.flow.fulfillment.v0.models.ServiceSummary;
-    readonly pdf: string;
-    readonly data: string;
+  interface AuthenticationForm {
+    readonly password: string;
   }
 
-  interface PartnerBridgeManifestForm {
-    readonly order_numbers: string[];
+  interface AuthorizationBundle {
+    readonly id: string;
+    readonly organization_id: string;
+    readonly authorization_reference: io.flow.payment.v0.models.AuthorizationReference;
+    readonly payment_request_reference: io.flow.payment.gateway.v0.models.PaymentRequestReference;
+    readonly billing?: io.flow.payment.request.bundle.v0.models.PaymentRequestBilling;
   }
 
-  interface PartnerFulfillment {
-    readonly organization: string;
-    readonly key: string;
-    readonly number: string;
-    readonly items: io.flow.order.management.v0.models.FulfillmentItem[];
-    readonly center?: io.flow.fulfillment.v0.models.CenterSummary[];
+  interface AuthorizationMetadata {
+    readonly limit?: number;
   }
 
-  interface PartnerFulfillmentCancellationForm {
-    readonly change_source: io.flow.order.management.v0.enums.OrderChangeSource;
-    readonly reason: io.flow.order.management.v0.enums.CancelReason;
-    readonly lines: io.flow.order.management.v0.models.FulfillmentLineCancelForm[];
+  interface AuthorizationParameters {
+    readonly method: string;
+    readonly parameters: any /*object*/;
   }
 
-  interface PartnerFulfillmentCompleteCancellationForm {
-    readonly change_source: io.flow.order.management.v0.enums.OrderChangeSource;
-    readonly reason: io.flow.order.management.v0.enums.CancelReason;
+  interface AuthorizationParametersForm {
+    readonly order_number: string;
+    readonly amount: number;
+    readonly currency: string;
+    readonly billing_address?: io.flow.common.v0.models.BillingAddress;
+    readonly ip?: string;
+    readonly origin_url?: string;
   }
 
-  interface PartnerManifest {
+  interface BitpayAccount {
+    readonly discriminator: 'bitpay_account';
     readonly id: string;
-    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
-    readonly service?: io.flow.fulfillment.v0.models.ServiceSummary;
-    readonly timestamp: string;
-    readonly shipping_labels: io.flow.label.v0.models.ShippingLabelSummary[];
-    readonly pdf?: string;
+    readonly organization_id: string;
+    readonly key: string;
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly authentication: io.flow.payment.internal.v0.models.BitpayAuthentication;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  interface PartnerManifestForm {
-    readonly tracking_numbers: string[];
-    readonly service?: string;
+  interface BitpayAccountModificationForm {
+    readonly discriminator: 'bitpay_account_modification_form';
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface PartnerOrderIdentifier {
+  interface BitpayAccountPutForm {
+    readonly discriminator: 'bitpay_account_put_form';
+    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
+    readonly authentication: io.flow.payment.internal.v0.models.BitpayAuthenticationForm;
+    readonly country: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  }
+
+  interface BitpayAuthentication {
+    readonly api_token: string;
+    readonly public_key: string;
+    readonly secret_key_reference: string;
+  }
+
+  interface BitpayAuthenticationDataReference {
     readonly id: string;
-    readonly organization: io.flow.partner.v0.models.PartnerOrganizationReference;
-    readonly order: io.flow.partner.v0.models.PartnerOrderReference;
-    readonly number: string;
   }
 
-  interface PartnerOrderIdentifierForm {
-    readonly number: string;
-    readonly order_number: string;
+  interface BitpayAuthenticationForm {
+    readonly api_token: string;
+    readonly public_key: string;
+    readonly secret_key: string;
   }
 
-  interface PartnerOrderIdentifierPutForm {
-    readonly order_number: string;
+  interface Chargeback {
+    readonly id: string;
+    readonly key: string;
+    readonly authorization: io.flow.payment.v0.models.AuthorizationReference;
+    readonly amount: number;
+    readonly currency: string;
+    readonly base?: io.flow.common.v0.models.Money;
+    readonly chargeback_issued_at: string;
+    readonly created_at: string;
+    readonly payment_status: io.flow.payment.internal.v0.enums.ChargebackPaymentStatus;
+    readonly process_status: io.flow.payment.internal.v0.enums.ChargebackProcessStatus;
+    readonly processor: io.flow.payment.internal.v0.enums.Processor;
+    readonly processor_reason: string;
+    readonly processor_status: string;
+    readonly processor_reference?: string;
+    readonly provider_reference?: string;
+    readonly provider_reason_code?: string;
   }
 
-  interface PartnerOrderReference {
+  interface ChargebackVersion {
     readonly id: string;
-    readonly number: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly chargeback: io.flow.payment.internal.v0.models.Chargeback;
   }
 
-  interface PartnerOrganizationReference {
+  interface Cipher {
     readonly id: string;
+    readonly attributes: Record<string, string>;
   }
 
-  interface SummaryLabelForm {
-    readonly discriminator: 'summary_label_form';
-    readonly organization: string;
-    readonly order_number: string;
-    readonly items?: io.flow.common.v0.models.LineItemForm[];
-    readonly package?: io.flow.label.v0.models.ShippingLabelPackage;
-    readonly center_key?: string;
+  interface CipherForm {
+    readonly text: string;
+    readonly attributes?: Record<string, string>;
+    readonly password?: string;
   }
-}
 
-declare namespace io.flow.partner.v0.unions {
-  type LabelForm =
-    | io.flow.partner.v0.models.DetailedLabelForm
-    | io.flow.partner.v0.models.SummaryLabelForm
-    | io.flow.partner.v0.models.BridgeLabelForm;
-}
+  interface CipherReference {
+    readonly id: string;
+  }
 
-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';
-  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';
-}
+  interface ClassicPaymentRedirectForm {
+    readonly MD: string;
+    readonly PaRes: string;
+  }
 
-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 CryptoAccount {
+    readonly discriminator: 'crypto_account';
+    readonly id: string;
+    readonly organization_id: string;
+    readonly key: string;
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly authentication: io.flow.payment.internal.v0.models.CryptoAuthentication;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  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 CryptoAccountModificationForm {
+    readonly discriminator: 'crypto_account_modification_form';
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface CatalogItemReference {
+  interface CryptoAccountPutForm {
+    readonly discriminator: 'crypto_account_put_form';
+    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
+    readonly authentication: io.flow.payment.internal.v0.models.CryptoAuthenticationForm;
+    readonly country: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  }
+
+  interface CryptoAuthentication {
+    readonly public_key: string;
+    readonly secret_key_reference: string;
+    readonly signature_secret_reference: string;
+  }
+
+  interface CryptoAuthenticationForm {
+    readonly public_key: string;
+    readonly secret_key: string;
+    readonly signature_secret: string;
+  }
+
+  interface DecryptCipherForm {
     readonly id: string;
-    readonly number: string;
+    readonly password: string;
   }
 
-  interface CatalogItemSummary {
-    readonly number: string;
-    readonly name: string;
+  interface DecryptedCipher {
+    readonly id: string;
+    readonly cleartext: string;
     readonly attributes: Record<string, string>;
   }
 
-  interface ChannelReference {
+  interface Encryption {
     readonly id: string;
+    readonly key: io.flow.payment.internal.v0.models.KeyReference;
+    readonly iv: string;
+    readonly cipher: string;
+    readonly passphrase_ids: string[];
   }
 
-  interface CheckoutReference {
+  interface FinancialMerchantCategory {
     readonly id: string;
+    readonly iso_18245_4: string;
+    readonly title: string;
+    readonly category_group: string;
+    readonly description?: string;
   }
 
-  interface Contact {
-    readonly name: io.flow.common.v0.models.Name;
-    readonly company?: string;
-    readonly email?: string;
-    readonly phone?: string;
+  interface FiservAccount {
+    readonly discriminator: 'fiserv_account';
+    readonly id: string;
+    readonly organization_id: string;
+    readonly key: string;
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly region: string;
+    readonly authentication: io.flow.payment.internal.v0.models.FiservAuthentication;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  interface CustomerInvoice {
-    readonly address?: io.flow.common.v0.models.BillingAddress;
+  interface FiservAccountModificationForm {
+    readonly discriminator: 'fiserv_account_modification_form';
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly region: string;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface CustomerReference {
-    readonly number: string;
+  interface FiservAccountPutForm {
+    readonly discriminator: 'fiserv_account_put_form';
+    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
+    readonly region: string;
+    readonly authentication: io.flow.payment.internal.v0.models.FiservAuthenticationForm;
+    readonly country: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface DatetimeRange {
-    readonly from: string;
-    readonly to: string;
+  interface FiservAuthentication {
+    readonly public_key: string;
+    readonly secret_key_reference: 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 FiservAuthenticationDataReference {
+    readonly account_id: string;
+    readonly store_id: string;
   }
 
-  interface Dimensions {
-    readonly product?: io.flow.common.v0.models.Dimension;
-    readonly packaging?: io.flow.common.v0.models.Dimension;
+  interface FiservAuthenticationForm {
+    readonly public_key: string;
+    readonly secret_key: string;
   }
 
-  interface DiscountForm {
-    readonly offer: io.flow.common.v0.unions.DiscountOffer;
-    readonly target?: io.flow.common.v0.enums.DiscountTarget;
-    readonly label?: string;
+  interface FiservMerchant {
+    readonly discriminator: 'fiserv_merchant';
+    readonly id: string;
+    readonly key: string;
+    readonly organization_id: string;
+    readonly external_id: string;
+    readonly processor_account_reference: io.flow.payment.internal.v0.models.ProcessorAccountReference;
+    readonly base_currency: string;
+    readonly funding_currency: string;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  interface DiscountOfferFixed {
-    readonly discriminator: 'discount_offer_fixed';
-    readonly money: io.flow.common.v0.models.Money;
+  interface FiservMerchantModificationForm {
+    readonly discriminator: 'fiserv_merchant_modification_form';
+    readonly external_id: string;
+    readonly base_currency: string;
+    readonly funding_currency: string;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface DiscountOfferPercent {
-    readonly discriminator: 'discount_offer_percent';
-    readonly percent: number;
+  interface FiservMerchantPutForm {
+    readonly discriminator: 'fiserv_merchant_put_form';
+    readonly organization_id: string;
+    readonly external_id: string;
+    readonly base_currency: string;
+    readonly funding_currency: string;
+    readonly country: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface DiscountsForm {
-    readonly discounts: io.flow.common.v0.models.DiscountForm[];
+  interface InternalAdyenAuthorizationDetails {
+    readonly discriminator: 'internal_adyen_authorization_details';
+    readonly adyen_authentication_data: io.flow.payment.internal.v0.models.AdyenAuthenticationDataReference;
   }
 
-  interface Duration {
-    readonly unit: io.flow.common.v0.enums.UnitOfTime;
-    readonly value: number;
+  interface InternalAfterpayAuthorizationDetails {
+    readonly discriminator: 'internal_afterpay_authorization_details';
+    readonly afterpay_authentication_data: io.flow.payment.internal.v0.models.AfterpayAuthenticationDataReference;
   }
 
-  interface EntityIdentifier {
-    readonly name: io.flow.common.v0.enums.EntityIdentifierType;
-    readonly number: string;
-    readonly issuing_country?: string;
+  interface InternalBitpayAuthorizationDetails {
+    readonly discriminator: 'internal_bitpay_authorization_details';
+    readonly bitpay_authentication_data: io.flow.payment.internal.v0.models.BitpayAuthenticationDataReference;
   }
 
-  interface Exception {
-    readonly type: io.flow.common.v0.enums.ExceptionType;
-    readonly datetime_range: io.flow.common.v0.models.DatetimeRange;
+  interface InternalFiservAuthorizationDetails {
+    readonly discriminator: 'internal_fiserv_authorization_details';
+    readonly fiserv_authentication_data: io.flow.payment.internal.v0.models.FiservAuthenticationDataReference;
   }
 
-  interface ExperienceSummary {
-    readonly id: string;
-    readonly key: string;
-    readonly name: string;
-    readonly country?: string;
-    readonly currency?: string;
-    readonly language?: string;
+  interface InternalPaymentRequest {
+    readonly payment_request: io.flow.payment.gateway.v0.models.PaymentRequest;
+    readonly actual_action?: io.flow.payment.gateway.v0.unions.Action;
   }
 
-  interface IncludedLevies {
-    readonly key: io.flow.common.v0.enums.IncludedLevyKey;
-    readonly label: string;
+  interface InternalPaypalAuthorizationDetails {
+    readonly discriminator: 'internal_paypal_authorization_details';
+    readonly paypal_authentication_data: io.flow.payment.internal.v0.models.PaypalAccountReference;
   }
 
-  interface InputForm {
-    readonly values?: Record<string, string>;
+  interface InternalStripeAuthorizationDetails {
+    readonly discriminator: 'internal_stripe_authorization_details';
+    readonly stripe_authentication_data: io.flow.payment.internal.v0.models.StripeAuthenticationDataReference;
   }
 
-  interface InputFormSpecification {
-    readonly inputs?: io.flow.common.v0.models.InputSpecification[];
-    readonly limitations?: io.flow.common.v0.models.InputSpecificationLimitations;
+  interface InternalTransactionDetailsCard {
+    readonly type: 'card';
+    readonly address_verification_result?: io.flow.payment.v0.models.AddressVerificationResult;
+    readonly cvv_result?: io.flow.payment.v0.models.CvvResult;
+    readonly network_details?: io.flow.payment.v0.models.TransactionNetworkDetailsCard;
   }
 
-  interface InputSpecification {
-    readonly type: io.flow.common.v0.enums.InputSpecificationType;
-    readonly name: string;
-    readonly display_text?: string;
+  interface Key {
+    readonly id: string;
+    readonly created_at: string;
   }
 
-  interface InputSpecificationLimitationMax {
-    readonly discriminator: 'input_specification_limitation_max';
-    readonly max: number;
+  interface KeyReference {
+    readonly id: string;
   }
 
-  interface InputSpecificationLimitations {
-    readonly limitations?: io.flow.common.v0.unions.InputSpecificationLimitation[];
+  interface KlarnaAuthorizationParameters {
+    readonly discriminator: 'klarna_authorization_parameters';
+    readonly client_token: string;
+    readonly payment_method_categories: io.flow.payment.internal.v0.models.KlarnaPaymentMethodCategory[];
   }
 
-  interface ItemReference {
-    readonly number: string;
+  interface KlarnaPaymentMethodCategory {
+    readonly id: string;
+    readonly name?: string;
+    readonly standard_asset_urls?: string;
+    readonly descriptive_asset_urls?: 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 OnlineAuthorizationCompleted {
+    readonly discriminator: 'online_authorization_completed';
+    readonly id: string;
+    readonly organization: string;
+    readonly key: string;
+    readonly expires_at: string;
   }
 
-  interface LineItemAttributesForm {
-    readonly attributes: Record<string, string>;
+  interface OrganizationPaymentSetting {
+    readonly id: string;
+    readonly organization_id: string;
+    readonly default_capture_option: io.flow.payment.gateway.v0.unions.PaymentCaptureOption;
+    readonly status: io.flow.payment.internal.v0.enums.OrganizationPaymentStatus;
+    readonly checkout_domain?: string;
+    readonly merchant_category_code?: string;
+    readonly payment_statement_suffix?: string;
+    readonly payment_statement_condensed?: string;
+    readonly created_at: string;
+    readonly updated_at: 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 OrganizationPaymentSettingForm {
+    readonly default_capture_option: io.flow.payment.gateway.v0.unions.PaymentCaptureOption;
+    readonly status: io.flow.payment.internal.v0.enums.OrganizationPaymentStatus;
+    readonly checkout_domain?: string;
+    readonly merchant_category_code?: string;
+    readonly payment_statement_suffix?: string;
   }
 
-  interface LineItemQuantityForm {
-    readonly quantity: number;
+  interface OrganizationPaymentSettingVersion {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly type: io.flow.common.v0.enums.ChangeType;
+    readonly organization_payment_setting: io.flow.payment.internal.v0.models.OrganizationPaymentSetting;
   }
 
-  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 Passphrase {
+    readonly id: string;
+    readonly tribe: io.flow.payment.internal.v0.models.Tribe;
+    readonly salt: string;
+    readonly iv: string;
+    readonly challenge_cipher: string;
+    readonly challenge_text: string;
   }
 
-  interface LogoImageStatic {
-    readonly url: string;
-    readonly width: number;
-    readonly height: number;
+  interface PassphraseForm {
+    readonly tribe: string;
+    readonly current_password?: string;
+    readonly new_password: string;
   }
 
-  interface LogoImageSvg {
-    readonly discriminator: 'svg';
-    readonly url: string;
+  interface PassphraseSummary {
+    readonly id: string;
+    readonly tribe: io.flow.payment.internal.v0.models.Tribe;
   }
 
-  interface Margin {
-    readonly type: io.flow.common.v0.enums.MarginType;
-    readonly value: number;
+  interface PaymentMethodDetail {
+    readonly method: io.flow.reference.v0.models.PaymentMethod;
+    readonly method_options?: io.flow.payment.internal.v0.models.PaymentMethodOption[];
   }
 
-  interface Measurement {
-    readonly value: string;
-    readonly units: io.flow.common.v0.enums.UnitOfMeasurement;
+  interface PaymentMethodOption {
+    readonly id: string;
+    readonly name: string;
+    readonly logo?: io.flow.common.v0.unions.LogoImage;
   }
 
-  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 PaymentOrganizationSettings {
+    readonly id: string;
+    readonly enable_auto_capture: boolean;
+    readonly link_capture_to_vcc: boolean;
+    readonly purge_ciphers: boolean;
+    readonly domain?: string;
+    readonly merchant_category_code?: number;
+    readonly payment_statement_suffix?: string;
+    readonly payment_statement_condensed?: string;
   }
 
-  interface MerchantOfRecordEntityRegistration {
-    readonly number: string;
+  interface PaymentOrganizationSettingsPutForm {
+    readonly enable_auto_capture?: boolean;
+    readonly link_capture_to_vcc?: boolean;
+    readonly purge_ciphers?: boolean;
+    readonly domain?: string;
+    readonly merchant_category_code?: number;
+    readonly payment_statement_suffix?: string;
+  }
+
+  interface PaypalAccount {
+    readonly discriminator: 'paypal_account';
+    readonly id: string;
+    readonly organization_id: string;
+    readonly key: string;
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
     readonly country: string;
+    readonly authentication: io.flow.payment.internal.v0.models.PaypalAuthentication;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  interface Money {
-    readonly amount: number;
-    readonly currency: string;
+  interface PaypalAccountModificationForm {
+    readonly discriminator: 'paypal_account_modification_form';
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface MoneyWithBase {
-    readonly currency: string;
-    readonly amount: number;
-    readonly base: io.flow.common.v0.models.Money;
+  interface PaypalAccountPutForm {
+    readonly discriminator: 'paypal_account_put_form';
+    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
+    readonly country: string;
+    readonly authentication: io.flow.payment.internal.v0.models.PaypalAuthenticationForm;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface MoneyWithOptionalBase {
-    readonly currency: string;
-    readonly amount: number;
-    readonly base?: io.flow.common.v0.models.Money;
+  interface PaypalAccountReference {
+    readonly id: string;
+    readonly flow_merchant_id?: string;
   }
 
-  interface Name {
-    readonly first?: string;
-    readonly last?: string;
+  interface PaypalAuthentication {
+    readonly username: string;
+    readonly password_reference: 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 PaypalAuthenticationForm {
+    readonly username: string;
+    readonly password: string;
   }
 
-  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 PaypalAuthorizationPayload {
+    readonly discriminator: 'paypal_authorization_payload';
+    readonly payment_id: string;
+    readonly payer_id: string;
   }
 
-  interface Organization {
-    readonly discriminator: 'organization';
+  interface PaypalMerchant {
+    readonly discriminator: 'paypal_merchant';
     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;
+    readonly key: string;
+    readonly organization_id: string;
+    readonly external_id: string;
+    readonly processor_account_reference: io.flow.payment.internal.v0.models.ProcessorAccountReference;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  interface OrganizationDefaults {
+  interface PaypalMerchantModificationForm {
+    readonly discriminator: 'paypal_merchant_modification_form';
+    readonly external_id: string;
     readonly country: string;
-    readonly base_currency: string;
-    readonly language: string;
-    readonly locale: string;
-    readonly timezone: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface OrganizationReference {
-    readonly discriminator: 'organization_reference';
+  interface PaypalMerchantPutForm {
+    readonly discriminator: 'paypal_merchant_put_form';
+    readonly organization_id: string;
+    readonly external_id: string;
+    readonly country: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
+  }
+
+  interface ProcessorAccountReference {
     readonly id: string;
+    readonly organization_id: string;
+    readonly key: string;
+    readonly processor: io.flow.payment.internal.v0.enums.Processor;
+    readonly country: string;
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface OrganizationSummary {
+  interface ProcessorEntityStatusForm {
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+  }
+
+  interface ProcessorMerchantReference {
     readonly id: string;
-    readonly name: string;
-    readonly environment: io.flow.common.v0.enums.Environment;
+    readonly organization_id: string;
+    readonly key: string;
+    readonly processor: io.flow.payment.internal.v0.enums.Processor;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface PartnerReference {
+  interface Redirect {
     readonly id: string;
+    readonly post_payment_redirect_urls: io.flow.payment.v0.models.PostPaymentRedirectUrls;
+    readonly reason: io.flow.payment.internal.v0.enums.RedirectReason;
   }
 
-  interface Price {
-    readonly amount: number;
-    readonly currency: string;
-    readonly label: string;
+  interface RedirectActionCompleted {
+    readonly discriminator: 'redirect_action_completed';
+    readonly id: string;
+    readonly organization: string;
+    readonly key: string;
+    readonly expires_at: string;
+    readonly post_payment_redirect_urls: io.flow.payment.v0.models.PostPaymentRedirectUrls;
+    readonly inline_notification_urls?: io.flow.payment.v0.models.PostPaymentRedirectUrls;
   }
 
-  interface PriceForm {
-    readonly amount: number;
-    readonly currency: string;
+  interface RoutingAccount {
+    readonly discriminator: 'routing_account';
+    readonly processor: io.flow.payment.internal.v0.enums.Processor;
+    readonly processor_account: io.flow.payment.internal.v0.models.ProcessorAccountReference;
   }
 
-  interface PriceSourceCatalog {
-    readonly discriminator: 'catalog';
-    readonly price: io.flow.common.v0.models.Money;
+  interface RoutingMerchant {
+    readonly discriminator: 'routing_merchant';
+    readonly processor: io.flow.payment.internal.v0.enums.Processor;
+    readonly processor_account: io.flow.payment.internal.v0.models.ProcessorAccountReference;
+    readonly processor_merchant: io.flow.payment.internal.v0.models.ProcessorMerchantReference;
   }
 
-  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 RoutingProcessor {
+    readonly discriminator: 'routing_processor';
+    readonly processor: io.flow.payment.internal.v0.enums.Processor;
   }
 
-  interface PriceSourcePriceBookReference {
+  interface StripeAccount {
+    readonly discriminator: 'stripe_account';
     readonly id: string;
+    readonly organization_id: string;
     readonly key: string;
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly name: string;
+    readonly external_id: string;
+    readonly country: string;
+    readonly authentication: io.flow.payment.internal.v0.models.StripeAuthentication;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  interface PriceSourceProvided {
-    readonly discriminator: 'provided';
-    readonly price: io.flow.common.v0.models.Money;
+  interface StripeAccountModificationForm {
+    readonly discriminator: 'stripe_account_modification_form';
+    readonly owner: io.flow.payment.internal.v0.enums.Owner;
+    readonly name: string;
+    readonly external_id: string;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  interface PriceWithBase {
-    readonly currency: string;
-    readonly amount: number;
-    readonly label: string;
-    readonly base?: io.flow.common.v0.models.Price;
+  interface StripeAccountPutForm {
+    readonly discriminator: 'stripe_account_put_form';
+    readonly owner?: io.flow.payment.internal.v0.enums.Owner;
+    readonly name: string;
+    readonly external_id: string;
+    readonly country: string;
+    readonly authentication: io.flow.payment.internal.v0.models.StripeAuthenticationForm;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface RepeatDaily {
-    readonly discriminator: 'repeat_daily';
-    readonly interval: number;
+  interface StripeAuthentication {
+    readonly public_key: string;
+    readonly secret_key_reference: string;
   }
 
-  interface RepeatHourly {
-    readonly discriminator: 'repeat_hourly';
-    readonly interval: number;
+  interface StripeAuthenticationDataReference {
+    readonly id: string;
   }
 
-  interface RepeatMonthly {
-    readonly discriminator: 'repeat_monthly';
-    readonly interval: number;
-    readonly days: number[];
+  interface StripeAuthenticationForm {
+    readonly public_key: string;
+    readonly secret_key: string;
   }
 
-  interface RepeatWeekly {
-    readonly discriminator: 'repeat_weekly';
-    readonly interval: number;
-    readonly days_of_week: io.flow.common.v0.enums.DayOfWeek[];
+  interface StripeMerchant {
+    readonly discriminator: 'stripe_merchant';
+    readonly id: string;
+    readonly key: string;
+    readonly organization_id: string;
+    readonly external_id: string;
+    readonly processor_account_reference: io.flow.payment.internal.v0.models.ProcessorAccountReference;
+    readonly name: string;
+    readonly account_type: io.flow.stripe.v0.enums.AccountType;
+    readonly country: string;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly organization_capability: io.flow.payment.internal.v0.enums.OrganizationCapability;
+    readonly created_at: string;
+    readonly updated_at: string;
   }
 
-  interface Rounding {
-    readonly type: io.flow.common.v0.enums.RoundingType;
-    readonly method: io.flow.common.v0.enums.RoundingMethod;
-    readonly value: number;
+  interface StripeMerchantForm {
+    readonly discriminator: 'stripe_merchant_form';
+    readonly key?: string;
+    readonly organization_id: string;
+    readonly name: string;
+    readonly account_type: io.flow.stripe.v0.enums.AccountType;
+    readonly country: string;
+    readonly payment_statement: string;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
   }
 
-  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 StripeMerchantModificationForm {
+    readonly discriminator: 'stripe_merchant_modification_form';
+    readonly external_id: string;
+    readonly name: string;
+    readonly account_type: io.flow.stripe.v0.enums.AccountType;
+    readonly status: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly country: string;
   }
 
-  interface SessionReference {
-    readonly id: string;
+  interface StripeMerchantPutForm {
+    readonly discriminator: 'stripe_merchant_put_form';
+    readonly organization_id: string;
+    readonly external_id: string;
+    readonly name: string;
+    readonly account_type: io.flow.stripe.v0.enums.AccountType;
+    readonly status?: io.flow.payment.internal.v0.enums.ProcessorEntityStatus;
+    readonly country: string;
+    readonly organization_capability?: io.flow.payment.internal.v0.enums.OrganizationCapability;
   }
 
-  interface User {
-    readonly discriminator: 'user';
+  interface Tribe {
     readonly id: string;
-    readonly email?: string;
-    readonly name: io.flow.common.v0.models.Name;
-    readonly status: io.flow.common.v0.enums.UserStatus;
+    readonly description: string;
   }
 
-  interface UserReference {
-    readonly discriminator: 'user_reference';
+  interface VirtualCardProvider {
     readonly id: string;
-  }
-
-  interface Zone {
-    readonly postals?: string[];
-    readonly provinces?: string[];
-    readonly country: string;
+    readonly organization_id: string;
+    readonly provider: string;
+    readonly attributes?: Record<string, string>;
+    readonly created_at: string;
+    readonly updated_at: 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.payment.internal.v0.unions {
+  type AuthorizationPayload =
+    | io.flow.payment.internal.v0.models.ApplePayAuthorizationPayload
+    | io.flow.payment.internal.v0.models.PaypalAuthorizationPayload;
+  type InlineAuthorizationParameters =
+    io.flow.payment.internal.v0.models.KlarnaAuthorizationParameters;
+  type InternalAuthorizationDetails =
+    | io.flow.payment.internal.v0.models.InternalPaypalAuthorizationDetails
+    | io.flow.payment.internal.v0.models.InternalBitpayAuthorizationDetails
+    | io.flow.payment.internal.v0.models.InternalStripeAuthorizationDetails
+    | io.flow.payment.internal.v0.models.InternalAdyenAuthorizationDetails
+    | io.flow.payment.internal.v0.models.InternalAfterpayAuthorizationDetails
+    | io.flow.payment.internal.v0.models.InternalFiservAuthorizationDetails;
+  type InternalRefundForm = io.flow.payment.internal.v0.models.AdyenRefundForm;
+  type InternalTransactionDetails =
+    io.flow.payment.internal.v0.models.InternalTransactionDetailsCard;
+  type PaymentRedirect =
+    | io.flow.payment.internal.v0.models.OnlineAuthorizationCompleted
+    | io.flow.payment.internal.v0.models.RedirectActionCompleted;
+  type ProcessorAccount =
+    | io.flow.payment.internal.v0.models.StripeAccount
+    | io.flow.payment.internal.v0.models.AdyenAccount
+    | io.flow.payment.internal.v0.models.PaypalAccount
+    | io.flow.payment.internal.v0.models.AfterpayAccount
+    | io.flow.payment.internal.v0.models.BitpayAccount
+    | io.flow.payment.internal.v0.models.FiservAccount
+    | io.flow.payment.internal.v0.models.CryptoAccount;
+  type ProcessorAccountModificationForm =
+    | io.flow.payment.internal.v0.models.StripeAccountModificationForm
+    | io.flow.payment.internal.v0.models.AdyenAccountModificationForm
+    | io.flow.payment.internal.v0.models.PaypalAccountModificationForm
+    | io.flow.payment.internal.v0.models.AfterpayAccountModificationForm
+    | io.flow.payment.internal.v0.models.BitpayAccountModificationForm
+    | io.flow.payment.internal.v0.models.FiservAccountModificationForm
+    | io.flow.payment.internal.v0.models.CryptoAccountModificationForm;
+  type ProcessorAccountPutForm =
+    | io.flow.payment.internal.v0.models.StripeAccountPutForm
+    | io.flow.payment.internal.v0.models.AdyenAccountPutForm
+    | io.flow.payment.internal.v0.models.PaypalAccountPutForm
+    | io.flow.payment.internal.v0.models.AfterpayAccountPutForm
+    | io.flow.payment.internal.v0.models.BitpayAccountPutForm
+    | io.flow.payment.internal.v0.models.FiservAccountPutForm
+    | io.flow.payment.internal.v0.models.CryptoAccountPutForm;
+  type ProcessorMerchant =
+    | io.flow.payment.internal.v0.models.StripeMerchant
+    | io.flow.payment.internal.v0.models.AdyenMerchant
+    | io.flow.payment.internal.v0.models.FiservMerchant
+    | io.flow.payment.internal.v0.models.PaypalMerchant;
+  type ProcessorMerchantForm =
+    io.flow.payment.internal.v0.models.StripeMerchantForm;
+  type ProcessorMerchantModificationForm =
+    | io.flow.payment.internal.v0.models.StripeMerchantModificationForm
+    | io.flow.payment.internal.v0.models.AdyenMerchantModificationForm
+    | io.flow.payment.internal.v0.models.FiservMerchantModificationForm
+    | io.flow.payment.internal.v0.models.PaypalMerchantModificationForm;
+  type ProcessorMerchantPutForm =
+    | io.flow.payment.internal.v0.models.StripeMerchantPutForm
+    | io.flow.payment.internal.v0.models.AdyenMerchantPutForm
+    | io.flow.payment.internal.v0.models.FiservMerchantPutForm
+    | io.flow.payment.internal.v0.models.PaypalMerchantPutForm;
+  type RoutingEntity =
+    | io.flow.payment.internal.v0.models.RoutingProcessor
+    | io.flow.payment.internal.v0.models.RoutingAccount
+    | io.flow.payment.internal.v0.models.RoutingMerchant;
 }
 
 declare namespace io.flow.ftp.v0.enums {
@@ -10852,298 +11201,40 @@ declare namespace io.flow.ftp.v0.models {
   }
 }
 
-declare namespace io.flow.billing.reporting.csv.v0.enums {
-  type ReportingFulfillmentIsVirtual = 'all' | 'mixed' | 'none';
-}
-
 declare namespace io.flow.billing.reporting.csv.v0.models {
-  interface FulfillmentShopperBreakdown {
-    readonly shipping: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly fees: io.flow.billing.reporting.csv.v0.models.ReportingShopperFees;
-    readonly product: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly subtotal: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly tax: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly duty: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly discount: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly total: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-  }
-
-  interface MarkedAsFinal {
-    readonly products: boolean;
-    readonly shipping: boolean;
-  }
-
-  interface RefundRecord {
-    readonly billing_entity: string;
-    readonly order_id: string;
-    readonly order_refund_id: string;
-    readonly refund_created_at_date: string;
-    readonly reconciliation_date: string;
-    readonly reconciliation_month: number;
-    readonly reconciliation_year: number;
-    readonly order_created_at_date: string;
-    readonly order_status: string;
-    readonly b2b_sale: boolean;
-    readonly a_zero_vat_product_exists: boolean;
-    readonly payment_merchant_reference?: string;
-    readonly merchant_reference?: string;
-    readonly merchant_id: string;
-    readonly merchant_name: string;
-    readonly destination_country: string;
-    readonly shopper_country_is_eu: boolean;
-    readonly order_refund_reason_name: string;
-    readonly order_refund_status_name: string;
-    readonly original_ccy: string;
-    readonly transaction_ccy: string;
-    readonly total_refund_amount_exc_vat_in_transaction_ccy?: number;
-    readonly refund_vat_in_transaction_ccy?: number;
-    readonly total_refund_amount_inc_vat_in_transaction_ccy?: number;
-    readonly merchant_total_products_refund_amount_exc_vat_in_original_ccy: number;
-    readonly merchant_shipping_refund_amount_exc_vat_in_transaction_ccy?: number;
-    readonly merchant_shipping_refund_amount_exc_vat_in_original_ccy: number;
-    readonly total_refund_amount_exc_tax_collected_in_shopper_ccy?: number;
-    readonly tax_collected_amount_in_shopper_ccy: number;
-    readonly total_refund_amount_inc_tax_collected_in_shopper_ccy?: number;
-    readonly payment_gateway: string;
-    readonly min_product_customer_vat_rate?: number;
-    readonly is_virtual_order: boolean;
-    readonly is_mixed_virtual_order: boolean;
-    readonly total_refund_amount_exc_tax_collected_in_usd: number;
-    readonly tax_collected_amount_in_usd: number;
-    readonly total_refund_amount_inc_tax_collected_in_usd: number;
-    readonly total_refund_amount_exc_tax_collected_in_eur: number;
-    readonly tax_collected_amount_in_eur: number;
-    readonly total_refund_amount_inc_tax_collected_in_eur: number;
-    readonly is_wyol_order: boolean;
-    readonly is_duties_guaranteed: boolean;
-    readonly invoice_id?: string;
-    readonly total_refund_amount_exc_vat_in_entity_ccy: number;
-    readonly refund_vat_in_entity_ccy: number;
-    readonly total_refund_amount_inc_vat_in_entity_ccy: number;
-    readonly merchant_total_products_refund_amount_exc_vat_in_entity_ccy: number;
-    readonly merchant_shipping_refund_amount_exc_vat_in_entity_ccy: number;
-    readonly merchant_duties_and_taxes_refund_amount_in_entity_ccy: number;
-    readonly merchant_service_gesture_amount_exc_vat_in_entity_ccy: number;
-    readonly customer_prepaid_refund_amount_exc_vat_in_entity_ccy: number;
-    readonly total_refund_amount_exc_tax_collected_in_entity_ccy: number;
-    readonly tax_collected_amount_in_entity_ccy: number;
-    readonly total_refund_amount_inc_tax_collected_in_entity_ccy: number;
-    readonly conversion_rate_transaction_to_entity_ccy: number;
-    readonly merchant_order_id: string;
-    readonly transaction_date: string;
-    readonly debug_console_order_link: string;
-  }
-
-  interface ReportingAuthorizationReference {
-    readonly id: string;
-  }
-
-  interface ReportingBusiness {
-    readonly vat_registration_number: string;
-    readonly name?: string;
-  }
-
-  interface ReportingConversionRates {
-    readonly merchant: number;
-    readonly entity: number;
-    readonly usd: number;
-    readonly eur: number;
-  }
-
-  interface ReportingCountry {
-    readonly code: string;
-    readonly is_eu: boolean;
-  }
-
-  interface ReportingCurrencies {
-    readonly transaction: string;
-    readonly merchant: string;
-    readonly entity: string;
-  }
-
-  interface ReportingDebug {
-    readonly console_order_link: string;
-    readonly allocation_order_totals_delta?: number;
-    readonly allocation_order_item_discount_delta?: number;
-    readonly missing_item_subsidies?: io.flow.billing.reporting.csv.v0.models.ReportingDebugMissingSubsidies;
-    readonly missing_shipping_subsidies?: io.flow.billing.reporting.csv.v0.models.ReportingDebugMissingSubsidies;
-  }
-
-  interface ReportingDebugMissingSubsidies {
-    readonly price?: boolean;
-    readonly tax?: boolean;
-    readonly duty?: boolean;
-  }
-
-  interface ReportingDestination {
-    readonly country: io.flow.billing.reporting.csv.v0.models.ReportingCountry;
-    readonly province?: io.flow.billing.reporting.csv.v0.models.ReportingProvince;
-  }
-
-  interface ReportingEntity {
-    readonly id: string;
-  }
-
   interface ReportingFulfillment {
     readonly id: string;
     readonly sequence_number: number;
     readonly fulfilled_at: string;
     readonly completes_order: boolean;
-    readonly payment: io.flow.billing.reporting.csv.v0.models.ReportingFulfillmentPayment;
-    readonly value: io.flow.billing.reporting.csv.v0.models.FulfillmentShopperBreakdown;
-    readonly dispatch_country?: io.flow.billing.reporting.csv.v0.models.ReportingCountry;
-    readonly destination: io.flow.billing.reporting.csv.v0.models.ReportingDestination;
+    readonly payment: io.flow.billing.reporting.v0.models.ReportingPayment;
+    readonly value: io.flow.billing.reporting.v0.models.FulfillmentShopperBreakdown;
+    readonly dispatch_country?: io.flow.billing.reporting.v0.models.ReportingCountry;
+    readonly destination: io.flow.billing.reporting.v0.models.ReportingDestination;
     readonly carrier?: string;
-    readonly is: io.flow.billing.reporting.csv.v0.models.ReportingFulfillmentIs;
-    readonly has: io.flow.billing.reporting.csv.v0.models.ReportingFulfillmentHas;
-    readonly fx: io.flow.billing.reporting.csv.v0.models.ReportingFx;
-    readonly business?: io.flow.billing.reporting.csv.v0.models.ReportingBusiness;
-  }
-
-  interface ReportingFulfillmentHas {
-    readonly zero_vat_product: boolean;
-  }
-
-  interface ReportingFulfillmentIs {
-    readonly replacement: boolean;
-    readonly virtual: io.flow.billing.reporting.csv.v0.enums.ReportingFulfillmentIsVirtual;
-    readonly duties_guaranteed: boolean;
-    readonly wyol: boolean;
-    readonly b2b: boolean;
-    readonly domestic: boolean;
-  }
-
-  interface ReportingFulfillmentPayment {
-    readonly metadata?: io.flow.billing.reporting.csv.v0.models.ReportingFulfillmentPaymentMetadata;
-    readonly psp: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly credit: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly total: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-  }
-
-  interface ReportingFulfillmentPaymentMetadata {
-    readonly gateway: io.flow.payment.internal.v0.enums.Processor;
-    readonly method: string;
-    readonly psp_reference?: string;
-    readonly authorization?: io.flow.billing.reporting.csv.v0.models.ReportingAuthorizationReference;
-    readonly settlement_date: string;
-    readonly additional_authorizations?: io.flow.billing.reporting.csv.v0.models.ReportingFulfillmentPaymentMetadataAdditionalAuthorizations;
-  }
-
-  interface ReportingFulfillmentPaymentMetadataAdditionalAuthorizations {
-    readonly ids: string;
-  }
-
-  interface ReportingFx {
-    readonly shipping: io.flow.billing.reporting.csv.v0.models.ReportingUsd;
-    readonly fees: io.flow.billing.reporting.csv.v0.models.ReportingUsd;
-    readonly product: io.flow.billing.reporting.csv.v0.models.ReportingUsd;
-    readonly tax: io.flow.billing.reporting.csv.v0.models.ReportingUsd;
-    readonly duty: io.flow.billing.reporting.csv.v0.models.ReportingUsd;
-    readonly total: io.flow.billing.reporting.csv.v0.models.ReportingUsd;
-  }
-
-  interface ReportingMerchantFees {
-    readonly duty_guarantee: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly mor: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly fraud: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly fx: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly processing: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly rate_lock: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly transfer: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-  }
-
-  interface ReportingMerchantSubsidies {
-    readonly shipping: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly tax: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly duty: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly ccf: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-  }
-
-  interface ReportingMerchantTransactions {
-    readonly adjustment: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly reversal: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly tax: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly duty: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly freight: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-  }
-
-  interface ReportingMonetaryValue {
-    readonly transaction: number;
-    readonly merchant: number;
-    readonly entity: number;
-    readonly usd: number;
-    readonly eur: number;
-  }
-
-  interface ReportingOrderSummary {
-    readonly id: string;
-    readonly number: string;
-    readonly submitted_at: string;
-  }
-
-  interface ReportingOrganizationSummary {
-    readonly id: string;
-    readonly name: string;
-  }
-
-  interface ReportingProvince {
-    readonly code?: string;
-    readonly name: string;
-  }
-
-  interface ReportingReconciliation {
-    readonly date: string;
-    readonly month: number;
-    readonly year: number;
-  }
-
-  interface ReportingShopperFees {
-    readonly fuel: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly remote_area: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly oversize: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly ccf: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly emergency: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-    readonly peak: io.flow.billing.reporting.csv.v0.models.ReportingMonetaryValue;
-  }
-
-  interface ReportingUsd {
-    readonly usd: number;
-  }
-
-  interface ReportingVatRemittance {
-    readonly currency: string;
-    readonly rate: io.flow.billing.reporting.csv.v0.models.ReportingVatRemittanceRate;
-  }
-
-  interface ReportingVatRemittanceRate {
-    readonly entity: number;
-  }
-
-  interface ReportingVendor {
-    readonly id: string;
+    readonly is: io.flow.billing.reporting.v0.models.ReportingFulfillmentIs;
+    readonly has: io.flow.billing.reporting.v0.models.ReportingFulfillmentHas;
+    readonly fx: io.flow.billing.reporting.v0.models.ReportingFx;
+    readonly business?: io.flow.billing.reporting.v0.models.ReportingBusiness;
   }
 
   interface SalesRecord {
     readonly id: string;
-    readonly parent?: io.flow.billing.reporting.csv.v0.models.SalesRecordReference;
-    readonly merchant: io.flow.billing.reporting.csv.v0.models.ReportingOrganizationSummary;
-    readonly order: io.flow.billing.reporting.csv.v0.models.ReportingOrderSummary;
-    readonly entity: io.flow.billing.reporting.csv.v0.models.ReportingEntity;
-    readonly vendor: io.flow.billing.reporting.csv.v0.models.ReportingVendor;
-    readonly currencies: io.flow.billing.reporting.csv.v0.models.ReportingCurrencies;
-    readonly conversion_rate: io.flow.billing.reporting.csv.v0.models.ReportingConversionRates;
+    readonly parent?: io.flow.billing.reporting.v0.models.RecordReference;
+    readonly merchant: io.flow.billing.reporting.v0.models.ReportingOrganizationSummary;
+    readonly order: io.flow.billing.reporting.v0.models.ReportingOrderSummary;
+    readonly entity: io.flow.billing.reporting.v0.models.ReportingEntity;
+    readonly vendor: io.flow.billing.reporting.v0.models.ReportingVendor;
+    readonly currencies: io.flow.billing.reporting.v0.models.ReportingCurrencies;
+    readonly conversion_rate: io.flow.billing.reporting.v0.models.ReportingConversionRates;
+    readonly reconciliation: io.flow.billing.reporting.v0.models.ReportingReconciliation;
+    readonly merchant_subsidies: io.flow.billing.reporting.v0.models.ReportingMerchantSubsidies;
+    readonly merchant_fees: io.flow.billing.reporting.v0.models.ReportingMerchantFees;
+    readonly merchant_transactions: io.flow.billing.reporting.v0.models.ReportingMerchantTransactions;
+    readonly debug: io.flow.billing.reporting.v0.models.ReportingDebug;
     readonly fulfillment: io.flow.billing.reporting.csv.v0.models.ReportingFulfillment;
-    readonly reconciliation: io.flow.billing.reporting.csv.v0.models.ReportingReconciliation;
-    readonly marked_as_final: io.flow.billing.reporting.csv.v0.models.MarkedAsFinal;
-    readonly merchant_subsidies: io.flow.billing.reporting.csv.v0.models.ReportingMerchantSubsidies;
-    readonly merchant_fees: io.flow.billing.reporting.csv.v0.models.ReportingMerchantFees;
-    readonly merchant_transactions: io.flow.billing.reporting.csv.v0.models.ReportingMerchantTransactions;
-    readonly vat_remittance: io.flow.billing.reporting.csv.v0.models.ReportingVatRemittance;
-    readonly debug: io.flow.billing.reporting.csv.v0.models.ReportingDebug;
-  }
-
-  interface SalesRecordReference {
-    readonly id: string;
+    readonly vat_remittance: io.flow.billing.reporting.v0.models.ReportingVatRemittance;
+    readonly marked_as_final: io.flow.billing.reporting.v0.models.MarkedAsFinal;
   }
 }
 
@@ -12451,6 +12542,12 @@ declare namespace io.flow.experience.v0.unions {
 declare namespace io.flow.payment.request.bundle.v0.models {
   interface PaymentRequestBilling {
     readonly fees: io.flow.payment.request.bundle.v0.models.PaymentRequestBillingFees;
+    readonly currency_rate?: io.flow.payment.request.bundle.v0.models.PaymentRequestBillingCurrencyRate;
+  }
+
+  interface PaymentRequestBillingCurrencyRate {
+    readonly base_amount: number;
+    readonly base_currency: string;
   }
 
   interface PaymentRequestBillingFees {
@@ -13458,6 +13555,7 @@ declare namespace io.flow.price.v0.unions {
 }
 
 declare namespace io.flow.trueup.v0.enums {
+  type CarrierChargeReason = 'return_to_origin' | 'rejection' | 'other';
   type TrueupSurchargeType =
     | 'fuel'
     | 'remote_area'
@@ -14753,6 +14851,7 @@ declare namespace io.flow.billing.internal.v0.enums {
     | 'tax'
     | 'duty'
     | 'trueup'
+    | 'carrier_charge'
     | 'all';
   type BillingStatementBatchFileKey = 'summary';
   type BillingTransactionStatus = 'pending' | 'pending_proof' | 'posted';
@@ -14777,7 +14876,9 @@ declare namespace io.flow.billing.internal.v0.enums {
     | 'channel_billed'
     | 'tax'
     | 'duty'
-    | 'trueup';
+    | 'trueup'
+    | 'carrier_charge';
+  type CarrierChargeTransactionType = 'adjustment' | 'reversal' | 'charge';
   type ChannelBilledTransactionType =
     | 'adjustment'
     | 'reversal'
@@ -14823,6 +14924,7 @@ declare namespace io.flow.billing.internal.v0.enums {
     | 'fulfillment_external'
     | 'fulfillment_order_combined_shipment'
     | 'fulfillment_order_time'
+    | 'return_refund'
     | 'label_tracking_summary'
     | 'label_invoice_request'
     | 'carrier_charge'
@@ -14834,6 +14936,7 @@ declare namespace io.flow.billing.internal.v0.enums {
     | 'refund'
     | 'refund_over_capture'
     | 'sales_record'
+    | 'refund_record'
     | 'statement_batch'
     | 'statement_email'
     | 'statement_summary_email'
@@ -15134,6 +15237,7 @@ declare namespace io.flow.billing.internal.v0.models {
     readonly tax: io.flow.common.v0.models.Price;
     readonly duty: io.flow.common.v0.models.Price;
     readonly trueup: io.flow.common.v0.models.Price;
+    readonly carrier_charge: io.flow.common.v0.models.Price;
     readonly ending_balance: io.flow.common.v0.models.Price;
   }
 
@@ -15148,6 +15252,19 @@ declare namespace io.flow.billing.internal.v0.models {
     readonly statement?: io.flow.billing.internal.v0.models.BillingStatementReference;
   }
 
+  interface CarrierChargeTransaction {
+    readonly discriminator: 'carrier_charge_transaction';
+    readonly order: io.flow.billing.internal.v0.models.BillingOrderTransactionOrderReference;
+    readonly id: string;
+    readonly type: io.flow.billing.internal.v0.enums.BillingTransactionType;
+    readonly status: io.flow.billing.internal.v0.enums.BillingTransactionStatus;
+    readonly posted_at?: string;
+    readonly value: io.flow.common.v0.models.Price;
+    readonly description: string;
+    readonly statement?: io.flow.billing.internal.v0.models.BillingStatementReference;
+    readonly created_at: string;
+  }
+
   interface ChannelAccount {
     readonly channel: io.flow.common.v0.models.ChannelReference;
     readonly id: string;
@@ -15890,7 +16007,8 @@ declare namespace io.flow.billing.internal.v0.unions {
     | io.flow.billing.internal.v0.models.ChannelBilledTransaction
     | io.flow.billing.internal.v0.models.TaxTransaction
     | io.flow.billing.internal.v0.models.DutyTransaction
-    | io.flow.billing.internal.v0.models.TrueupTransaction;
+    | io.flow.billing.internal.v0.models.TrueupTransaction
+    | io.flow.billing.internal.v0.models.CarrierChargeTransaction;
 }
 
 declare namespace io.flow.billing.v0.enums {
@@ -15924,6 +16042,7 @@ declare namespace io.flow.billing.v0.enums {
     | 'shipping_label'
     | 'shipping_label_service'
     | 'trueup'
+    | 'carrier_charge'
     | 'shipping_label_revenue_share'
     | 'platform_fee'
     | 'tax'
@@ -16191,6 +16310,13 @@ declare namespace io.flow.billing.v0.models {
     readonly updated_at: string;
   }
 
+  interface TransactionMetadataCarrierCharge {
+    readonly discriminator: 'carrier_charge';
+    readonly reason: io.flow.trueup.v0.enums.CarrierChargeReason;
+    readonly carrier_id: string;
+    readonly carrier_tracking_number: string;
+  }
+
   interface TransactionMetadataChannel {
     readonly discriminator: 'channel';
     readonly method: string;
@@ -16289,6 +16415,7 @@ declare namespace io.flow.billing.v0.unions {
     | io.flow.billing.v0.models.TransactionMetadataShippingLabel
     | io.flow.billing.v0.models.TransactionMetadataChannel
     | io.flow.billing.v0.models.TransactionMetadataTrueup
+    | io.flow.billing.v0.models.TransactionMetadataCarrierCharge
     | io.flow.billing.v0.models.TransactionMetadataManual;
 }
 
@@ -18102,7 +18229,10 @@ declare namespace io.flow.internal.v0.enums {
     | 'capture_transactions_ignored_fully_refunded_count'
     | 'capture_transactions_ignored_other_count'
     | 'capture_transactions_ignored_previously_processed_count'
+    | 'capture_queued_count'
     | 'capture_transactions_total'
+    | 'carrier_charge_transactions_count'
+    | 'carrier_charge_transactions_total'
     | 'channel_transactions_processing_count'
     | 'channel_transactions_processing_total'
     | 'channel_transactions_adjustment_count'
@@ -18132,6 +18262,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'refund_transactions_ignored_fully_refunded_count'
     | 'refund_transactions_ignored_other_count'
     | 'refund_transactions_ignored_previously_processed_count'
+    | 'refund_queued_count'
     | 'refund_transactions_total'
     | 'reversal_order_cancellations_transactions_count'
     | 'reversal_order_cancellations_transactions_total'
@@ -18177,7 +18308,12 @@ declare namespace io.flow.internal.v0.enums {
     | 'percentage_billable_label_transactions_with_carrier_charge_20_days'
     | 'percentage_billable_label_transactions_with_carrier_charge_30_days'
     | 'percentage_billable_label_transactions_with_carrier_charge_60_days'
-    | 'percentage_billable_label_transactions_with_carrier_charge_90_days';
+    | 'percentage_billable_label_transactions_with_carrier_charge_90_days'
+    | 'percentage_bank_account_updates'
+    | 'percentage_bank_account_unique_updates'
+    | 'negative_balance_number_accounts'
+    | 'negative_balance_total'
+    | 'negative_balance_single_account_max';
   type BillingStatementAttachmentKey =
     | 'invoice'
     | 'statement'
@@ -18194,6 +18330,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'tax'
     | 'duty'
     | 'trueup'
+    | 'carrier_charge'
     | 'all';
   type BillingStatementBatchFileKey = 'summary';
   type BillingTransactionStatus = 'pending' | 'pending_proof' | 'posted';
@@ -18218,7 +18355,8 @@ declare namespace io.flow.internal.v0.enums {
     | 'channel_billed'
     | 'tax'
     | 'duty'
-    | 'trueup';
+    | 'trueup'
+    | 'carrier_charge';
   type BlazeCheckoutEvent =
     | 'begin_checkout'
     | 'select_promotion'
@@ -18232,8 +18370,9 @@ declare namespace io.flow.internal.v0.enums {
     | 'dtce'
     | 'dtce_two_calls'
     | 'dtce_with_deminimis'
-    | 'dtce_merged_with_tax';
-  type CarrierChargeOtherReason = 'return_to_origin' | 'other';
+    | 'dtce_merged_with_tax'
+    | 'dtce_with_inclusive_pricing';
+  type CarrierChargeTransactionType = 'adjustment' | 'reversal' | 'charge';
   type CarrierLabelGenerationMethod = 'direct' | 'easypost';
   type CarrierValidationStatus = 'success' | 'error';
   type CatalogImportType =
@@ -18278,6 +18417,19 @@ declare namespace io.flow.internal.v0.enums {
     | 'partial'
     | 'cancelled';
   type ChannelTransactionType = 'adjustment' | 'reversal' | 'processing';
+  type ChargeEstimateSource = 'global-e' | 'shopify';
+  type ChargeInputType =
+    | 'fuelsc'
+    | 'incoterm_ddp'
+    | 'delivery_confirmation'
+    | 'base_charge'
+    | 'package_pickup'
+    | 'insurance'
+    | 'usps_first_mile'
+    | 'oversize_piece'
+    | 'incoterm_dap'
+    | 'emergency_situation'
+    | 'remote_area_delivery';
   type ChargebackPaymentStatus = 'captured' | 'refunded';
   type ChargebackProcessStatus = 'inquiry' | 'open' | 'closed';
   type CheckoutAddAuthorizationErrorCode =
@@ -18672,6 +18824,8 @@ declare namespace io.flow.internal.v0.enums {
     | 'daily_value_deleted'
     | 'sales_record_upserted'
     | 'sales_record_deleted'
+    | 'revenue_record_upserted'
+    | 'revenue_record_deleted'
     | 'calculator_organization_settings_upserted'
     | 'calculator_organization_settings_deleted'
     | 'carrier_account_upserted_v2'
@@ -19123,6 +19277,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'dtce'
     | 'restrictions'
     | 'organization_status'
+    | 'category_constraints'
     | 'miscellaneous';
   type OnboardingAutomationProcessState =
     | 'not_started'
@@ -19241,6 +19396,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'fulfillment_external'
     | 'fulfillment_order_combined_shipment'
     | 'fulfillment_order_time'
+    | 'return_refund'
     | 'label_tracking_summary'
     | 'label_invoice_request'
     | 'carrier_charge'
@@ -19252,6 +19408,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'refund'
     | 'refund_over_capture'
     | 'sales_record'
+    | 'refund_record'
     | 'statement_batch'
     | 'statement_email'
     | 'statement_summary_email'
@@ -19288,6 +19445,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'sales_record'
     | 'trueup_overview'
     | 'non_channel_payment_bank_account';
+  type ReportingFulfillmentIsVirtual = 'all' | 'mixed' | 'none';
   type ReportingScheme =
     | 'immediate_reporting_to_tax_authority'
     | 'periodic_reporting_to_tax_authority'
@@ -19302,6 +19460,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'escalated'
     | 'accepted'
     | 'restricted';
+  type RevenueRecordType = 'sales' | 'refund';
   type RiskCheck = 'three_d_secure';
   type RiskEvaluation =
     | 'Pending'
@@ -19350,7 +19509,8 @@ declare namespace io.flow.internal.v0.enums {
     | 'online_payment'
     | 'order_update'
     | 'product_restriction_result'
-    | 'product_sync';
+    | 'product_sync'
+    | 'webhook_registrations';
   type ShopifyMarketsTradeSector =
     | 'apparel_and_accessories'
     | 'beauty_and_cosmetics'
@@ -20464,6 +20624,7 @@ declare namespace io.flow.internal.v0.models {
     readonly tax: io.flow.common.v0.models.Price;
     readonly duty: io.flow.common.v0.models.Price;
     readonly trueup: io.flow.common.v0.models.Price;
+    readonly carrier_charge: io.flow.common.v0.models.Price;
     readonly ending_balance: io.flow.common.v0.models.Price;
   }
 
@@ -20906,7 +21067,7 @@ declare namespace io.flow.internal.v0.models {
   interface CarrierChargeFormOther {
     readonly discriminator: 'other';
     readonly id: string;
-    readonly reason: io.flow.internal.v0.enums.CarrierChargeOtherReason;
+    readonly reason: io.flow.trueup.v0.enums.CarrierChargeReason;
     readonly organization_id: string;
     readonly order_number: string;
     readonly carrier_id: string;
@@ -20921,6 +21082,19 @@ declare namespace io.flow.internal.v0.models {
     readonly attributes?: Record<string, string>;
   }
 
+  interface CarrierChargeTransaction {
+    readonly discriminator: 'carrier_charge_transaction';
+    readonly order: io.flow.internal.v0.models.BillingOrderTransactionOrderReference;
+    readonly id: string;
+    readonly type: io.flow.internal.v0.enums.BillingTransactionType;
+    readonly status: io.flow.internal.v0.enums.BillingTransactionStatus;
+    readonly posted_at?: string;
+    readonly value: io.flow.common.v0.models.Price;
+    readonly description: string;
+    readonly statement?: io.flow.internal.v0.models.BillingStatementReference;
+    readonly created_at: string;
+  }
+
   interface CarrierChargeUnits {
     readonly currency: string;
     readonly weight: io.flow.units.v0.enums.UnitOfWeight;
@@ -21246,6 +21420,11 @@ declare namespace io.flow.internal.v0.models {
     readonly channel_order_acceptance: io.flow.internal.v0.models.ChannelOrderAcceptance;
   }
 
+  interface ChannelOrderAcceptanceDetails {
+    readonly order_acceptance: io.flow.internal.v0.models.ChannelOrderAcceptance;
+    readonly external_order: any /*object*/;
+  }
+
   interface ChannelOrderAcceptanceForm {
     readonly status: io.flow.internal.v0.enums.ChannelOrderAcceptanceStatus;
   }
@@ -21361,6 +21540,12 @@ declare namespace io.flow.internal.v0.models {
     readonly channel_transaction: io.flow.internal.v0.models.ChannelTransaction;
   }
 
+  interface ChargeInput {
+    readonly charge_input_code: io.flow.internal.v0.enums.ChargeInputType;
+    readonly price: io.flow.common.v0.models.Money;
+    readonly charge_input_source: io.flow.internal.v0.enums.ChargeEstimateSource;
+  }
+
   interface Chargeback {
     readonly id: string;
     readonly key: string;
@@ -25823,6 +26008,17 @@ declare namespace io.flow.internal.v0.models {
     readonly items: io.flow.order.management.v0.models.FulfillmentItem[];
   }
 
+  interface FulfillmentShopperBreakdown {
+    readonly shipping: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly fees: io.flow.internal.v0.models.ReportingShopperFees;
+    readonly product: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly subtotal: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly tax: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly duty: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly discount: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly total: io.flow.internal.v0.models.ReportingMonetaryValue;
+  }
+
   interface FulfillmentSnapshot {
     readonly tracking_source: string;
     readonly fulfillment_status?: string;
@@ -27299,6 +27495,11 @@ declare namespace io.flow.internal.v0.models {
     readonly shipped_item_values: io.flow.internal.v0.models.ShippedItemValue[];
   }
 
+  interface JeanDemoItem {
+    readonly id: string;
+    readonly name: string;
+  }
+
   interface Key {
     readonly id: string;
     readonly created_at: string;
@@ -27373,6 +27574,7 @@ declare namespace io.flow.internal.v0.models {
     readonly organization: string;
     readonly shipping_label_form: io.flow.label.v0.unions.ShippingLabelForm;
     readonly shipment_cost?: io.flow.common.v0.models.Money;
+    readonly charges?: io.flow.internal.v0.models.ChargeInput[];
     readonly reference_id?: string;
   }
 
@@ -28000,6 +28202,11 @@ declare namespace io.flow.internal.v0.models {
     readonly number: string;
   }
 
+  interface MarkedAsFinal {
+    readonly products: boolean;
+    readonly shipping: boolean;
+  }
+
   interface MarketingGatewayChannel {
     readonly id: string;
     readonly platform: io.flow.internal.v0.enums.MarketingGatewayPlatform;
@@ -30337,6 +30544,10 @@ declare namespace io.flow.internal.v0.models {
     readonly orders_since_submitted_at?: string;
   }
 
+  interface RecordReference {
+    readonly id: string;
+  }
+
   interface Redirect {
     readonly id: string;
     readonly post_payment_redirect_urls: io.flow.payment.v0.models.PostPaymentRedirectUrls;
@@ -30405,6 +30616,52 @@ declare namespace io.flow.internal.v0.models {
     readonly task_id: string;
   }
 
+  interface ReportingAuthorizationReference {
+    readonly id: string;
+  }
+
+  interface ReportingBusiness {
+    readonly vat_registration_number: string;
+    readonly name?: string;
+  }
+
+  interface ReportingConversionRates {
+    readonly merchant: number;
+    readonly entity: number;
+    readonly usd: number;
+    readonly eur: number;
+  }
+
+  interface ReportingCountry {
+    readonly code: string;
+    readonly is_eu: boolean;
+  }
+
+  interface ReportingCurrencies {
+    readonly transaction: string;
+    readonly merchant: string;
+    readonly entity: string;
+  }
+
+  interface ReportingDebug {
+    readonly console_order_link: string;
+    readonly allocation_order_totals_delta?: number;
+    readonly allocation_order_item_discount_delta?: number;
+    readonly missing_item_subsidies?: io.flow.internal.v0.models.ReportingDebugMissingSubsidies;
+    readonly missing_shipping_subsidies?: io.flow.internal.v0.models.ReportingDebugMissingSubsidies;
+  }
+
+  interface ReportingDebugMissingSubsidies {
+    readonly price?: boolean;
+    readonly tax?: boolean;
+    readonly duty?: boolean;
+  }
+
+  interface ReportingDestination {
+    readonly country: io.flow.internal.v0.models.ReportingCountry;
+    readonly province?: io.flow.internal.v0.models.ReportingProvince;
+  }
+
   interface ReportingDetails {
     readonly accounting_transactions?: any /*object*/[];
     readonly fulfillments?: any /*object*/[];
@@ -30413,6 +30670,166 @@ declare namespace io.flow.internal.v0.models {
     readonly refund_records?: any /*object*/[];
   }
 
+  interface ReportingEntity {
+    readonly id: string;
+  }
+
+  interface ReportingFulfillment {
+    readonly id: string;
+    readonly sequence_number: number;
+    readonly fulfilled_at: string;
+    readonly completes_order: boolean;
+    readonly payment: io.flow.internal.v0.models.ReportingPayment;
+    readonly refund?: io.flow.internal.v0.models.ReportingRefundReference;
+    readonly value: io.flow.internal.v0.models.FulfillmentShopperBreakdown;
+    readonly dispatch_country?: io.flow.internal.v0.models.ReportingCountry;
+    readonly destination?: io.flow.internal.v0.models.ReportingDestination;
+    readonly shipment?: io.flow.internal.v0.models.ReportingShipment;
+    readonly is: io.flow.internal.v0.models.ReportingFulfillmentIs;
+    readonly has: io.flow.internal.v0.models.ReportingFulfillmentHas;
+    readonly fx: io.flow.internal.v0.models.ReportingFx;
+    readonly business?: io.flow.internal.v0.models.ReportingBusiness;
+  }
+
+  interface ReportingFulfillmentHas {
+    readonly zero_vat_product: boolean;
+  }
+
+  interface ReportingFulfillmentIs {
+    readonly replacement: boolean;
+    readonly virtual: io.flow.internal.v0.enums.ReportingFulfillmentIsVirtual;
+    readonly duties_guaranteed: boolean;
+    readonly wyol: boolean;
+    readonly b2b: boolean;
+    readonly domestic: boolean;
+  }
+
+  interface ReportingFx {
+    readonly shipping: io.flow.internal.v0.models.ReportingUsd;
+    readonly fees: io.flow.internal.v0.models.ReportingUsd;
+    readonly product: io.flow.internal.v0.models.ReportingUsd;
+    readonly tax: io.flow.internal.v0.models.ReportingUsd;
+    readonly duty: io.flow.internal.v0.models.ReportingUsd;
+    readonly total: io.flow.internal.v0.models.ReportingUsd;
+  }
+
+  interface ReportingMerchantBreakdown {
+    readonly subsidies: io.flow.internal.v0.models.ReportingMerchantSubsidies;
+    readonly fees: io.flow.internal.v0.models.ReportingMerchantFees;
+    readonly transactions: io.flow.internal.v0.models.ReportingMerchantTransactions;
+  }
+
+  interface ReportingMerchantFees {
+    readonly duty_guarantee: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly mor: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly fraud: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly fx: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly processing: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly rate_lock: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly transfer: io.flow.internal.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingMerchantSubsidies {
+    readonly shipping: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly tax: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly duty: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly ccf: io.flow.internal.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingMerchantTransactions {
+    readonly adjustment: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly reversal: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly tax: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly duty: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly freight: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly refund: io.flow.internal.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingMonetaryValue {
+    readonly transaction: number;
+    readonly merchant: number;
+    readonly entity: number;
+    readonly usd: number;
+    readonly eur: number;
+  }
+
+  interface ReportingOrderSummary {
+    readonly id: string;
+    readonly number: string;
+    readonly submitted_at: string;
+  }
+
+  interface ReportingOrganizationSummary {
+    readonly id: string;
+    readonly name: string;
+  }
+
+  interface ReportingPayment {
+    readonly metadata?: io.flow.internal.v0.models.ReportingPaymentMetadata;
+    readonly psp: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly credit: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly total: io.flow.internal.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingPaymentMetadata {
+    readonly gateway: io.flow.internal.v0.enums.Processor;
+    readonly method: string;
+    readonly psp_reference?: string;
+    readonly authorization?: io.flow.internal.v0.models.ReportingAuthorizationReference;
+    readonly settlement_date: string;
+    readonly additional_authorizations?: io.flow.internal.v0.models.ReportingPaymentMetadataAdditionalAuthorizations;
+  }
+
+  interface ReportingPaymentMetadataAdditionalAuthorizations {
+    readonly ids: string;
+  }
+
+  interface ReportingProvince {
+    readonly code?: string;
+    readonly name: string;
+  }
+
+  interface ReportingReconciliation {
+    readonly date: string;
+    readonly month: number;
+    readonly year: number;
+  }
+
+  interface ReportingRefundReference {
+    readonly id: string;
+  }
+
+  interface ReportingShipment {
+    readonly carrier: string;
+    readonly tracking_number?: string;
+  }
+
+  interface ReportingShopperFees {
+    readonly fuel: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly remote_area: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly oversize: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly ccf: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly emergency: io.flow.internal.v0.models.ReportingMonetaryValue;
+    readonly peak: io.flow.internal.v0.models.ReportingMonetaryValue;
+  }
+
+  interface ReportingUsd {
+    readonly usd: number;
+  }
+
+  interface ReportingVatRemittance {
+    readonly currency: string;
+    readonly rate: io.flow.internal.v0.models.ReportingVatRemittanceRate;
+  }
+
+  interface ReportingVatRemittanceRate {
+    readonly entity: number;
+  }
+
+  interface ReportingVendor {
+    readonly id: string;
+  }
+
   interface RequeueRequestForm {
     readonly product_ids?: string[];
     readonly hs6_codes?: string[];
@@ -30465,6 +30882,7 @@ declare namespace io.flow.internal.v0.models {
     readonly status?: io.flow.internal.v0.enums.RestrictionStatus;
     readonly statuses?: io.flow.internal.v0.enums.RestrictionStatus[];
     readonly rule_ids?: string[];
+    readonly user_ids?: string[];
     readonly categories?: string[];
     readonly product_name_query?: string;
     readonly positive_keywords?: string[];
@@ -30687,6 +31105,7 @@ declare namespace io.flow.internal.v0.models {
     readonly posting_cutoff: string;
     readonly trigger: io.flow.internal.v0.unions.ReturnTrigger;
     readonly returned_at: string;
+    readonly completes_order: boolean;
   }
 
   interface ReturnPolicyDeleted {
@@ -30733,6 +31152,40 @@ declare namespace io.flow.internal.v0.models {
     readonly refund: io.flow.payment.v0.models.RefundReference;
   }
 
+  interface RevenueRecord {
+    readonly id: string;
+    readonly organization: io.flow.internal.v0.models.ReportingOrganizationSummary;
+    readonly parent?: io.flow.internal.v0.models.RecordReference;
+    readonly type: io.flow.internal.v0.enums.RevenueRecordType;
+    readonly order: io.flow.internal.v0.models.ReportingOrderSummary;
+    readonly entity: io.flow.internal.v0.models.ReportingEntity;
+    readonly vendor: io.flow.internal.v0.models.ReportingVendor;
+    readonly currencies: io.flow.internal.v0.models.ReportingCurrencies;
+    readonly conversion_rate: io.flow.internal.v0.models.ReportingConversionRates;
+    readonly reconciliation: io.flow.internal.v0.models.ReportingReconciliation;
+    readonly merchant: io.flow.internal.v0.models.ReportingMerchantBreakdown;
+    readonly fulfillment: io.flow.internal.v0.models.ReportingFulfillment;
+    readonly vat_remittance: io.flow.internal.v0.models.ReportingVatRemittance;
+    readonly marked_as_final: io.flow.internal.v0.models.MarkedAsFinal;
+    readonly debug: io.flow.internal.v0.models.ReportingDebug;
+  }
+
+  interface RevenueRecordDeleted {
+    readonly discriminator: 'revenue_record_deleted';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly id: string;
+  }
+
+  interface RevenueRecordUpserted {
+    readonly discriminator: 'revenue_record_upserted';
+    readonly event_id: string;
+    readonly timestamp: string;
+    readonly organization: string;
+    readonly revenue_record: io.flow.internal.v0.models.RevenueRecord;
+  }
+
   interface RoutingAccount {
     readonly discriminator: 'routing_account';
     readonly processor: io.flow.internal.v0.enums.Processor;
@@ -33165,6 +33618,8 @@ declare namespace io.flow.internal.v0.unions {
     | io.flow.internal.v0.models.DailyValueDeleted
     | io.flow.internal.v0.models.SalesRecordUpserted
     | io.flow.internal.v0.models.SalesRecordDeleted
+    | io.flow.internal.v0.models.RevenueRecordUpserted
+    | io.flow.internal.v0.models.RevenueRecordDeleted
     | io.flow.internal.v0.models.CalculatorOrganizationSettingsUpserted
     | io.flow.internal.v0.models.CalculatorOrganizationSettingsDeleted
     | io.flow.internal.v0.models.CarrierAccountUpsertedV2
@@ -33702,7 +34157,8 @@ declare namespace io.flow.internal.v0.unions {
     | io.flow.internal.v0.models.ChannelBilledTransaction
     | io.flow.internal.v0.models.TaxTransaction
     | io.flow.internal.v0.models.DutyTransaction
-    | io.flow.internal.v0.models.TrueupTransaction;
+    | io.flow.internal.v0.models.TrueupTransaction
+    | io.flow.internal.v0.models.CarrierChargeTransaction;
   type TransactionSummary =
     | io.flow.internal.v0.models.PaymentSummaryV2
     | io.flow.internal.v0.models.FraudSummary;
@@ -34118,8 +34574,10 @@ export type CarrierChargeFormLabel =
   io.flow.internal.v0.models.CarrierChargeFormLabel;
 export type CarrierChargeFormOther =
   io.flow.internal.v0.models.CarrierChargeFormOther;
-export type CarrierChargeOtherReason =
-  io.flow.internal.v0.enums.CarrierChargeOtherReason;
+export type CarrierChargeTransaction =
+  io.flow.internal.v0.models.CarrierChargeTransaction;
+export type CarrierChargeTransactionType =
+  io.flow.internal.v0.enums.CarrierChargeTransactionType;
 export type CarrierChargeUnits = io.flow.internal.v0.models.CarrierChargeUnits;
 export type CarrierCredentials = io.flow.internal.v0.unions.CarrierCredentials;
 export type CarrierInvoice = io.flow.internal.v0.models.CarrierInvoice;
@@ -34205,6 +34663,8 @@ export type ChannelOrderAcceptance =
   io.flow.internal.v0.models.ChannelOrderAcceptance;
 export type ChannelOrderAcceptanceDeleted =
   io.flow.internal.v0.models.ChannelOrderAcceptanceDeleted;
+export type ChannelOrderAcceptanceDetails =
+  io.flow.internal.v0.models.ChannelOrderAcceptanceDetails;
 export type ChannelOrderAcceptanceErrorAction =
   io.flow.internal.v0.enums.ChannelOrderAcceptanceErrorAction;
 export type ChannelOrderAcceptanceForm =
@@ -34250,6 +34710,10 @@ export type ChannelTransactionType =
   io.flow.internal.v0.enums.ChannelTransactionType;
 export type ChannelTransactionUpserted =
   io.flow.internal.v0.models.ChannelTransactionUpserted;
+export type ChargeEstimateSource =
+  io.flow.internal.v0.enums.ChargeEstimateSource;
+export type ChargeInput = io.flow.internal.v0.models.ChargeInput;
+export type ChargeInputType = io.flow.internal.v0.enums.ChargeInputType;
 export type Chargeback = io.flow.internal.v0.models.Chargeback;
 export type ChargebackDeleted = io.flow.internal.v0.models.ChargebackDeleted;
 export type ChargebackPaymentStatus =
@@ -35847,6 +36311,8 @@ export type FulfillmentReference =
   io.flow.internal.v0.models.FulfillmentReference;
 export type FulfillmentShipmentTracking =
   io.flow.internal.v0.models.FulfillmentShipmentTracking;
+export type FulfillmentShopperBreakdown =
+  io.flow.internal.v0.models.FulfillmentShopperBreakdown;
 export type FulfillmentSnapshot =
   io.flow.internal.v0.models.FulfillmentSnapshot;
 export type FulfillmentSubsidyBreakdown =
@@ -36143,6 +36609,7 @@ export type ItemSummary = io.flow.internal.v0.models.ItemSummary;
 export type ItemType = io.flow.internal.v0.enums.ItemType;
 export type ItemValuesForm = io.flow.internal.v0.models.ItemValuesForm;
 export type ItemsShipped = io.flow.internal.v0.models.ItemsShipped;
+export type JeanDemoItem = io.flow.internal.v0.models.JeanDemoItem;
 export type Key = io.flow.internal.v0.models.Key;
 export type KeyReference = io.flow.internal.v0.models.KeyReference;
 export type KeywordType = io.flow.internal.v0.enums.KeywordType;
@@ -36311,6 +36778,7 @@ export type ManualTransactionForm =
   io.flow.internal.v0.models.ManualTransactionForm;
 export type ManualTransactionFormOrder =
   io.flow.internal.v0.models.ManualTransactionFormOrder;
+export type MarkedAsFinal = io.flow.internal.v0.models.MarkedAsFinal;
 export type MarketingGatewayAccountConnectionStatus =
   io.flow.internal.v0.enums.MarketingGatewayAccountConnectionStatus;
 export type MarketingGatewayChannel =
@@ -36985,6 +37453,7 @@ export type ReboundConfigurationForm =
   io.flow.internal.v0.models.ReboundConfigurationForm;
 export type ReboundConfigurationStatus =
   io.flow.internal.v0.enums.ReboundConfigurationStatus;
+export type RecordReference = io.flow.internal.v0.models.RecordReference;
 export type Redirect = io.flow.internal.v0.models.Redirect;
 export type RedirectActionCompleted =
   io.flow.internal.v0.models.RedirectActionCompleted;
@@ -37004,8 +37473,64 @@ export type ReportRuleDecision = io.flow.internal.v0.models.ReportRuleDecision;
 export type ReportStatus = io.flow.internal.v0.enums.ReportStatus;
 export type ReportSummary = io.flow.internal.v0.models.ReportSummary;
 export type ReportType = io.flow.internal.v0.enums.ReportType;
+export type ReportingAuthorizationReference =
+  io.flow.internal.v0.models.ReportingAuthorizationReference;
+export type ReportingBusiness = io.flow.internal.v0.models.ReportingBusiness;
+export type ReportingConversionRates =
+  io.flow.internal.v0.models.ReportingConversionRates;
+export type ReportingCountry = io.flow.internal.v0.models.ReportingCountry;
+export type ReportingCurrencies =
+  io.flow.internal.v0.models.ReportingCurrencies;
+export type ReportingDebug = io.flow.internal.v0.models.ReportingDebug;
+export type ReportingDebugMissingSubsidies =
+  io.flow.internal.v0.models.ReportingDebugMissingSubsidies;
+export type ReportingDestination =
+  io.flow.internal.v0.models.ReportingDestination;
 export type ReportingDetails = io.flow.internal.v0.models.ReportingDetails;
+export type ReportingEntity = io.flow.internal.v0.models.ReportingEntity;
+export type ReportingFulfillment =
+  io.flow.internal.v0.models.ReportingFulfillment;
+export type ReportingFulfillmentHas =
+  io.flow.internal.v0.models.ReportingFulfillmentHas;
+export type ReportingFulfillmentIs =
+  io.flow.internal.v0.models.ReportingFulfillmentIs;
+export type ReportingFulfillmentIsVirtual =
+  io.flow.internal.v0.enums.ReportingFulfillmentIsVirtual;
+export type ReportingFx = io.flow.internal.v0.models.ReportingFx;
+export type ReportingMerchantBreakdown =
+  io.flow.internal.v0.models.ReportingMerchantBreakdown;
+export type ReportingMerchantFees =
+  io.flow.internal.v0.models.ReportingMerchantFees;
+export type ReportingMerchantSubsidies =
+  io.flow.internal.v0.models.ReportingMerchantSubsidies;
+export type ReportingMerchantTransactions =
+  io.flow.internal.v0.models.ReportingMerchantTransactions;
+export type ReportingMonetaryValue =
+  io.flow.internal.v0.models.ReportingMonetaryValue;
+export type ReportingOrderSummary =
+  io.flow.internal.v0.models.ReportingOrderSummary;
+export type ReportingOrganizationSummary =
+  io.flow.internal.v0.models.ReportingOrganizationSummary;
+export type ReportingPayment = io.flow.internal.v0.models.ReportingPayment;
+export type ReportingPaymentMetadata =
+  io.flow.internal.v0.models.ReportingPaymentMetadata;
+export type ReportingPaymentMetadataAdditionalAuthorizations =
+  io.flow.internal.v0.models.ReportingPaymentMetadataAdditionalAuthorizations;
+export type ReportingProvince = io.flow.internal.v0.models.ReportingProvince;
+export type ReportingReconciliation =
+  io.flow.internal.v0.models.ReportingReconciliation;
+export type ReportingRefundReference =
+  io.flow.internal.v0.models.ReportingRefundReference;
 export type ReportingScheme = io.flow.internal.v0.enums.ReportingScheme;
+export type ReportingShipment = io.flow.internal.v0.models.ReportingShipment;
+export type ReportingShopperFees =
+  io.flow.internal.v0.models.ReportingShopperFees;
+export type ReportingUsd = io.flow.internal.v0.models.ReportingUsd;
+export type ReportingVatRemittance =
+  io.flow.internal.v0.models.ReportingVatRemittance;
+export type ReportingVatRemittanceRate =
+  io.flow.internal.v0.models.ReportingVatRemittanceRate;
+export type ReportingVendor = io.flow.internal.v0.models.ReportingVendor;
 export type RequeueRequestForm = io.flow.internal.v0.models.RequeueRequestForm;
 export type ResponsibleParty = io.flow.internal.v0.enums.ResponsibleParty;
 export type RestrictionAction = io.flow.internal.v0.enums.RestrictionAction;
@@ -37080,6 +37605,12 @@ export type ReturnSummary = io.flow.internal.v0.models.ReturnSummary;
 export type ReturnTrigger = io.flow.internal.v0.unions.ReturnTrigger;
 export type ReturnTriggerRefund =
   io.flow.internal.v0.models.ReturnTriggerRefund;
+export type RevenueRecord = io.flow.internal.v0.models.RevenueRecord;
+export type RevenueRecordDeleted =
+  io.flow.internal.v0.models.RevenueRecordDeleted;
+export type RevenueRecordType = io.flow.internal.v0.enums.RevenueRecordType;
+export type RevenueRecordUpserted =
+  io.flow.internal.v0.models.RevenueRecordUpserted;
 export type RiskCheck = io.flow.internal.v0.enums.RiskCheck;
 export type RiskEvaluation = io.flow.internal.v0.enums.RiskEvaluation;
 export type RoutingAccount = io.flow.internal.v0.models.RoutingAccount;