stripe 22.6.1 → 22.7.0-alpha.2

package/esm/resources/V2/Billing/Contracts.d.ts

@@ -0,0 +1,1776 @@
+import { StripeResource } from '../../../StripeResource.js';
+import { V2Amount } from './../V2Amounts.js';
+import { MetadataParam, OtherString, Decimal, Metadata } from '../../../shared.js';
+import { RequestOptions, V2ListPromise, Response } from '../../../lib.js';
+import { DeletedObject } from './../../V2/DeletedObject.js';
+import { PricingLineResource } from './Contracts/PricingLines.js';
+import { Stripe } from '../../../stripe.core.js';
+export declare class ContractResource extends StripeResource {
+    private readonly stripe;
+    pricingLines: PricingLineResource;
+    constructor(stripe: Stripe);
+    /**
+     * List contracts.
+     */
+    list(params?: V2.Billing.ContractListParams, options?: RequestOptions): V2ListPromise<Contract>;
+    /**
+     * Create a draft contract.
+     * @throws Stripe.AlreadyExistsError
+     */
+    create(params: V2.Billing.ContractCreateParams, options?: RequestOptions): Promise<Response<Contract>>;
+    /**
+     * Delete a draft contract.
+     */
+    del(id: string, params?: V2.Billing.ContractDeleteParams, options?: RequestOptions): Promise<Response<DeletedObject>>;
+    /**
+     * Retrieve a contract.
+     */
+    retrieve(id: string, params?: V2.Billing.ContractRetrieveParams, options?: RequestOptions): Promise<Response<Contract>>;
+    /**
+     * Update a draft or active contract.
+     * @throws Stripe.AlreadyExistsError
+     * @throws Stripe.CannotProceedError
+     */
+    update(id: string, params?: V2.Billing.ContractUpdateParams, options?: RequestOptions): Promise<Response<Contract>>;
+    /**
+     * Activate a draft contract.
+     */
+    activate(id: string, params?: V2.Billing.ContractActivateParams, options?: RequestOptions): Promise<Response<Contract>>;
+    /**
+     * Cancel an active contract.
+     */
+    cancel(id: string, params?: V2.Billing.ContractCancelParams, options?: RequestOptions): Promise<Response<Contract>>;
+}
+export interface Contract {
+    /**
+     * The contract id.
+     */
+    id: string;
+    /**
+     * String representing the object's type. Objects of the same type share the same value of the object field.
+     */
+    object: 'v2.billing.contract';
+    /**
+     * The billing cycle anchor.
+     */
+    billing_cycle_anchor?: Contract.BillingCycleAnchor;
+    /**
+     * The billing settings.
+     */
+    billing_settings?: Contract.BillingSettings;
+    /**
+     * A unique user-provided contract number e.g. C-2026-0001.
+     */
+    contract_number: string;
+    /**
+     * Timestamp of when the contract was created.
+     */
+    created: string;
+    /**
+     * The currency.
+     */
+    currency: string;
+    /**
+     * The customer id.
+     */
+    customer: string;
+    /**
+     * Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+     */
+    livemode: boolean;
+    /**
+     * Set of key-value pairs.
+     */
+    metadata?: Metadata;
+    /**
+     * The one-time fees. Only populated when `one_time_fees` is passed in the `include` parameter.
+     */
+    one_time_fees?: Contract.OneTimeFees;
+    /**
+     * The pricing lines. Only populated when `pricing_lines` is passed in the `include` parameter.
+     */
+    pricing_lines?: Contract.PricingLines;
+    /**
+     * The pricing overrides. Only populated when `pricing_overrides` is passed in the `include` parameter.
+     */
+    pricing_overrides?: Contract.PricingOverrides;
+    /**
+     * The current status of the contract.
+     */
+    status: Contract.Status;
+    /**
+     * Historical timestamps of when the contract transitioned into each status.
+     */
+    status_transitions?: Contract.StatusTransitions;
+}
+export declare namespace Contract {
+    interface BillingCycleAnchor {
+        /**
+         * The billing cycle anchor as a UTC timestamp.
+         */
+        timestamp: string;
+    }
+    interface BillingSettings {
+        /**
+         * The bill settings details configures invoice and tax settings for the contract.
+         */
+        bill_settings_details?: BillingSettings.BillSettingsDetails;
+        /**
+         * The billing profile details configures who is charged for the contract.
+         */
+        billing_profile_details: BillingSettings.BillingProfileDetails;
+        /**
+         * The collection settings details configures how payments are collected on the contract.
+         */
+        collection_settings_details: BillingSettings.CollectionSettingsDetails;
+    }
+    interface OneTimeFees {
+        /**
+         * The one-time fees for this page.
+         */
+        data: Array<OneTimeFees.Data>;
+    }
+    interface PricingLines {
+        /**
+         * The pricing lines for this page.
+         */
+        data: Array<PricingLines.Data>;
+    }
+    interface PricingOverrides {
+        /**
+         * The pricing overrides for this page.
+         */
+        data: Array<PricingOverrides.Data>;
+    }
+    type Status = 'active' | 'canceled' | 'draft' | 'ended' | OtherString;
+    interface StatusTransitions {
+        /**
+         * The timestamp when the contract was activated.
+         */
+        activated_at?: string;
+        /**
+         * The timestamp when the contract was canceled.
+         */
+        canceled_at?: string;
+        /**
+         * The timestamp when the contract ended.
+         */
+        ended_at?: string;
+    }
+    namespace BillingSettings {
+        interface BillSettingsDetails {
+            /**
+             * Calculation settings.
+             */
+            calculation?: BillSettingsDetails.Calculation;
+            /**
+             * Invoice settings.
+             */
+            invoice?: BillSettingsDetails.Invoice;
+        }
+        interface BillingProfileDetails {
+            /**
+             * The customer who pays for the contract invoice.
+             */
+            customer: string;
+            /**
+             * The default payment method for the contract.
+             */
+            default_payment_method?: string;
+        }
+        interface CollectionSettingsDetails {
+            /**
+             * The collection method.
+             */
+            collection_method: CollectionSettingsDetails.CollectionMethod;
+            /**
+             * The payment method configuration.
+             */
+            payment_method_configuration?: string;
+        }
+        namespace BillSettingsDetails {
+            interface Calculation {
+                /**
+                 * Tax calculation settings.
+                 */
+                tax?: Calculation.Tax;
+            }
+            interface Invoice {
+                /**
+                 * The number of time units before the invoice is past due.
+                 */
+                time_until_due?: Invoice.TimeUntilDue;
+            }
+            namespace Calculation {
+                interface Tax {
+                    /**
+                     * The type of tax calculation.
+                     */
+                    type: Tax.Type;
+                }
+                namespace Tax {
+                    type Type = 'automatic' | 'manual';
+                }
+            }
+            namespace Invoice {
+                interface TimeUntilDue {
+                    /**
+                     * The interval unit.
+                     */
+                    interval: TimeUntilDue.Interval;
+                    /**
+                     * The number of intervals.
+                     */
+                    interval_count: number;
+                }
+                namespace TimeUntilDue {
+                    type Interval = 'day' | 'month' | 'week' | 'year';
+                }
+            }
+        }
+        namespace CollectionSettingsDetails {
+            type CollectionMethod = 'charge_automatically' | 'send_invoice';
+        }
+    }
+    namespace OneTimeFees {
+        interface Data {
+            /**
+             * The amount billed for this fee.
+             */
+            amount: V2Amount;
+            /**
+             * When this fee will be billed. Always contains a concrete timestamp.
+             */
+            bill_at: Data.BillAt;
+            /**
+             * The id of the one-time fee.
+             */
+            id: string;
+            /**
+             * The user-provided lookup key.
+             */
+            lookup_key?: string;
+            /**
+             * The id of the product for this fee.
+             */
+            product: string;
+        }
+        namespace Data {
+            interface BillAt {
+                /**
+                 * The timestamp at which the fee will be billed.
+                 */
+                timestamp: string;
+            }
+        }
+    }
+    namespace PricingLines {
+        interface Data {
+            /**
+             * Timestamp when the pricing line ends.
+             */
+            ends_at: Data.EndsAt;
+            /**
+             * The id of the pricing line.
+             */
+            id: string;
+            /**
+             * The user-provided lookup key for the pricing line.
+             */
+            lookup_key?: string;
+            /**
+             * Set of key-value pairs.
+             */
+            metadata?: Metadata;
+            /**
+             * The pricing configuration for the pricing line.
+             */
+            pricing: Data.Pricing;
+            /**
+             * Timestamp when the pricing line starts.
+             */
+            starts_at: Data.StartsAt;
+        }
+        namespace Data {
+            interface EndsAt {
+                /**
+                 * The timestamp when the item ends.
+                 */
+                timestamp: string;
+            }
+            interface Pricing {
+                /**
+                 * V1 price details. Present when `type` is `price`.
+                 */
+                price_details?: Pricing.PriceDetails;
+                /**
+                 * The type of pricing.
+                 */
+                type: Pricing.Type;
+            }
+            interface StartsAt {
+                /**
+                 * The timestamp when the item starts.
+                 */
+                timestamp: string;
+            }
+            namespace Pricing {
+                interface PriceDetails {
+                    /**
+                     * The current quantity on this pricing line.
+                     */
+                    current_quantity: Decimal;
+                    /**
+                     * The ID of the V1 price.
+                     */
+                    price: string;
+                    /**
+                     * The overwrite_price overrides embedded directly on this pricing line.
+                     */
+                    pricing_overrides?: PriceDetails.PricingOverrides;
+                }
+                type Type = 'price' | OtherString;
+                namespace PriceDetails {
+                    interface PricingOverrides {
+                        /**
+                         * The pricing line overrides.
+                         */
+                        data: Array<PricingOverrides.Data>;
+                    }
+                    namespace PricingOverrides {
+                        interface Data {
+                            /**
+                             * Timestamp when this override ends.
+                             */
+                            ends_at: Data.EndsAt;
+                            /**
+                             * The ID of the pricing override.
+                             */
+                            id: string;
+                            /**
+                             * The user-provided lookup key for this override.
+                             */
+                            lookup_key?: string;
+                            /**
+                             * Set of key-value pairs.
+                             */
+                            metadata?: Metadata;
+                            /**
+                             * Details for an overwrite_price override.
+                             */
+                            overwrite_price?: Data.OverwritePrice;
+                            /**
+                             * The priority of this override relative to others. Lower number = higher priority.
+                             */
+                            priority: number;
+                            /**
+                             * Timestamp when this override starts.
+                             */
+                            starts_at: Data.StartsAt;
+                            /**
+                             * The type of override.
+                             */
+                            type: Data.Type;
+                        }
+                        namespace Data {
+                            interface EndsAt {
+                                /**
+                                 * The timestamp when the item ends.
+                                 */
+                                timestamp: string;
+                            }
+                            interface OverwritePrice {
+                                /**
+                                 * The per-unit amount to be charged, represented as a decimal string in minor currency units.
+                                 */
+                                unit_amount?: string;
+                            }
+                            interface StartsAt {
+                                /**
+                                 * The timestamp when the item starts.
+                                 */
+                                timestamp: string;
+                            }
+                            type Type = 'overwrite_price' | OtherString;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    namespace PricingOverrides {
+        interface Data {
+            /**
+             * Resolved timestamp when the pricing override ends.
+             */
+            ends_at: Data.EndsAt;
+            /**
+             * The ID of the pricing override.
+             */
+            id: string;
+            /**
+             * The user-provided lookup key for the pricing override.
+             */
+            lookup_key?: string;
+            /**
+             * Set of key-value pairs.
+             */
+            metadata?: Metadata;
+            /**
+             * Details for a multiply_pricing override.
+             */
+            multiply_pricing?: Data.MultiplyPricing;
+            /**
+             * The priority of this override relative to others. Lower number = higher priority.
+             */
+            priority: number;
+            /**
+             * Resolved timestamp when the pricing override starts.
+             */
+            starts_at: Data.StartsAt;
+            /**
+             * The type of pricing override.
+             */
+            type: Data.Type;
+        }
+        namespace Data {
+            interface EndsAt {
+                /**
+                 * The timestamp when the item ends.
+                 */
+                timestamp: string;
+            }
+            interface MultiplyPricing {
+                /**
+                 * Criteria determining which rates the multiply_pricing override applies to.
+                 */
+                criteria: Array<MultiplyPricing.Criterion>;
+                /**
+                 * The multiply_pricing factor, represented as a decimal string. e.g. "0.8" for a 20% reduction.
+                 */
+                factor: string;
+            }
+            interface StartsAt {
+                /**
+                 * The timestamp when the item starts.
+                 */
+                timestamp: string;
+            }
+            type Type = 'multiply_pricing' | OtherString;
+            namespace MultiplyPricing {
+                interface Criterion {
+                    /**
+                     * Filter by pricing line IDs.
+                     */
+                    pricing_line_ids?: Array<string>;
+                    /**
+                     * Filter by pricing line lookup keys.
+                     */
+                    pricing_line_lookup_keys?: Array<string>;
+                    /**
+                     * Whether to include or exclude items matching these criteria.
+                     */
+                    type: Criterion.Type;
+                }
+                namespace Criterion {
+                    type Type = 'exclude' | 'include' | OtherString;
+                }
+            }
+        }
+    }
+}
+export declare namespace V2 {
+    namespace Billing {
+        interface ContractCreateParams {
+            /**
+             * A unique user-provided contract number e.g. C-2026-0001.
+             * Maximum length of 200 characters.
+             */
+            contract_number: string;
+            /**
+             * Currency of the contract.
+             */
+            currency: string;
+            /**
+             * The billing cycle anchor for the contract. If not provided, defaults to the pricing line start time.
+             * It is only at the top-level of the contract with no option to override at the pricing line level.
+             */
+            billing_cycle_anchor?: ContractCreateParams.BillingCycleAnchor;
+            /**
+             * The billing settings for the contract.
+             */
+            billing_settings?: ContractCreateParams.BillingSettings;
+            /**
+             * Additional fields to include in the response.
+             */
+            include?: Array<ContractCreateParams.Include>;
+            /**
+             * Set of key-value pairs that you can attach to an object.
+             */
+            metadata?: MetadataParam;
+            /**
+             * A list of one-time fees to create with the contract. Each fee is billed as individual invoice items per its bill_schedule.
+             */
+            one_time_fees?: Array<ContractCreateParams.OneTimeFee>;
+            /**
+             * A list of pricing lines to create with the contract.
+             */
+            pricing_lines?: Array<ContractCreateParams.PricingLine>;
+            /**
+             * A list of pricing overrides to create with the contract.
+             */
+            pricing_overrides?: Array<ContractCreateParams.PricingOverride>;
+        }
+        namespace ContractCreateParams {
+            interface BillingCycleAnchor {
+                /**
+                 * Configuration for determining the billing cycle anchor by calendar fields.
+                 */
+                config?: BillingCycleAnchor.Config;
+                /**
+                 * A specific timestamp to use as the billing cycle anchor.
+                 */
+                timestamp?: string;
+                /**
+                 * The type of billing cycle anchor.
+                 */
+                type: BillingCycleAnchor.Type;
+            }
+            interface BillingSettings {
+                /**
+                 * The bill settings details configures invoice and tax settings for the contract.
+                 */
+                bill_settings_details?: BillingSettings.BillSettingsDetails;
+                /**
+                 * The billing profile details configures who is charged for the contract.
+                 */
+                billing_profile_details: BillingSettings.BillingProfileDetails;
+                /**
+                 * The collection settings details configures how payments are collected on the contract.
+                 */
+                collection_settings_details: BillingSettings.CollectionSettingsDetails;
+            }
+            type Include = 'billing_settings' | 'one_time_fees' | 'pricing_lines' | 'pricing_overrides' | OtherString;
+            interface OneTimeFee {
+                /**
+                 * The amount to bill.
+                 */
+                amount: V2Amount;
+                /**
+                 * When this fee should be billed.
+                 */
+                bill_at: OneTimeFee.BillAt;
+                /**
+                 * A user-provided lookup key.
+                 */
+                lookup_key?: string;
+                /**
+                 * The id of the product for this fee.
+                 */
+                product: string;
+            }
+            interface PricingLine {
+                /**
+                 * When the pricing line ends.
+                 */
+                ends_at: PricingLine.EndsAt;
+                /**
+                 * A user-provided lookup key to reference this pricing line.
+                 */
+                lookup_key?: string;
+                /**
+                 * Set of key-value pairs that you can attach to an object.
+                 */
+                metadata?: MetadataParam;
+                /**
+                 * The pricing configuration for the pricing line.
+                 */
+                pricing: PricingLine.Pricing;
+                /**
+                 * When the pricing line starts.
+                 */
+                starts_at: PricingLine.StartsAt;
+            }
+            interface PricingOverride {
+                /**
+                 * When the pricing override ends.
+                 */
+                ends_at: PricingOverride.EndsAt;
+                /**
+                 * A user-provided lookup key to reference this pricing override.
+                 */
+                lookup_key?: string;
+                /**
+                 * Set of key-value pairs.
+                 */
+                metadata?: MetadataParam;
+                /**
+                 * Parameters for a multiply_pricing override. Required if `type` is `multiply_pricing`.
+                 */
+                multiply_pricing?: PricingOverride.MultiplyPricing;
+                /**
+                 * The priority of this override relative to others. The highest priority is 0 and the lowest is 100.
+                 */
+                priority?: number;
+                /**
+                 * When the pricing override starts.
+                 */
+                starts_at: PricingOverride.StartsAt;
+                /**
+                 * The type of pricing override.
+                 */
+                type: PricingOverride.Type;
+            }
+            namespace BillingCycleAnchor {
+                interface Config {
+                    /**
+                     * Day of month (1-31).
+                     */
+                    day_of_month: number;
+                    /**
+                     * Hour of day in UTC (0-23).
+                     */
+                    hour?: number;
+                    /**
+                     * Minute of hour (0-59).
+                     */
+                    minute?: number;
+                    /**
+                     * Month of year (1-12).
+                     */
+                    month_of_year?: number;
+                    /**
+                     * Second of minute (0-59).
+                     */
+                    second?: number;
+                }
+                type Type = 'config' | 'timestamp';
+            }
+            namespace BillingSettings {
+                interface BillSettingsDetails {
+                    /**
+                     * Calculation settings.
+                     */
+                    calculation?: BillSettingsDetails.Calculation;
+                    /**
+                     * Invoice settings.
+                     */
+                    invoice?: BillSettingsDetails.Invoice;
+                }
+                interface BillingProfileDetails {
+                    /**
+                     * The customer who pays for the contract invoice.
+                     */
+                    customer: string;
+                    /**
+                     * The default payment method for the contract.
+                     */
+                    default_payment_method?: string;
+                }
+                interface CollectionSettingsDetails {
+                    /**
+                     * How payment is collected for the contract.
+                     */
+                    collection_method: CollectionSettingsDetails.CollectionMethod;
+                    /**
+                     * The payment method configuration.
+                     */
+                    payment_method_configuration?: string;
+                }
+                namespace BillSettingsDetails {
+                    interface Calculation {
+                        /**
+                         * Tax calculation settings.
+                         */
+                        tax?: Calculation.Tax;
+                    }
+                    interface Invoice {
+                        /**
+                         * How long the customer has to pay the invoice before it's past due.
+                         */
+                        time_until_due?: Invoice.TimeUntilDue;
+                    }
+                    namespace Calculation {
+                        interface Tax {
+                            /**
+                             * The type of tax calculation.
+                             */
+                            type: Tax.Type;
+                        }
+                        namespace Tax {
+                            type Type = 'automatic' | 'manual';
+                        }
+                    }
+                    namespace Invoice {
+                        interface TimeUntilDue {
+                            /**
+                             * The interval unit.
+                             */
+                            interval: TimeUntilDue.Interval;
+                            /**
+                             * The number of intervals.
+                             */
+                            interval_count: number;
+                        }
+                        namespace TimeUntilDue {
+                            type Interval = 'day' | 'month' | 'week' | 'year';
+                        }
+                    }
+                }
+                namespace CollectionSettingsDetails {
+                    type CollectionMethod = 'charge_automatically' | 'send_invoice';
+                }
+            }
+            namespace OneTimeFee {
+                interface BillAt {
+                    /**
+                     * The timestamp at which the entry should be billed. Required if `type` is `timestamp`.
+                     */
+                    timestamp?: string;
+                    /**
+                     * The type of the bill_at.
+                     */
+                    type: BillAt.Type;
+                }
+                namespace BillAt {
+                    type Type = 'now' | 'timestamp' | OtherString;
+                }
+            }
+            namespace PricingLine {
+                interface EndsAt {
+                    /**
+                     * The timestamp when the item ends. Required if `type` is `timestamp`.
+                     */
+                    timestamp?: string;
+                    /**
+                     * The type of the ends_at.
+                     */
+                    type: EndsAt.Type;
+                }
+                interface Pricing {
+                    /**
+                     * V1 price details. Required if `type` is `price`.
+                     */
+                    price_details?: Pricing.PriceDetails;
+                    /**
+                     * The type of pricing.
+                     */
+                    type: Pricing.Type;
+                }
+                interface StartsAt {
+                    /**
+                     * The timestamp when the item starts. Required if `type` is `timestamp`.
+                     */
+                    timestamp?: string;
+                    /**
+                     * The type of the starts_at.
+                     */
+                    type: StartsAt.Type;
+                }
+                namespace EndsAt {
+                    type Type = 'timestamp' | OtherString;
+                }
+                namespace Pricing {
+                    interface PriceDetails {
+                        /**
+                         * The id of the price.
+                         */
+                        price: string;
+                        /**
+                         * Pricing overrides embedded directly on this pricing line.
+                         */
+                        pricing_overrides?: Array<PriceDetails.PricingOverride>;
+                        /**
+                         * Quantity changes for the pricing line. For now, at most one entry is allowed.
+                         * A quantity change clears all future quantity changes on this pricing line. Defaults to 1.
+                         */
+                        quantity_changes?: Array<PriceDetails.QuantityChange>;
+                    }
+                    type Type = 'price' | OtherString;
+                    namespace PriceDetails {
+                        interface PricingOverride {
+                            /**
+                             * When the override ends. Defaults to the pricing line's end if not specified.
+                             */
+                            ends_at?: PricingOverride.EndsAt;
+                            /**
+                             * A user-provided lookup key to reference this override.
+                             */
+                            lookup_key?: string;
+                            /**
+                             * Set of key-value pairs that you can attach to an object.
+                             */
+                            metadata?: MetadataParam;
+                            /**
+                             * Parameters for the overwrite_price override. Required if `type` is `overwrite_price`.
+                             */
+                            overwrite_price?: PricingOverride.OverwritePrice;
+                            /**
+                             * The priority of this override relative to others. 0 is highest, 100 is lowest. Defaults to 50.
+                             */
+                            priority?: number;
+                            /**
+                             * When the override starts. Defaults to the pricing line's start if not specified.
+                             */
+                            starts_at?: PricingOverride.StartsAt;
+                            /**
+                             * The type of override.
+                             */
+                            type: PricingOverride.Type;
+                        }
+                        interface QuantityChange {
+                            /**
+                             * When this quantity change takes effect.
+                             */
+                            effective_at: QuantityChange.EffectiveAt;
+                            /**
+                             * The quantity to set.
+                             */
+                            set: Decimal;
+                        }
+                        namespace PricingOverride {
+                            interface EndsAt {
+                                /**
+                                 * The timestamp when the item ends. Required if `type` is `timestamp`.
+                                 */
+                                timestamp?: string;
+                                /**
+                                 * The type of the ends_at.
+                                 */
+                                type: EndsAt.Type;
+                            }
+                            interface OverwritePrice {
+                                /**
+                                 * The per-unit amount to be charged, represented as a decimal string in minor currency units.
+                                 */
+                                unit_amount?: string;
+                            }
+                            interface StartsAt {
+                                /**
+                                 * The timestamp when the item starts. Required if `type` is `timestamp`.
+                                 */
+                                timestamp?: string;
+                                /**
+                                 * The type of the starts_at.
+                                 */
+                                type: StartsAt.Type;
+                            }
+                            type Type = 'overwrite_price' | OtherString;
+                            namespace EndsAt {
+                                type Type = 'timestamp' | OtherString;
+                            }
+                            namespace StartsAt {
+                                type Type = 'timestamp' | OtherString;
+                            }
+                        }
+                        namespace QuantityChange {
+                            interface EffectiveAt {
+                                /**
+                                 * The timestamp for the effective at.
+                                 */
+                                timestamp?: string;
+                                /**
+                                 * The type of the effective at.
+                                 */
+                                type: EffectiveAt.Type;
+                            }
+                            namespace EffectiveAt {
+                                type Type = 'timestamp' | OtherString;
+                            }
+                        }
+                    }
+                }
+                namespace StartsAt {
+                    type Type = 'timestamp' | OtherString;
+                }
+            }
+            namespace PricingOverride {
+                interface EndsAt {
+                    /**
+                     * The timestamp when the item ends. Required if `type` is `timestamp`.
+                     */
+                    timestamp?: string;
+                    /**
+                     * The type of the ends_at.
+                     */
+                    type: EndsAt.Type;
+                }
+                interface MultiplyPricing {
+                    /**
+                     * Criteria determining which rates the multiply_pricing override applies to.
+                     */
+                    criteria?: Array<MultiplyPricing.Criterion>;
+                    /**
+                     * The multiply_pricing factor, represented as a decimal string. e.g. "0.8" for a 20% reduction.
+                     */
+                    factor: string;
+                }
+                interface StartsAt {
+                    /**
+                     * The timestamp when the item starts. Required if `type` is `timestamp`.
+                     */
+                    timestamp?: string;
+                    /**
+                     * The type of the starts_at.
+                     */
+                    type: StartsAt.Type;
+                }
+                type Type = 'multiply_pricing' | OtherString;
+                namespace EndsAt {
+                    type Type = 'timestamp' | OtherString;
+                }
+                namespace MultiplyPricing {
+                    interface Criterion {
+                        /**
+                         * Filter by pricing line IDs.
+                         */
+                        pricing_line_ids?: Array<string>;
+                        /**
+                         * Filter by pricing line lookup keys.
+                         */
+                        pricing_line_lookup_keys?: Array<string>;
+                        /**
+                         * Whether to include or exclude items matching these criteria.
+                         */
+                        type: Criterion.Type;
+                    }
+                    namespace Criterion {
+                        type Type = 'exclude' | 'include' | OtherString;
+                    }
+                }
+                namespace StartsAt {
+                    type Type = 'timestamp' | OtherString;
+                }
+            }
+        }
+    }
+}
+export declare namespace V2 {
+    namespace Billing {
+        interface ContractRetrieveParams {
+            /**
+             * Additional fields to include in the response.
+             */
+            include?: Array<ContractRetrieveParams.Include>;
+        }
+        namespace ContractRetrieveParams {
+            type Include = 'billing_settings' | 'one_time_fees' | 'pricing_lines' | 'pricing_overrides' | OtherString;
+        }
+    }
+}
+export declare namespace V2 {
+    namespace Billing {
+        interface ContractUpdateParams {
+            /**
+             * Additional fields to include in the response.
+             */
+            include?: Array<ContractUpdateParams.Include>;
+            /**
+             * Set of key-value pairs.
+             */
+            metadata?: MetadataParam;
+            /**
+             * One-time fee actions to apply.
+             */
+            one_time_fee_actions?: Array<ContractUpdateParams.OneTimeFeeAction>;
+            /**
+             * Pricing line actions to apply.
+             */
+            pricing_line_actions?: Array<ContractUpdateParams.PricingLineAction>;
+            /**
+             * Pricing override actions to apply.
+             */
+            pricing_override_actions?: Array<ContractUpdateParams.PricingOverrideAction>;
+        }
+        namespace ContractUpdateParams {
+            type Include = 'billing_settings' | 'one_time_fees' | 'pricing_lines' | 'pricing_overrides' | OtherString;
+            interface OneTimeFeeAction {
+                /**
+                 * Parameters for adding a one-time fee.
+                 */
+                add?: OneTimeFeeAction.Add;
+                /**
+                 * Parameters for removing a one-time fee.
+                 */
+                remove?: OneTimeFeeAction.Remove;
+                /**
+                 * The type of one-time fee action.
+                 */
+                type: OneTimeFeeAction.Type;
+                /**
+                 * Parameters for updating a one-time fee.
+                 */
+                update?: OneTimeFeeAction.Update;
+            }
+            interface PricingLineAction {
+                /**
+                 * Add a pricing line.
+                 */
+                add?: PricingLineAction.Add;
+                /**
+                 * Remove a pricing line.
+                 */
+                remove?: PricingLineAction.Remove;
+                /**
+                 * The type of pricing line action.
+                 */
+                type: PricingLineAction.Type;
+                /**
+                 * Update a pricing line.
+                 */
+                update?: PricingLineAction.Update;
+            }
+            interface PricingOverrideAction {
+                /**
+                 * Add a pricing override.
+                 */
+                add?: PricingOverrideAction.Add;
+                /**
+                 * Remove a pricing override.
+                 */
+                remove?: PricingOverrideAction.Remove;
+                /**
+                 * The type of pricing override action.
+                 */
+                type: PricingOverrideAction.Type;
+                /**
+                 * Update a pricing override.
+                 */
+                update?: PricingOverrideAction.Update;
+            }
+            namespace OneTimeFeeAction {
+                interface Add {
+                    /**
+                     * The amount to bill.
+                     */
+                    amount: V2Amount;
+                    /**
+                     * When this fee should be billed.
+                     */
+                    bill_at: Add.BillAt;
+                    /**
+                     * A user-provided lookup key.
+                     */
+                    lookup_key?: string;
+                    /**
+                     * The id of the product for this fee.
+                     */
+                    product: string;
+                }
+                interface Remove {
+                    /**
+                     * The id of the one-time fee to remove.
+                     */
+                    id?: string;
+                    /**
+                     * The lookup key of the one-time fee to remove.
+                     */
+                    lookup_key?: string;
+                }
+                type Type = 'add' | 'remove' | 'update';
+                interface Update {
+                    /**
+                     * The updated amount to bill.
+                     */
+                    amount?: V2Amount;
+                    /**
+                     * The updated bill_at schedule.
+                     */
+                    bill_at?: Update.BillAt;
+                    /**
+                     * The id of the one-time fee to update.
+                     */
+                    id?: string;
+                    /**
+                     * The lookup key of the one-time fee to update.
+                     */
+                    lookup_key?: string;
+                }
+                namespace Add {
+                    interface BillAt {
+                        /**
+                         * The timestamp at which the entry should be billed. Required if `type` is `timestamp`.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of the bill_at.
+                         */
+                        type: BillAt.Type;
+                    }
+                    namespace BillAt {
+                        type Type = 'now' | 'timestamp' | OtherString;
+                    }
+                }
+                namespace Update {
+                    interface BillAt {
+                        /**
+                         * The timestamp at which the entry should be billed. Required if `type` is `timestamp`.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of the bill_at.
+                         */
+                        type: BillAt.Type;
+                    }
+                    namespace BillAt {
+                        type Type = 'now' | 'timestamp' | OtherString;
+                    }
+                }
+            }
+            namespace PricingLineAction {
+                interface Add {
+                    /**
+                     * The end time for the pricing line.
+                     */
+                    ends_at: Add.EndsAt;
+                    /**
+                     * A lookup key for the pricing line.
+                     */
+                    lookup_key?: string;
+                    /**
+                     * Metadata for the pricing line.
+                     */
+                    metadata?: MetadataParam;
+                    /**
+                     * The pricing configuration for the pricing line.
+                     */
+                    pricing: Add.Pricing;
+                    /**
+                     * The start time for the pricing line.
+                     */
+                    starts_at: Add.StartsAt;
+                }
+                interface Remove {
+                    /**
+                     * The id of the pricing line to remove.
+                     */
+                    id: string;
+                }
+                type Type = 'add' | 'remove' | 'update' | OtherString;
+                interface Update {
+                    /**
+                     * Updated end time.
+                     */
+                    ends_at?: Update.EndsAt;
+                    /**
+                     * The id of the pricing line.
+                     */
+                    id: string;
+                    /**
+                     * Metadata mutations to apply to the pricing line.
+                     */
+                    metadata?: MetadataParam;
+                    /**
+                     * Updated pricing configuration.
+                     */
+                    pricing?: Update.Pricing;
+                    /**
+                     * Updated start time.
+                     */
+                    starts_at?: Update.StartsAt;
+                }
+                namespace Add {
+                    interface EndsAt {
+                        /**
+                         * The timestamp when the pricing ends.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of end time to apply.
+                         */
+                        type: EndsAt.Type;
+                    }
+                    interface Pricing {
+                        /**
+                         * V1 price details. Required if `type` is `price`.
+                         */
+                        price_details?: Pricing.PriceDetails;
+                        /**
+                         * The type of pricing.
+                         */
+                        type: Pricing.Type;
+                    }
+                    interface StartsAt {
+                        /**
+                         * The timestamp when the pricing starts.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of start time to apply.
+                         */
+                        type: StartsAt.Type;
+                    }
+                    namespace EndsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                    namespace Pricing {
+                        interface PriceDetails {
+                            /**
+                             * The id of the price.
+                             */
+                            price: string;
+                            /**
+                             * Pricing overrides embedded directly on this pricing line.
+                             */
+                            pricing_overrides?: Array<PriceDetails.PricingOverride>;
+                            /**
+                             * Quantity changes for the pricing line. For now, at most one entry is allowed.
+                             * A quantity change clears all future quantity changes on this pricing line. Defaults to 1.
+                             */
+                            quantity_changes?: Array<PriceDetails.QuantityChange>;
+                        }
+                        type Type = 'price' | OtherString;
+                        namespace PriceDetails {
+                            interface PricingOverride {
+                                /**
+                                 * When the override ends. Defaults to the pricing line's end if not specified.
+                                 */
+                                ends_at?: PricingOverride.EndsAt;
+                                /**
+                                 * A user-provided lookup key to reference this override.
+                                 */
+                                lookup_key?: string;
+                                /**
+                                 * Set of key-value pairs that you can attach to an object.
+                                 */
+                                metadata?: MetadataParam;
+                                /**
+                                 * Parameters for the overwrite_price override. Required if `type` is `overwrite_price`.
+                                 */
+                                overwrite_price?: PricingOverride.OverwritePrice;
+                                /**
+                                 * The priority of this override relative to others. 0 is highest, 100 is lowest. Defaults to 50.
+                                 */
+                                priority?: number;
+                                /**
+                                 * When the override starts. Defaults to the pricing line's start if not specified.
+                                 */
+                                starts_at?: PricingOverride.StartsAt;
+                                /**
+                                 * The type of override.
+                                 */
+                                type: PricingOverride.Type;
+                            }
+                            interface QuantityChange {
+                                /**
+                                 * When this quantity change takes effect.
+                                 */
+                                effective_at: QuantityChange.EffectiveAt;
+                                /**
+                                 * The quantity to set.
+                                 */
+                                set: Decimal;
+                            }
+                            namespace PricingOverride {
+                                interface EndsAt {
+                                    /**
+                                     * The timestamp when the item ends. Required if `type` is `timestamp`.
+                                     */
+                                    timestamp?: string;
+                                    /**
+                                     * The type of the ends_at.
+                                     */
+                                    type: EndsAt.Type;
+                                }
+                                interface OverwritePrice {
+                                    /**
+                                     * The per-unit amount to be charged, represented as a decimal string in minor currency units.
+                                     */
+                                    unit_amount?: string;
+                                }
+                                interface StartsAt {
+                                    /**
+                                     * The timestamp when the item starts. Required if `type` is `timestamp`.
+                                     */
+                                    timestamp?: string;
+                                    /**
+                                     * The type of the starts_at.
+                                     */
+                                    type: StartsAt.Type;
+                                }
+                                type Type = 'overwrite_price' | OtherString;
+                                namespace EndsAt {
+                                    type Type = 'timestamp' | OtherString;
+                                }
+                                namespace StartsAt {
+                                    type Type = 'timestamp' | OtherString;
+                                }
+                            }
+                            namespace QuantityChange {
+                                interface EffectiveAt {
+                                    /**
+                                     * The timestamp for the effective at.
+                                     */
+                                    timestamp?: string;
+                                    /**
+                                     * The type of the effective at.
+                                     */
+                                    type: EffectiveAt.Type;
+                                }
+                                namespace EffectiveAt {
+                                    type Type = 'timestamp' | OtherString;
+                                }
+                            }
+                        }
+                    }
+                    namespace StartsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                }
+                namespace Update {
+                    interface EndsAt {
+                        /**
+                         * The timestamp when the pricing ends.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of end time to apply.
+                         */
+                        type: EndsAt.Type;
+                    }
+                    interface Pricing {
+                        /**
+                         * V1 price details. Present when the pricing line type is `price`.
+                         */
+                        price_details?: Pricing.PriceDetails;
+                    }
+                    interface StartsAt {
+                        /**
+                         * The timestamp when the pricing starts.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of start time to apply.
+                         */
+                        type: StartsAt.Type;
+                    }
+                    namespace EndsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                    namespace Pricing {
+                        interface PriceDetails {
+                            /**
+                             * Pricing override actions to apply to the overrides embedded on this pricing line.
+                             */
+                            pricing_override_actions?: Array<PriceDetails.PricingOverrideAction>;
+                            /**
+                             * Quantity changes for the pricing line. Setting this clears all future quantity changes.
+                             */
+                            quantity_changes?: Array<PriceDetails.QuantityChange>;
+                        }
+                        namespace PriceDetails {
+                            interface PricingOverrideAction {
+                                /**
+                                 * Add a pricing line override.
+                                 */
+                                add?: PricingOverrideAction.Add;
+                                /**
+                                 * Remove a pricing line override.
+                                 */
+                                remove?: PricingOverrideAction.Remove;
+                                /**
+                                 * The type of pricing line override action.
+                                 */
+                                type: PricingOverrideAction.Type;
+                                /**
+                                 * Update a pricing line override.
+                                 */
+                                update?: PricingOverrideAction.Update;
+                            }
+                            interface QuantityChange {
+                                /**
+                                 * When this quantity change takes effect.
+                                 */
+                                effective_at: QuantityChange.EffectiveAt;
+                                /**
+                                 * The quantity to set.
+                                 */
+                                set: Decimal;
+                            }
+                            namespace PricingOverrideAction {
+                                interface Add {
+                                    /**
+                                     * The end time for the override.
+                                     */
+                                    ends_at: Add.EndsAt;
+                                    /**
+                                     * A lookup key for the override.
+                                     */
+                                    lookup_key?: string;
+                                    /**
+                                     * Metadata for the pricing override.
+                                     */
+                                    metadata?: MetadataParam;
+                                    /**
+                                     * Parameters for an overwrite_price override. Required if `type` is `overwrite_price`.
+                                     */
+                                    overwrite_price?: Add.OverwritePrice;
+                                    /**
+                                     * The priority of this override relative to others. 0 is highest, 100 is lowest. Defaults to 50.
+                                     */
+                                    priority?: number;
+                                    /**
+                                     * The start time for the override.
+                                     */
+                                    starts_at: Add.StartsAt;
+                                    /**
+                                     * The type of override to add.
+                                     */
+                                    type: Add.Type;
+                                }
+                                interface Remove {
+                                    /**
+                                     * The id of the pricing override to remove.
+                                     */
+                                    id?: string;
+                                    /**
+                                     * Lookup key of the override to remove.
+                                     */
+                                    lookup_key?: string;
+                                }
+                                type Type = 'add' | 'remove' | 'update' | OtherString;
+                                interface Update {
+                                    /**
+                                     * Updated end time.
+                                     */
+                                    ends_at?: Update.EndsAt;
+                                    /**
+                                     * The id of the pricing override to update.
+                                     */
+                                    id?: string;
+                                    /**
+                                     * Updated lookup key.
+                                     */
+                                    lookup_key?: string;
+                                    /**
+                                     * Metadata mutations to apply to the pricing override.
+                                     */
+                                    metadata?: MetadataParam;
+                                    /**
+                                     * Updated start time.
+                                     */
+                                    starts_at?: Update.StartsAt;
+                                }
+                                namespace Add {
+                                    interface EndsAt {
+                                        /**
+                                         * The timestamp when the pricing ends.
+                                         */
+                                        timestamp?: string;
+                                        /**
+                                         * The type of end time to apply.
+                                         */
+                                        type: EndsAt.Type;
+                                    }
+                                    interface OverwritePrice {
+                                        /**
+                                         * The per-unit amount to be charged, represented as a decimal string in minor currency units.
+                                         */
+                                        unit_amount?: string;
+                                    }
+                                    interface StartsAt {
+                                        /**
+                                         * The timestamp when the pricing starts.
+                                         */
+                                        timestamp?: string;
+                                        /**
+                                         * The type of start time to apply.
+                                         */
+                                        type: StartsAt.Type;
+                                    }
+                                    type Type = 'overwrite_price' | OtherString;
+                                    namespace EndsAt {
+                                        type Type = 'timestamp' | OtherString;
+                                    }
+                                    namespace StartsAt {
+                                        type Type = 'timestamp' | OtherString;
+                                    }
+                                }
+                                namespace Update {
+                                    interface EndsAt {
+                                        /**
+                                         * The timestamp when the pricing ends.
+                                         */
+                                        timestamp?: string;
+                                        /**
+                                         * The type of end time to apply.
+                                         */
+                                        type: EndsAt.Type;
+                                    }
+                                    interface StartsAt {
+                                        /**
+                                         * The timestamp when the pricing starts.
+                                         */
+                                        timestamp?: string;
+                                        /**
+                                         * The type of start time to apply.
+                                         */
+                                        type: StartsAt.Type;
+                                    }
+                                    namespace EndsAt {
+                                        type Type = 'timestamp' | OtherString;
+                                    }
+                                    namespace StartsAt {
+                                        type Type = 'timestamp' | OtherString;
+                                    }
+                                }
+                            }
+                            namespace QuantityChange {
+                                interface EffectiveAt {
+                                    /**
+                                     * The timestamp for the effective at.
+                                     */
+                                    timestamp?: string;
+                                    /**
+                                     * The type of the effective at.
+                                     */
+                                    type: EffectiveAt.Type;
+                                }
+                                namespace EffectiveAt {
+                                    type Type = 'timestamp' | OtherString;
+                                }
+                            }
+                        }
+                    }
+                    namespace StartsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                }
+            }
+            namespace PricingOverrideAction {
+                interface Add {
+                    /**
+                     * The end time for the pricing override.
+                     */
+                    ends_at: Add.EndsAt;
+                    /**
+                     * A lookup key for the pricing override.
+                     */
+                    lookup_key?: string;
+                    /**
+                     * Metadata for the pricing override.
+                     */
+                    metadata?: MetadataParam;
+                    /**
+                     * A multiply_pricing override to add.
+                     */
+                    multiply_pricing?: Add.MultiplyPricing;
+                    /**
+                     * An overwrite price override to add.
+                     */
+                    overwrite_price?: Add.OverwritePrice;
+                    /**
+                     * The priority for the pricing override. The highest priority is 0 and the lowest is 100.
+                     */
+                    priority?: number;
+                    /**
+                     * The start time for the pricing override.
+                     */
+                    starts_at: Add.StartsAt;
+                    /**
+                     * The type of pricing override to add.
+                     */
+                    type: Add.Type;
+                }
+                interface Remove {
+                    /**
+                     * The id of the pricing override to remove.
+                     */
+                    id: string;
+                }
+                type Type = 'add' | 'remove' | 'update' | OtherString;
+                interface Update {
+                    /**
+                     * The updated end time for the pricing override.
+                     */
+                    ends_at?: Update.EndsAt;
+                    /**
+                     * The ID of the pricing override.
+                     */
+                    id: string;
+                    /**
+                     * Metadata mutations to apply to the pricing override.
+                     */
+                    metadata?: MetadataParam;
+                    /**
+                     * The updated start time for the pricing override.
+                     */
+                    starts_at?: Update.StartsAt;
+                }
+                namespace Add {
+                    interface EndsAt {
+                        /**
+                         * The timestamp when the pricing ends.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of end time to apply.
+                         */
+                        type: EndsAt.Type;
+                    }
+                    interface MultiplyPricing {
+                        /**
+                         * Criteria determining which rates the multiply_pricing override applies to.
+                         */
+                        criteria: Array<MultiplyPricing.Criterion>;
+                        /**
+                         * The multiply_pricing factor, represented as a decimal string. e.g. "0.8" for a 20% reduction.
+                         */
+                        factor: string;
+                    }
+                    interface OverwritePrice {
+                        /**
+                         * The per-unit amount to be charged, represented as a decimal string in minor currency units.
+                         */
+                        unit_amount?: string;
+                    }
+                    interface StartsAt {
+                        /**
+                         * The timestamp when the pricing starts.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of start time to apply.
+                         */
+                        type: StartsAt.Type;
+                    }
+                    type Type = 'multiply_pricing' | OtherString;
+                    namespace EndsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                    namespace MultiplyPricing {
+                        interface Criterion {
+                            /**
+                             * Filter by pricing line IDs.
+                             */
+                            pricing_line_ids?: Array<string>;
+                            /**
+                             * Filter by pricing line lookup keys.
+                             */
+                            pricing_line_lookup_keys?: Array<string>;
+                            /**
+                             * Whether to include or exclude items matching these criteria.
+                             */
+                            type: Criterion.Type;
+                        }
+                        namespace Criterion {
+                            type Type = 'exclude' | 'include' | OtherString;
+                        }
+                    }
+                    namespace StartsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                }
+                namespace Update {
+                    interface EndsAt {
+                        /**
+                         * The timestamp when the pricing ends.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of end time to apply.
+                         */
+                        type: EndsAt.Type;
+                    }
+                    interface StartsAt {
+                        /**
+                         * The timestamp when the pricing starts.
+                         */
+                        timestamp?: string;
+                        /**
+                         * The type of start time to apply.
+                         */
+                        type: StartsAt.Type;
+                    }
+                    namespace EndsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                    namespace StartsAt {
+                        type Type = 'timestamp' | OtherString;
+                    }
+                }
+            }
+        }
+    }
+}
+export declare namespace V2 {
+    namespace Billing {
+        interface ContractListParams {
+            /**
+             * Filter by customer id.
+             */
+            customer?: string;
+            /**
+             * Additional fields to include in the response.
+             */
+            include?: Array<ContractListParams.Include>;
+            /**
+             * The limit for the number of results per page.
+             */
+            limit?: number;
+        }
+        namespace ContractListParams {
+            type Include = 'billing_settings' | 'one_time_fees' | 'pricing_lines' | 'pricing_overrides' | OtherString;
+        }
+    }
+}
+export declare namespace V2 {
+    namespace Billing {
+        interface ContractDeleteParams {
+        }
+    }
+}
+export declare namespace V2 {
+    namespace Billing {
+        interface ContractActivateParams {
+            /**
+             * Additional fields to include in the response.
+             */
+            include?: Array<ContractActivateParams.Include>;
+        }
+        namespace ContractActivateParams {
+            type Include = 'billing_settings' | 'one_time_fees' | 'pricing_lines' | 'pricing_overrides' | OtherString;
+        }
+    }
+}
+export declare namespace V2 {
+    namespace Billing {
+        interface ContractCancelParams {
+            /**
+             * Per-pricing-line proration behavior overrides. Falls back to `proration_behavior` if
+             * not specified for a given line.
+             */
+            cancel_pricing_lines?: Array<ContractCancelParams.CancelPricingLine>;
+            /**
+             * Additional fields to include in the response.
+             */
+            include?: Array<ContractCancelParams.Include>;
+            /**
+             * Top-level proration behavior for the cancellation. Defaults to `prorated` if not set.
+             */
+            proration_behavior?: ContractCancelParams.ProrationBehavior;
+        }
+        namespace ContractCancelParams {
+            interface CancelPricingLine {
+                /**
+                 * The id of the pricing line.
+                 */
+                id?: string;
+                /**
+                 * The lookup key of the pricing line.
+                 */
+                lookup_key?: string;
+                /**
+                 * Proration behavior scoped to this pricing line. If not provided, falls back to the
+                 * top-level `proration_behavior` on the cancel request. Defaults to `prorated`.
+                 */
+                proration_behavior?: CancelPricingLine.ProrationBehavior;
+            }
+            type Include = 'billing_settings' | 'one_time_fees' | 'pricing_lines' | 'pricing_overrides' | OtherString;
+            type ProrationBehavior = 'none' | 'prorated' | OtherString;
+            namespace CancelPricingLine {
+                type ProrationBehavior = 'none' | 'prorated' | OtherString;
+            }
+        }
+    }
+}