@flowio/types 11.24.80 → 11.24.82

package/src/api-internal.ts

@@ -2402,9 +2402,16 @@ declare namespace io.flow.billing.csv.v0.models {
     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;
@@ -7257,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'
@@ -7435,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 {
@@ -7509,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;
@@ -8578,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 {
@@ -8589,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;
@@ -8895,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;
@@ -8920,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;
@@ -8965,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;
@@ -9227,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;
@@ -10034,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 {
@@ -10864,263 +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 RecordReference {
-    readonly id: string;
-  }
-
-  interface RefundRecord {
-    readonly id: string;
-    readonly parent?: io.flow.billing.reporting.csv.v0.models.RecordReference;
-    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 reconciliation: io.flow.billing.reporting.csv.v0.models.ReportingReconciliation;
-    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 debug: io.flow.billing.reporting.csv.v0.models.ReportingDebug;
-    readonly return?: io.flow.billing.reporting.csv.v0.models.ReportingReturn;
-  }
-
-  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;
-    readonly refund: 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 ReportingReturn {
-    readonly placeholder: string;
-  }
-
-  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.RecordReference;
-    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 reconciliation: io.flow.billing.reporting.csv.v0.models.ReportingReconciliation;
-    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 debug: io.flow.billing.reporting.csv.v0.models.ReportingDebug;
+    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 vat_remittance: io.flow.billing.reporting.csv.v0.models.ReportingVatRemittance;
-    readonly marked_as_final: io.flow.billing.reporting.csv.v0.models.MarkedAsFinal;
-  }
-
-  interface TransactionReference {
-    readonly id: string;
+    readonly vat_remittance: io.flow.billing.reporting.v0.models.ReportingVatRemittance;
+    readonly marked_as_final: io.flow.billing.reporting.v0.models.MarkedAsFinal;
   }
 }
 
@@ -12428,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 {
@@ -13435,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'
@@ -14730,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';
@@ -14754,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'
@@ -14780,7 +14904,8 @@ declare namespace io.flow.billing.internal.v0.enums {
     | 'shipping_true_up'
     | 'tax_credit'
     | 'carrier_credit'
-    | 'negative_balance_guarantee';
+    | 'negative_balance_guarantee'
+    | 'bank_payment_failure';
   type OrderCancellationInitiatedBy = 'flow' | 'organization';
   type OrderTransactionType = 'adjustment' | 'reversal' | 'order_service';
   type PreferredBillingSchedule = 'monthly' | 'bi-monthly';
@@ -14791,32 +14916,6 @@ declare namespace io.flow.billing.internal.v0.enums {
     | 'refund'
     | 'fully_subsidized_order'
     | 'credit_payment';
-  type QueuedRecordType =
-    | 'capture'
-    | 'channel_transaction'
-    | 'consumer_invoice'
-    | 'fulfillment_in_transit'
-    | 'fulfillment_shipping_notification'
-    | 'fulfillment_external'
-    | 'fulfillment_order_combined_shipment'
-    | 'fulfillment_order_time'
-    | 'label_tracking_summary'
-    | 'label_invoice_request'
-    | 'carrier_charge'
-    | 'carrier_charge_file'
-    | 'order'
-    | 'order_identifier'
-    | 'organization_onboarding_state'
-    | 'posting_proof'
-    | 'refund'
-    | 'refund_over_capture'
-    | 'sales_record'
-    | 'statement_batch'
-    | 'statement_email'
-    | 'statement_summary_email'
-    | 'pending_payout_transaction_event'
-    | 'credit_and_subsidy'
-    | 'negative_balance_guarantee';
   type ResponsibleParty = 'flow' | 'organization';
   type StatementTransferTransactionLocation = 'transactions_file' | 'summary';
   type SubscriptionFrequency = 'yearly' | 'monthly';
@@ -15111,6 +15210,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;
   }
 
@@ -15125,6 +15225,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;
@@ -15867,7 +15980,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 {
@@ -15901,6 +16015,7 @@ declare namespace io.flow.billing.v0.enums {
     | 'shipping_label'
     | 'shipping_label_service'
     | 'trueup'
+    | 'carrier_charge'
     | 'shipping_label_revenue_share'
     | 'platform_fee'
     | 'tax'
@@ -16168,6 +16283,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;
@@ -16266,6 +16388,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;
 }
 
@@ -18079,7 +18202,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'
@@ -18109,6 +18235,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'
@@ -18154,7 +18281,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'
@@ -18171,6 +18303,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'tax'
     | 'duty'
     | 'trueup'
+    | 'carrier_charge'
     | 'all';
   type BillingStatementBatchFileKey = 'summary';
   type BillingTransactionStatus = 'pending' | 'pending_proof' | 'posted';
@@ -18195,7 +18328,8 @@ declare namespace io.flow.internal.v0.enums {
     | 'channel_billed'
     | 'tax'
     | 'duty'
-    | 'trueup';
+    | 'trueup'
+    | 'carrier_charge';
   type BlazeCheckoutEvent =
     | 'begin_checkout'
     | 'select_promotion'
@@ -18209,8 +18343,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 =
@@ -18266,6 +18401,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'usps_first_mile'
     | 'oversize_piece'
     | 'incoterm_dap'
+    | 'emergency_situation'
     | 'remote_area_delivery';
   type ChargebackPaymentStatus = 'captured' | 'refunded';
   type ChargebackProcessStatus = 'inquiry' | 'open' | 'closed';
@@ -18556,6 +18692,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'confirmation'
     | 'invalid_checkout';
   type ClassificationErrorCode = 'generic_error';
+  type ColmItemType = 'physical' | 'digital';
   type ComplianceType = 'weee';
   type ContentElementType = 'markdown' | 'html' | 'plain_text' | 'href';
   type ContentStatus = 'draft' | 'live' | 'archived';
@@ -18661,6 +18798,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'
@@ -19025,7 +19164,8 @@ declare namespace io.flow.internal.v0.enums {
     | 'shipping_true_up'
     | 'tax_credit'
     | 'carrier_credit'
-    | 'negative_balance_guarantee';
+    | 'negative_balance_guarantee'
+    | 'bank_payment_failure';
   type MarketingGatewayAccountConnectionStatus =
     | 'not_connected'
     | 'connecting'
@@ -19112,6 +19252,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'dtce'
     | 'restrictions'
     | 'organization_status'
+    | 'category_constraints'
     | 'miscellaneous';
   type OnboardingAutomationProcessState =
     | 'not_started'
@@ -19221,33 +19362,6 @@ declare namespace io.flow.internal.v0.enums {
   type PromptCheckoutDisplayPosition = 'email' | 'submission';
   type PromptOptions = 'notice_only' | 'require_consent' | 'consent_by_default';
   type PromptTarget = 'browse' | 'checkout';
-  type QueuedRecordType =
-    | 'capture'
-    | 'channel_transaction'
-    | 'consumer_invoice'
-    | 'fulfillment_in_transit'
-    | 'fulfillment_shipping_notification'
-    | 'fulfillment_external'
-    | 'fulfillment_order_combined_shipment'
-    | 'fulfillment_order_time'
-    | 'return_refund'
-    | 'label_tracking_summary'
-    | 'label_invoice_request'
-    | 'carrier_charge'
-    | 'carrier_charge_file'
-    | 'order'
-    | 'order_identifier'
-    | 'organization_onboarding_state'
-    | 'posting_proof'
-    | 'refund'
-    | 'refund_over_capture'
-    | 'sales_record'
-    | 'statement_batch'
-    | 'statement_email'
-    | 'statement_summary_email'
-    | 'pending_payout_transaction_event'
-    | 'credit_and_subsidy'
-    | 'negative_balance_guarantee';
   type QuoteRequestType =
     | 'generate'
     | 'delete'
@@ -19278,6 +19392,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'
@@ -19292,6 +19407,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'escalated'
     | 'accepted'
     | 'restricted';
+  type RevenueRecordType = 'sales' | 'refund';
   type RiskCheck = 'three_d_secure';
   type RiskEvaluation =
     | 'Pending'
@@ -19340,7 +19456,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'
@@ -19365,6 +19482,7 @@ declare namespace io.flow.internal.v0.enums {
     | 'duty';
   type ShopifyPromotionStatus = 'active' | 'inactive';
   type ShopifyService = 'payment' | 'duty_tax_calculator';
+  type ShrutiDemoType = 'digital' | 'physical';
   type SignificanceAction =
     | 'end_and_implement_winner'
     | 'end_and_revert'
@@ -19388,6 +19506,7 @@ declare namespace io.flow.internal.v0.enums {
   type Status = 'draft' | 'scheduled' | 'live' | 'ended' | 'archived';
   type SubscriptionFrequency = 'yearly' | 'monthly';
   type SuggestionAction = 'accept' | 'validate' | 'review';
+  type SvitlanaType = 'physical' | 'digital';
   type TariffEligibilityType = 'rex';
   type TaskProcessorKey =
     | 'order_messenger'
@@ -20454,6 +20573,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;
   }
 
@@ -20896,7 +21016,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;
@@ -20911,6 +21031,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;
@@ -23681,6 +23814,23 @@ declare namespace io.flow.internal.v0.models {
     readonly classified_by: string;
   }
 
+  interface ColmItem {
+    readonly id: string;
+    readonly number: string;
+    readonly amount: io.flow.common.v0.models.Price;
+    readonly description?: string;
+    readonly type: io.flow.internal.v0.enums.ColmItemType;
+    readonly added_on: string;
+  }
+
+  interface ColmItemForm {
+    readonly number: string;
+    readonly amount: io.flow.common.v0.models.Price;
+    readonly description?: string;
+    readonly type: io.flow.internal.v0.enums.ColmItemType;
+    readonly added_on: string;
+  }
+
   interface CommercialInvoiceComparison {
     readonly urls: string[];
   }
@@ -25824,6 +25974,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;
@@ -27300,6 +27461,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;
@@ -28002,6 +28168,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;
@@ -29853,8 +30024,6 @@ declare namespace io.flow.internal.v0.models {
     readonly status: io.flow.internal.v0.enums.RestrictionStatus;
     readonly matching_positive_keywords: string[];
     readonly matching_negative_keywords: string[];
-    readonly positive_search_matches?: string[];
-    readonly negative_search_matches?: string[];
     readonly updated_by_user_id: string;
   }
 
@@ -30339,6 +30508,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;
@@ -30407,6 +30580,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*/[];
@@ -30415,6 +30634,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[];
@@ -30467,6 +30846,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[];
@@ -30504,8 +30884,6 @@ declare namespace io.flow.internal.v0.models {
   interface RestrictionKeywords {
     readonly positive_keywords: string[];
     readonly negative_keywords: string[];
-    readonly positive_search_matches: string[];
-    readonly negative_search_matches: string[];
   }
 
   interface RestrictionOrganization {
@@ -30594,8 +30972,6 @@ declare namespace io.flow.internal.v0.models {
     readonly accepted_rules?: string[];
     readonly positive_keywords?: string[];
     readonly negative_keywords?: string[];
-    readonly positive_search_matches?: string[];
-    readonly negative_search_matches?: string[];
     readonly user_ids?: string[];
     readonly categories?: string[];
     readonly product_name_query?: string;
@@ -30689,6 +31065,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 {
@@ -30735,6 +31112,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;
@@ -31068,11 +31479,12 @@ declare namespace io.flow.internal.v0.models {
     readonly shopify_markets_order: io.flow.internal.v0.models.ShopifyMarketsOrder;
   }
 
-  interface ShopifyMarketsOrderVersion {
+  interface ShopifyMarketsOrderVersionWithShopId {
     readonly id: string;
     readonly timestamp: string;
     readonly type: io.flow.common.v0.enums.ChangeType;
     readonly shopify_markets_order: io.flow.shopify.markets.internal.event.v0.models.ShopifyMarketsOrder;
+    readonly shop_id?: string;
   }
 
   interface ShopifyMarketsOrdersMetrics {
@@ -31534,6 +31946,23 @@ declare namespace io.flow.internal.v0.models {
     readonly total: number;
   }
 
+  interface ShrutiDemoItem {
+    readonly id: string;
+    readonly number: string;
+    readonly amount: io.flow.common.v0.models.Price;
+    readonly description?: string;
+    readonly type: io.flow.internal.v0.enums.ShrutiDemoType;
+    readonly added_on: string;
+  }
+
+  interface ShrutiDemoItemForm {
+    readonly number: string;
+    readonly amount: io.flow.common.v0.models.Price;
+    readonly description?: string;
+    readonly type: io.flow.internal.v0.enums.ShrutiDemoType;
+    readonly added_on: string;
+  }
+
   interface SimpleAccountReference {
     readonly id: string;
   }
@@ -31982,6 +32411,22 @@ declare namespace io.flow.internal.v0.models {
     readonly svb_virtual_card_clearing: io.flow.internal.v0.models.SvbVirtualCardClearing;
   }
 
+  interface SvitlanaItem {
+    readonly id: string;
+    readonly number: string;
+    readonly amount: number;
+    readonly description?: string;
+    readonly type: io.flow.internal.v0.enums.SvitlanaType;
+    readonly added_on: string;
+  }
+
+  interface SvitlanaItemForm {
+    readonly number: string;
+    readonly amount: number;
+    readonly description?: string;
+    readonly type: io.flow.internal.v0.enums.SvitlanaType;
+  }
+
   interface TariffCodeDuty {
     readonly tariff_code: string;
     readonly duties: Record<string, io.flow.internal.v0.models.Duties>;
@@ -33167,6 +33612,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
@@ -33704,7 +34151,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;
@@ -34120,8 +34568,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;
@@ -35344,6 +35794,9 @@ export type ClassificationWrapper =
 export type ClassifiedProduct = io.flow.internal.v0.models.ClassifiedProduct;
 export type ClassifiedProductDetail =
   io.flow.internal.v0.models.ClassifiedProductDetail;
+export type ColmItem = io.flow.internal.v0.models.ColmItem;
+export type ColmItemForm = io.flow.internal.v0.models.ColmItemForm;
+export type ColmItemType = io.flow.internal.v0.enums.ColmItemType;
 export type CommercialInvoiceComparison =
   io.flow.internal.v0.models.CommercialInvoiceComparison;
 export type CommercialInvoiceInternal =
@@ -35855,6 +36308,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 =
@@ -36151,6 +36606,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;
@@ -36319,6 +36775,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 =
@@ -36893,7 +37350,6 @@ export type ProofOfPostingOrderCombinedShipment =
 export type ProofOfPostingShippingNotification =
   io.flow.internal.v0.models.ProofOfPostingShippingNotification;
 export type QueuedRecord = io.flow.internal.v0.models.QueuedRecord;
-export type QueuedRecordType = io.flow.internal.v0.enums.QueuedRecordType;
 export type QuoteRequest = io.flow.internal.v0.models.QuoteRequest;
 export type QuoteRequestType = io.flow.internal.v0.enums.QuoteRequestType;
 export type RateAndRuleItem = io.flow.internal.v0.models.RateAndRuleItem;
@@ -36993,6 +37449,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;
@@ -37012,8 +37469,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;
@@ -37088,6 +37601,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;
@@ -37189,8 +37708,8 @@ export type ShopifyMarketsOrderDeleted =
   io.flow.internal.v0.models.ShopifyMarketsOrderDeleted;
 export type ShopifyMarketsOrderUpserted =
   io.flow.internal.v0.models.ShopifyMarketsOrderUpserted;
-export type ShopifyMarketsOrderVersion =
-  io.flow.internal.v0.models.ShopifyMarketsOrderVersion;
+export type ShopifyMarketsOrderVersionWithShopId =
+  io.flow.internal.v0.models.ShopifyMarketsOrderVersionWithShopId;
 export type ShopifyMarketsOrdersMetrics =
   io.flow.internal.v0.models.ShopifyMarketsOrdersMetrics;
 export type ShopifyMarketsQueuedRecord =
@@ -37338,6 +37857,9 @@ export type ShopperFreight = io.flow.internal.v0.models.ShopperFreight;
 export type ShopperLine = io.flow.internal.v0.models.ShopperLine;
 export type ShopperLines = io.flow.internal.v0.models.ShopperLines;
 export type ShopperSummary = io.flow.internal.v0.models.ShopperSummary;
+export type ShrutiDemoItem = io.flow.internal.v0.models.ShrutiDemoItem;
+export type ShrutiDemoItemForm = io.flow.internal.v0.models.ShrutiDemoItemForm;
+export type ShrutiDemoType = io.flow.internal.v0.enums.ShrutiDemoType;
 export type SignificanceAction = io.flow.internal.v0.enums.SignificanceAction;
 export type SimpleAccountReference =
   io.flow.internal.v0.models.SimpleAccountReference;
@@ -37450,6 +37972,9 @@ export type SvbVirtualCardClearingDeleted =
   io.flow.internal.v0.models.SvbVirtualCardClearingDeleted;
 export type SvbVirtualCardClearingUpserted =
   io.flow.internal.v0.models.SvbVirtualCardClearingUpserted;
+export type SvitlanaItem = io.flow.internal.v0.models.SvitlanaItem;
+export type SvitlanaItemForm = io.flow.internal.v0.models.SvitlanaItemForm;
+export type SvitlanaType = io.flow.internal.v0.enums.SvitlanaType;
 export type TariffCodeDuty = io.flow.internal.v0.models.TariffCodeDuty;
 export type TariffCodesExport = io.flow.internal.v0.models.TariffCodesExport;
 export type TariffEligibility = io.flow.internal.v0.models.TariffEligibility;