@metronome/sdk 3.6.0 → 3.8.0

package/resources/v2/contracts.d.mts

@@ -213,7 +213,1326 @@ export interface ContractListResponse {
     data: Array<Shared.ContractV2>;
 }
 export interface ContractEditResponse {
-    data: Shared.ID;
+    data: ContractEditResponse.Data;
+}
+export declare namespace ContractEditResponse {
+    interface Data {
+        id: string;
+        edit?: Data.Edit;
+    }
+    namespace Data {
+        interface Edit {
+            id: string;
+            add_commits?: Array<Edit.AddCommit>;
+            add_credits?: Array<Edit.AddCredit>;
+            add_discounts?: Array<Shared.Discount>;
+            add_overrides?: Array<Edit.AddOverride>;
+            add_prepaid_balance_threshold_configuration?: Shared.PrepaidBalanceThresholdConfigurationV2;
+            add_pro_services?: Array<Shared.ProService>;
+            add_recurring_commits?: Array<Edit.AddRecurringCommit>;
+            add_recurring_credits?: Array<Edit.AddRecurringCredit>;
+            add_reseller_royalties?: Array<Edit.AddResellerRoyalty>;
+            add_scheduled_charges?: Array<Edit.AddScheduledCharge>;
+            add_spend_threshold_configuration?: Shared.SpendThresholdConfigurationV2;
+            /**
+             * List of subscriptions on the contract.
+             */
+            add_subscriptions?: Array<Edit.AddSubscription>;
+            add_usage_filters?: Array<Edit.AddUsageFilter>;
+            archive_commits?: Array<Edit.ArchiveCommit>;
+            archive_credits?: Array<Edit.ArchiveCredit>;
+            archive_scheduled_charges?: Array<Edit.ArchiveScheduledCharge>;
+            remove_overrides?: Array<Edit.RemoveOverride>;
+            timestamp?: string;
+            /**
+             * Prevents the creation of duplicates. If a request to create a record is made
+             * with a previously used uniqueness key, a new record will not be created and the
+             * request will fail with a 409 error.
+             */
+            uniqueness_key?: string;
+            update_commits?: Array<Edit.UpdateCommit>;
+            update_contract_end_date?: string;
+            /**
+             * Value to update the contract name to. If not provided, the contract name will
+             * remain unchanged.
+             */
+            update_contract_name?: string | null;
+            update_credits?: Array<Edit.UpdateCredit>;
+            update_discounts?: Array<Edit.UpdateDiscount>;
+            update_prepaid_balance_threshold_configuration?: Edit.UpdatePrepaidBalanceThresholdConfiguration;
+            update_recurring_commits?: Array<Edit.UpdateRecurringCommit>;
+            update_recurring_credits?: Array<Edit.UpdateRecurringCredit>;
+            update_refund_invoices?: Array<Edit.UpdateRefundInvoice>;
+            update_scheduled_charges?: Array<Edit.UpdateScheduledCharge>;
+            update_spend_threshold_configuration?: Edit.UpdateSpendThresholdConfiguration;
+            /**
+             * Optional list of subscriptions to update.
+             */
+            update_subscriptions?: Array<Edit.UpdateSubscription>;
+        }
+        namespace Edit {
+            interface AddCommit {
+                id: string;
+                product: AddCommit.Product;
+                type: 'PREPAID' | 'POSTPAID';
+                /**
+                 * The schedule that the customer will gain access to the credits purposed with
+                 * this commit.
+                 */
+                access_schedule?: Shared.ScheduleDuration;
+                applicable_product_ids?: Array<string>;
+                applicable_product_tags?: Array<string>;
+                description?: string;
+                /**
+                 * Optional configuration for commit hierarchy access control
+                 */
+                hierarchy_configuration?: Shared.CommitHierarchyConfiguration;
+                /**
+                 * The schedule that the customer will be invoiced for this commit.
+                 */
+                invoice_schedule?: AddCommit.InvoiceSchedule;
+                name?: string;
+                /**
+                 * This field's availability is dependent on your client's configuration.
+                 */
+                netsuite_sales_order_id?: string;
+                /**
+                 * If multiple credits or commits are applicable, the one with the lower priority
+                 * will apply first.
+                 */
+                priority?: number;
+                rate_type?: 'COMMIT_RATE' | 'LIST_RATE';
+                rollover_fraction?: number;
+                /**
+                 * This field's availability is dependent on your client's configuration.
+                 */
+                salesforce_opportunity_id?: string;
+                /**
+                 * List of filters that determine what kind of customer usage draws down a commit
+                 * or credit. A customer's usage needs to meet the condition of at least one of the
+                 * specifiers to contribute to a commit's or credit's drawdown. This field cannot
+                 * be used together with `applicable_product_ids` or `applicable_product_tags`.
+                 * Instead, to target usage by product or product tag, pass those values in the
+                 * body of `specifiers`.
+                 */
+                specifiers?: Array<Shared.CommitSpecifierInput>;
+            }
+            namespace AddCommit {
+                interface Product {
+                    id: string;
+                    name: string;
+                }
+                /**
+                 * The schedule that the customer will be invoiced for this commit.
+                 */
+                interface InvoiceSchedule {
+                    credit_type?: Shared.CreditTypeData;
+                    /**
+                     * If true, this schedule will not generate an invoice.
+                     */
+                    do_not_invoice?: boolean;
+                    schedule_items?: Array<InvoiceSchedule.ScheduleItem>;
+                }
+                namespace InvoiceSchedule {
+                    interface ScheduleItem {
+                        id: string;
+                        timestamp: string;
+                        amount?: number;
+                        invoice_id?: string | null;
+                        quantity?: number;
+                        unit_price?: number;
+                    }
+                }
+            }
+            interface AddCredit {
+                id: string;
+                product: AddCredit.Product;
+                type: 'CREDIT';
+                /**
+                 * The schedule that the customer will gain access to the credits.
+                 */
+                access_schedule?: Shared.ScheduleDuration;
+                applicable_product_ids?: Array<string>;
+                applicable_product_tags?: Array<string>;
+                description?: string;
+                /**
+                 * Optional configuration for recurring credit hierarchy access control
+                 */
+                hierarchy_configuration?: Shared.CommitHierarchyConfiguration;
+                name?: string;
+                /**
+                 * This field's availability is dependent on your client's configuration.
+                 */
+                netsuite_sales_order_id?: string;
+                /**
+                 * If multiple credits or commits are applicable, the one with the lower priority
+                 * will apply first.
+                 */
+                priority?: number;
+                rate_type?: 'COMMIT_RATE' | 'LIST_RATE';
+                rollover_fraction?: number;
+                /**
+                 * This field's availability is dependent on your client's configuration.
+                 */
+                salesforce_opportunity_id?: string;
+                /**
+                 * List of filters that determine what kind of customer usage draws down a commit
+                 * or credit. A customer's usage needs to meet the condition of at least one of the
+                 * specifiers to contribute to a commit's or credit's drawdown. This field cannot
+                 * be used together with `applicable_product_ids` or `applicable_product_tags`.
+                 * Instead, to target usage by product or product tag, pass those values in the
+                 * body of `specifiers`.
+                 */
+                specifiers?: Array<Shared.CommitSpecifierInput>;
+            }
+            namespace AddCredit {
+                interface Product {
+                    id: string;
+                    name: string;
+                }
+            }
+            interface AddOverride {
+                id: string;
+                created_at: string;
+                starting_at: string;
+                applicable_product_tags?: Array<string>;
+                ending_before?: string;
+                entitled?: boolean;
+                is_commit_specific?: boolean;
+                multiplier?: number;
+                override_specifiers?: Array<AddOverride.OverrideSpecifier>;
+                override_tiers?: Array<Shared.OverrideTier>;
+                overwrite_rate?: AddOverride.OverwriteRate;
+                priority?: number;
+                product?: AddOverride.Product;
+                target?: 'COMMIT_RATE' | 'LIST_RATE';
+                type?: 'OVERWRITE' | 'MULTIPLIER' | 'TIERED';
+            }
+            namespace AddOverride {
+                interface OverrideSpecifier {
+                    any_commit_or_credit_ids?: Array<string>;
+                    billing_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
+                    commit_ids?: Array<string>;
+                    presentation_group_values?: {
+                        [key: string]: string | null;
+                    };
+                    pricing_group_values?: {
+                        [key: string]: string;
+                    };
+                    product_id?: string;
+                    product_tags?: Array<string>;
+                    recurring_commit_ids?: Array<string>;
+                }
+                interface OverwriteRate {
+                    rate_type: 'FLAT' | 'PERCENTAGE' | 'SUBSCRIPTION' | 'TIERED' | 'TIERED_PERCENTAGE' | 'CUSTOM';
+                    credit_type?: Shared.CreditTypeData;
+                    /**
+                     * Only set for CUSTOM rate_type. This field is interpreted by custom rate
+                     * processors.
+                     */
+                    custom_rate?: {
+                        [key: string]: unknown;
+                    };
+                    /**
+                     * Default proration configuration. Only valid for SUBSCRIPTION rate_type. Must be
+                     * set to true.
+                     */
+                    is_prorated?: boolean;
+                    /**
+                     * Default price. For FLAT rate_type, this must be >=0. For PERCENTAGE rate_type,
+                     * this is a decimal fraction, e.g. use 0.1 for 10%; this must be >=0 and <=1.
+                     */
+                    price?: number;
+                    /**
+                     * Default quantity. For SUBSCRIPTION rate_type, this must be >=0.
+                     */
+                    quantity?: number;
+                    /**
+                     * Only set for TIERED rate_type.
+                     */
+                    tiers?: Array<Shared.Tier>;
+                }
+                interface Product {
+                    id: string;
+                    name: string;
+                }
+            }
+            interface AddRecurringCommit {
+                id: string;
+                /**
+                 * The amount of commit to grant.
+                 */
+                access_amount: AddRecurringCommit.AccessAmount;
+                /**
+                 * The amount of time the created commits will be valid for
+                 */
+                commit_duration: AddRecurringCommit.CommitDuration;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                priority: number;
+                product: AddRecurringCommit.Product;
+                /**
+                 * Whether the created commits will use the commit rate or list rate
+                 */
+                rate_type: 'COMMIT_RATE' | 'LIST_RATE';
+                /**
+                 * Determines the start time for the first commit
+                 */
+                starting_at: string;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                applicable_product_ids?: Array<string>;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                applicable_product_tags?: Array<string>;
+                contract?: AddRecurringCommit.Contract;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                description?: string;
+                /**
+                 * Determines when the contract will stop creating recurring commits. Optional
+                 */
+                ending_before?: string;
+                /**
+                 * Optional configuration for recurring credit hierarchy access control
+                 */
+                hierarchy_configuration?: Shared.CommitHierarchyConfiguration;
+                /**
+                 * The amount the customer should be billed for the commit. Not required.
+                 */
+                invoice_amount?: AddRecurringCommit.InvoiceAmount;
+                /**
+                 * Displayed on invoices. Will be passed through to the individual commits
+                 */
+                name?: string;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                netsuite_sales_order_id?: string;
+                /**
+                 * Determines whether the first and last commit will be prorated. If not provided,
+                 * the default is FIRST_AND_LAST (i.e. prorate both the first and last commits).
+                 */
+                proration?: 'NONE' | 'FIRST' | 'LAST' | 'FIRST_AND_LAST';
+                /**
+                 * Rounding configuration for prorated recurring commit amounts.
+                 */
+                proration_rounding?: AddRecurringCommit.ProrationRounding | null;
+                /**
+                 * The frequency at which the recurring commits will be created. If not provided: -
+                 * The commits will be created on the usage invoice frequency. If provided: - The
+                 * period defined in the duration will correspond to this frequency. - Commits will
+                 * be created aligned with the recurring commit's starting_at rather than the usage
+                 * invoice dates.
+                 */
+                recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY' | 'DAILY';
+                /**
+                 * Will be passed down to the individual commits. This controls how much of an
+                 * individual unexpired commit will roll over upon contract transition. Must be
+                 * between 0 and 1.
+                 */
+                rollover_fraction?: number;
+                /**
+                 * List of filters that determine what kind of customer usage draws down a commit
+                 * or credit. A customer's usage needs to meet the condition of at least one of the
+                 * specifiers to contribute to a commit's or credit's drawdown.
+                 */
+                specifiers?: Array<Shared.CommitSpecifier>;
+                /**
+                 * Attach a subscription to the recurring commit/credit.
+                 */
+                subscription_config?: Shared.RecurringCommitSubscriptionConfig;
+            }
+            namespace AddRecurringCommit {
+                /**
+                 * The amount of commit to grant.
+                 */
+                interface AccessAmount {
+                    credit_type_id: string;
+                    unit_price: number;
+                    quantity?: number;
+                }
+                /**
+                 * The amount of time the created commits will be valid for
+                 */
+                interface CommitDuration {
+                    value: number;
+                    unit?: 'PERIODS';
+                }
+                interface Product {
+                    id: string;
+                    name: string;
+                }
+                interface Contract {
+                    id: string;
+                }
+                /**
+                 * The amount the customer should be billed for the commit. Not required.
+                 */
+                interface InvoiceAmount {
+                    credit_type_id: string;
+                    quantity: number;
+                    unit_price: number;
+                }
+                /**
+                 * Rounding configuration for prorated recurring commit amounts.
+                 */
+                interface ProrationRounding {
+                    access?: ProrationRounding.Access;
+                    invoice?: ProrationRounding.Invoice;
+                }
+                namespace ProrationRounding {
+                    interface Access {
+                        /**
+                         * Number of decimal places to round to. Applied directly to the stored monetary
+                         * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                         * nearest 100 in the stored unit).
+                         */
+                        decimal_places: number;
+                        rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                    }
+                    interface Invoice {
+                        /**
+                         * Number of decimal places to round to. Applied directly to the stored monetary
+                         * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                         * nearest 100 in the stored unit).
+                         */
+                        decimal_places: number;
+                        rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                    }
+                }
+            }
+            interface AddRecurringCredit {
+                id: string;
+                /**
+                 * The amount of commit to grant.
+                 */
+                access_amount: AddRecurringCredit.AccessAmount;
+                /**
+                 * The amount of time the created commits will be valid for
+                 */
+                commit_duration: AddRecurringCredit.CommitDuration;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                priority: number;
+                product: AddRecurringCredit.Product;
+                /**
+                 * Whether the created commits will use the commit rate or list rate
+                 */
+                rate_type: 'COMMIT_RATE' | 'LIST_RATE';
+                /**
+                 * Determines the start time for the first commit
+                 */
+                starting_at: string;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                applicable_product_ids?: Array<string>;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                applicable_product_tags?: Array<string>;
+                contract?: AddRecurringCredit.Contract;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                description?: string;
+                /**
+                 * Determines when the contract will stop creating recurring commits. Optional
+                 */
+                ending_before?: string;
+                /**
+                 * Optional configuration for recurring credit hierarchy access control
+                 */
+                hierarchy_configuration?: Shared.CommitHierarchyConfiguration;
+                /**
+                 * Displayed on invoices. Will be passed through to the individual commits
+                 */
+                name?: string;
+                /**
+                 * Will be passed down to the individual commits
+                 */
+                netsuite_sales_order_id?: string;
+                /**
+                 * Determines whether the first and last commit will be prorated. If not provided,
+                 * the default is FIRST_AND_LAST (i.e. prorate both the first and last commits).
+                 */
+                proration?: 'NONE' | 'FIRST' | 'LAST' | 'FIRST_AND_LAST';
+                /**
+                 * Rounding configuration for prorated recurring credit amounts.
+                 */
+                proration_rounding?: AddRecurringCredit.ProrationRounding | null;
+                /**
+                 * The frequency at which the recurring commits will be created. If not provided: -
+                 * The commits will be created on the usage invoice frequency. If provided: - The
+                 * period defined in the duration will correspond to this frequency. - Commits will
+                 * be created aligned with the recurring commit's starting_at rather than the usage
+                 * invoice dates.
+                 */
+                recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY' | 'DAILY';
+                /**
+                 * Will be passed down to the individual commits. This controls how much of an
+                 * individual unexpired commit will roll over upon contract transition. Must be
+                 * between 0 and 1.
+                 */
+                rollover_fraction?: number;
+                /**
+                 * List of filters that determine what kind of customer usage draws down a commit
+                 * or credit. A customer's usage needs to meet the condition of at least one of the
+                 * specifiers to contribute to a commit's or credit's drawdown.
+                 */
+                specifiers?: Array<Shared.CommitSpecifier>;
+                /**
+                 * Attach a subscription to the recurring commit/credit.
+                 */
+                subscription_config?: Shared.RecurringCommitSubscriptionConfig;
+            }
+            namespace AddRecurringCredit {
+                /**
+                 * The amount of commit to grant.
+                 */
+                interface AccessAmount {
+                    credit_type_id: string;
+                    unit_price: number;
+                    quantity?: number;
+                }
+                /**
+                 * The amount of time the created commits will be valid for
+                 */
+                interface CommitDuration {
+                    value: number;
+                    unit?: 'PERIODS';
+                }
+                interface Product {
+                    id: string;
+                    name: string;
+                }
+                interface Contract {
+                    id: string;
+                }
+                /**
+                 * Rounding configuration for prorated recurring credit amounts.
+                 */
+                interface ProrationRounding {
+                    access?: ProrationRounding.Access;
+                }
+                namespace ProrationRounding {
+                    interface Access {
+                        /**
+                         * Number of decimal places to round to. Applied directly to the stored monetary
+                         * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                         * nearest 100 in the stored unit).
+                         */
+                        decimal_places: number;
+                        rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                    }
+                }
+            }
+            interface AddResellerRoyalty {
+                reseller_type: 'AWS' | 'AWS_PRO_SERVICE' | 'GCP' | 'GCP_PRO_SERVICE';
+                applicable_product_ids?: Array<string>;
+                applicable_product_tags?: Array<string>;
+                aws_account_number?: string;
+                aws_offer_id?: string;
+                aws_payer_reference_id?: string;
+                ending_before?: string | null;
+                fraction?: number;
+                gcp_account_id?: string;
+                gcp_offer_id?: string;
+                netsuite_reseller_id?: string;
+                reseller_contract_value?: number;
+                starting_at?: string;
+            }
+            interface AddScheduledCharge {
+                id: string;
+                product: AddScheduledCharge.Product;
+                schedule: Shared.SchedulePointInTime;
+                /**
+                 * displayed on invoices
+                 */
+                name?: string;
+                /**
+                 * This field's availability is dependent on your client's configuration.
+                 */
+                netsuite_sales_order_id?: string;
+            }
+            namespace AddScheduledCharge {
+                interface Product {
+                    id: string;
+                    name: string;
+                }
+            }
+            interface AddSubscription {
+                /**
+                 * Previous, current, and next billing periods for the subscription.
+                 */
+                billing_periods: AddSubscription.BillingPeriods;
+                collection_schedule: 'ADVANCE' | 'ARREARS';
+                proration: AddSubscription.Proration;
+                /**
+                 * Determines how the subscription's quantity is controlled. Defaults to
+                 * QUANTITY_ONLY. **QUANTITY_ONLY**: The subscription quantity is specified
+                 * directly on the subscription. `initial_quantity` must be provided with this
+                 * option. Compatible with recurring commits/credits that use POOLED allocation.
+                 * **SEAT_BASED**: Use when you want to pass specific seat identifiers (e.g. add
+                 * user_123) to increment and decrement a subscription quantity, rather than
+                 * directly providing the quantity. You must use a **SEAT_BASED** subscription to
+                 * use a linked recurring credit with an allocation per seat. `seat_config` must be
+                 * provided with this option.
+                 */
+                quantity_management_mode: 'SEAT_BASED' | 'QUANTITY_ONLY';
+                /**
+                 * List of quantity schedule items for the subscription. Only includes the current
+                 * quantity and future quantity changes.
+                 */
+                quantity_schedule: Array<AddSubscription.QuantitySchedule>;
+                starting_at: string;
+                subscription_rate: AddSubscription.SubscriptionRate;
+                id?: string;
+                billing_cycle_config?: AddSubscription.BillingCycleConfig;
+                /**
+                 * Custom fields to be added eg. { "key1": "value1", "key2": "value2" }
+                 */
+                custom_fields?: {
+                    [key: string]: string;
+                };
+                description?: string;
+                ending_before?: string;
+                fiat_credit_type_id?: string;
+                name?: string;
+                seat_config?: AddSubscription.SeatConfig;
+            }
+            namespace AddSubscription {
+                /**
+                 * Previous, current, and next billing periods for the subscription.
+                 */
+                interface BillingPeriods {
+                    current?: BillingPeriods.Current;
+                    next?: BillingPeriods.Next;
+                    previous?: BillingPeriods.Previous;
+                }
+                namespace BillingPeriods {
+                    interface Current {
+                        ending_before: string;
+                        starting_at: string;
+                    }
+                    interface Next {
+                        ending_before: string;
+                        starting_at: string;
+                    }
+                    interface Previous {
+                        ending_before: string;
+                        starting_at: string;
+                    }
+                }
+                interface Proration {
+                    invoice_behavior: 'BILL_IMMEDIATELY' | 'BILL_ON_NEXT_COLLECTION_DATE';
+                    is_prorated: boolean;
+                    rounding?: Proration.Rounding;
+                }
+                namespace Proration {
+                    interface Rounding {
+                        /**
+                         * Number of decimal places to round to. Applied directly to the stored monetary
+                         * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                         * nearest 100 in the stored unit).
+                         */
+                        decimal_places: number;
+                        rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                    }
+                }
+                interface QuantitySchedule {
+                    quantity: number;
+                    starting_at: string;
+                    ending_before?: string;
+                }
+                interface SubscriptionRate {
+                    billing_frequency: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
+                    product: SubscriptionRate.Product;
+                }
+                namespace SubscriptionRate {
+                    interface Product {
+                        id: string;
+                        name: string;
+                    }
+                }
+                interface BillingCycleConfig {
+                    /**
+                     * The date this subscription's billing cycle is anchored to.
+                     */
+                    anchor_date: string;
+                    /**
+                     * Controls whether this subscription consolidates onto usage invoices or gets its
+                     * own scheduled invoice.
+                     */
+                    invoice_placement: 'ON_SCHEDULED_INVOICE' | 'ON_USAGE_INVOICE';
+                }
+                interface SeatConfig {
+                    /**
+                     * The property name, sent on usage events, that identifies the seat ID associated
+                     * with the usage event. For example, the property name might be seat_id or
+                     * user_id. The property must be set as a group key on billable metrics and a
+                     * presentation/pricing group key on contract products. This allows linked
+                     * recurring credits with an allocation per seat to be consumed by only one seat's
+                     * usage.
+                     */
+                    seat_group_key: string;
+                }
+            }
+            interface AddUsageFilter {
+                group_key: string;
+                group_values: Array<string>;
+                /**
+                 * This will match contract starting_at value if usage filter is active from the
+                 * beginning of the contract.
+                 */
+                starting_at: string;
+                /**
+                 * This will match contract ending_before value if usage filter is active until the
+                 * end of the contract. It will be undefined if the contract is open-ended.
+                 */
+                ending_before?: string;
+            }
+            interface ArchiveCommit {
+                id: string;
+            }
+            interface ArchiveCredit {
+                id: string;
+            }
+            interface ArchiveScheduledCharge {
+                id: string;
+            }
+            interface RemoveOverride {
+                id: string;
+            }
+            interface UpdateCommit {
+                id: string;
+                access_schedule?: UpdateCommit.AccessSchedule;
+                /**
+                 * Which products the commit applies to. If applicable_product_ids,
+                 * applicable_product_tags or specifiers are not provided, the commit applies to
+                 * all products.
+                 */
+                applicable_product_ids?: Array<string> | null;
+                /**
+                 * Which tags the commit applies to. If applicable_product_ids,
+                 * applicable_product_tags or specifiers are not provided, the commit applies to
+                 * all products.
+                 */
+                applicable_product_tags?: Array<string> | null;
+                description?: string;
+                /**
+                 * Optional configuration for commit hierarchy access control
+                 */
+                hierarchy_configuration?: Shared.CommitHierarchyConfiguration;
+                invoice_schedule?: UpdateCommit.InvoiceSchedule;
+                name?: string;
+                netsuite_sales_order_id?: string | null;
+                /**
+                 * If multiple commits are applicable, the one with the lower priority will apply
+                 * first.
+                 */
+                priority?: number | null;
+                product_id?: string;
+                /**
+                 * If set, the commit's rate type was updated to the specified value.
+                 */
+                rate_type?: 'COMMIT_RATE' | 'LIST_RATE';
+                rollover_fraction?: number | null;
+                /**
+                 * List of filters that determine what kind of customer usage draws down a commit
+                 * or credit. A customer's usage needs to meet the condition of at least one of the
+                 * specifiers to contribute to a commit's or credit's drawdown. This field cannot
+                 * be used together with `applicable_product_ids` or `applicable_product_tags`.
+                 * Instead, to target usage by product or product tag, pass those values in the
+                 * body of `specifiers`.
+                 */
+                specifiers?: Array<Shared.CommitSpecifierInput> | null;
+            }
+            namespace UpdateCommit {
+                interface AccessSchedule {
+                    add_schedule_items?: Array<AccessSchedule.AddScheduleItem>;
+                    remove_schedule_items?: Array<AccessSchedule.RemoveScheduleItem>;
+                    update_schedule_items?: Array<AccessSchedule.UpdateScheduleItem>;
+                }
+                namespace AccessSchedule {
+                    interface AddScheduleItem {
+                        amount: number;
+                        /**
+                         * RFC 3339 timestamp (exclusive)
+                         */
+                        ending_before: string;
+                        /**
+                         * RFC 3339 timestamp (inclusive)
+                         */
+                        starting_at: string;
+                    }
+                    interface RemoveScheduleItem {
+                        id: string;
+                    }
+                    interface UpdateScheduleItem {
+                        id: string;
+                        amount?: number;
+                        /**
+                         * RFC 3339 timestamp (exclusive)
+                         */
+                        ending_before?: string;
+                        /**
+                         * RFC 3339 timestamp (inclusive)
+                         */
+                        starting_at?: string;
+                    }
+                }
+                interface InvoiceSchedule {
+                    add_schedule_items?: Array<InvoiceSchedule.AddScheduleItem>;
+                    remove_schedule_items?: Array<InvoiceSchedule.RemoveScheduleItem>;
+                    update_schedule_items?: Array<InvoiceSchedule.UpdateScheduleItem>;
+                }
+                namespace InvoiceSchedule {
+                    interface AddScheduleItem {
+                        timestamp: string;
+                        amount?: number;
+                        quantity?: number;
+                        unit_price?: number;
+                    }
+                    interface RemoveScheduleItem {
+                        id: string;
+                    }
+                    interface UpdateScheduleItem {
+                        id: string;
+                        amount?: number;
+                        quantity?: number;
+                        timestamp?: string;
+                        unit_price?: number;
+                    }
+                }
+            }
+            interface UpdateCredit {
+                id: string;
+                access_schedule?: UpdateCredit.AccessSchedule;
+                /**
+                 * Which products the credit applies to. If applicable_product_ids,
+                 * applicable_product_tags or specifiers are not provided, the credit applies to
+                 * all products.
+                 */
+                applicable_product_ids?: Array<string> | null;
+                /**
+                 * Which tags the credit applies to. If applicable_product_ids,
+                 * applicable_product_tags or specifiers are not provided, the credit applies to
+                 * all products.
+                 */
+                applicable_product_tags?: Array<string> | null;
+                description?: string;
+                /**
+                 * Optional configuration for credit hierarchy access control
+                 */
+                hierarchy_configuration?: Shared.CommitHierarchyConfiguration;
+                name?: string;
+                netsuite_sales_order_id?: string | null;
+                /**
+                 * If multiple credits are applicable, the one with the lower priority will apply
+                 * first.
+                 */
+                priority?: number | null;
+                product_id?: string;
+                /**
+                 * If set, the credit's rate type was updated to the specified value.
+                 */
+                rate_type?: 'LIST_RATE' | 'COMMIT_RATE';
+                rollover_fraction?: number | null;
+                /**
+                 * List of filters that determine what kind of customer usage draws down a commit
+                 * or credit. A customer's usage needs to meet the condition of at least one of the
+                 * specifiers to contribute to a commit's or credit's drawdown. This field cannot
+                 * be used together with `applicable_product_ids` or `applicable_product_tags`.
+                 * Instead, to target usage by product or product tag, pass those values in the
+                 * body of `specifiers`.
+                 */
+                specifiers?: Array<Shared.CommitSpecifierInput> | null;
+            }
+            namespace UpdateCredit {
+                interface AccessSchedule {
+                    add_schedule_items?: Array<AccessSchedule.AddScheduleItem>;
+                    remove_schedule_items?: Array<AccessSchedule.RemoveScheduleItem>;
+                    update_schedule_items?: Array<AccessSchedule.UpdateScheduleItem>;
+                }
+                namespace AccessSchedule {
+                    interface AddScheduleItem {
+                        amount: number;
+                        /**
+                         * RFC 3339 timestamp (exclusive)
+                         */
+                        ending_before: string;
+                        /**
+                         * RFC 3339 timestamp (inclusive)
+                         */
+                        starting_at: string;
+                    }
+                    interface RemoveScheduleItem {
+                        id: string;
+                    }
+                    interface UpdateScheduleItem {
+                        id: string;
+                        amount?: number;
+                        /**
+                         * RFC 3339 timestamp (exclusive)
+                         */
+                        ending_before?: string;
+                        /**
+                         * RFC 3339 timestamp (inclusive)
+                         */
+                        starting_at?: string;
+                    }
+                }
+            }
+            interface UpdateDiscount {
+                id: string;
+                /**
+                 * Custom fields to be added eg. { "key1": "value1", "key2": "value2" }
+                 */
+                custom_fields?: {
+                    [key: string]: string;
+                };
+                name?: string;
+                netsuite_sales_order_id?: string;
+                /**
+                 * Must provide either schedule_items or recurring_schedule.
+                 */
+                schedule?: UpdateDiscount.Schedule;
+            }
+            namespace UpdateDiscount {
+                /**
+                 * Must provide either schedule_items or recurring_schedule.
+                 */
+                interface Schedule {
+                    /**
+                     * Defaults to USD (cents) if not passed.
+                     */
+                    credit_type_id?: string;
+                    /**
+                     * This field is only applicable to commit invoice schedules. If true, this
+                     * schedule will not generate an invoice.
+                     */
+                    do_not_invoice?: boolean;
+                    /**
+                     * Enter the unit price and quantity for the charge or instead only send the
+                     * amount. If amount is sent, the unit price is assumed to be the amount and
+                     * quantity is inferred to be 1.
+                     */
+                    recurring_schedule?: Schedule.RecurringSchedule;
+                    /**
+                     * Either provide amount or provide both unit_price and quantity.
+                     */
+                    schedule_items?: Array<Schedule.ScheduleItem>;
+                }
+                namespace Schedule {
+                    /**
+                     * Enter the unit price and quantity for the charge or instead only send the
+                     * amount. If amount is sent, the unit price is assumed to be the amount and
+                     * quantity is inferred to be 1.
+                     */
+                    interface RecurringSchedule {
+                        amount_distribution: 'DIVIDED' | 'DIVIDED_ROUNDED' | 'EACH';
+                        /**
+                         * RFC 3339 timestamp (exclusive).
+                         */
+                        ending_before: string;
+                        frequency: 'MONTHLY' | 'QUARTERLY' | 'SEMI_ANNUAL' | 'ANNUAL' | 'WEEKLY';
+                        /**
+                         * RFC 3339 timestamp (inclusive).
+                         */
+                        starting_at: string;
+                        /**
+                         * Amount for the charge. Can be provided instead of unit_price and quantity. If
+                         * amount is sent, the unit_price is assumed to be the amount and quantity is
+                         * inferred to be 1.
+                         */
+                        amount?: number;
+                        /**
+                         * Quantity for the charge. Will be multiplied by unit_price to determine the
+                         * amount and must be specified with unit_price. If specified amount cannot be
+                         * provided.
+                         */
+                        quantity?: number;
+                        /**
+                         * Unit price for the charge. Will be multiplied by quantity to determine the
+                         * amount and must be specified with quantity. If specified amount cannot be
+                         * provided.
+                         */
+                        unit_price?: number;
+                    }
+                    interface ScheduleItem {
+                        /**
+                         * timestamp of the scheduled event
+                         */
+                        timestamp: string;
+                        /**
+                         * Amount for the charge. Can be provided instead of unit_price and quantity. If
+                         * amount is sent, the unit_price is assumed to be the amount and quantity is
+                         * inferred to be 1.
+                         */
+                        amount?: number;
+                        /**
+                         * Quantity for the charge. Will be multiplied by unit_price to determine the
+                         * amount and must be specified with unit_price. If specified amount cannot be
+                         * provided.
+                         */
+                        quantity?: number;
+                        /**
+                         * Unit price for the charge. Will be multiplied by quantity to determine the
+                         * amount and must be specified with quantity. If specified amount cannot be
+                         * provided.
+                         */
+                        unit_price?: number;
+                    }
+                }
+            }
+            interface UpdatePrepaidBalanceThresholdConfiguration {
+                commit?: UpdatePrepaidBalanceThresholdConfiguration.Commit;
+                /**
+                 * If provided, the threshold, recharge-to amount, and the resulting threshold
+                 * commit amount will be in terms of this credit type instead of the fiat currency.
+                 */
+                custom_credit_type_id?: string | null;
+                discount_configuration?: UpdatePrepaidBalanceThresholdConfiguration.DiscountConfiguration | null;
+                /**
+                 * When set to false, the contract will not be evaluated against the
+                 * threshold_amount. Toggling to true will result an immediate evaluation,
+                 * regardless of prior state.
+                 */
+                is_enabled?: boolean;
+                payment_gate_config?: Shared.PaymentGateConfigV2;
+                /**
+                 * Specify the amount the balance should be recharged to.
+                 */
+                recharge_to_amount?: number;
+                /**
+                 * Specify the threshold amount for the contract. Each time the contract's balance
+                 * lowers to this amount, a threshold charge will be initiated.
+                 */
+                threshold_amount?: number;
+                /**
+                 * Determines which balances are excluded from remaining balance calculation for
+                 * threshold billing.
+                 */
+                threshold_balance_specifiers?: Array<UpdatePrepaidBalanceThresholdConfiguration.ThresholdBalanceSpecifier> | null;
+            }
+            namespace UpdatePrepaidBalanceThresholdConfiguration {
+                interface Commit extends Shared.UpdateBaseThresholdCommit {
+                    /**
+                     * Which products the threshold commit applies to. If both applicable_product_ids
+                     * and applicable_product_tags are not provided, the commit applies to all
+                     * products.
+                     */
+                    applicable_product_ids?: Array<string> | null;
+                    /**
+                     * Which tags the threshold commit applies to. If both applicable_product_ids and
+                     * applicable_product_tags are not provided, the commit applies to all products.
+                     */
+                    applicable_product_tags?: Array<string> | null;
+                    /**
+                     * List of filters that determine what kind of customer usage draws down a commit
+                     * or credit. A customer's usage needs to meet the condition of at least one of the
+                     * specifiers to contribute to a commit's or credit's drawdown. This field cannot
+                     * be used together with `applicable_product_ids` or `applicable_product_tags`.
+                     * Instead, to target usage by product or product tag, pass those values in the
+                     * body of `specifiers`.
+                     */
+                    specifiers?: Array<Shared.CommitSpecifierInput> | null;
+                }
+                interface DiscountConfiguration {
+                    /**
+                     * Update the discount cap. Set to null to remove an existing cap.
+                     */
+                    cap?: DiscountConfiguration.Cap | null;
+                    /**
+                     * The fraction of the original amount that the customer pays after applying the
+                     * discount. Set to null to remove the discount fraction. For example, 0.85 means
+                     * the customer pays 85% of the original amount (a 15% discount).
+                     */
+                    payment_fraction?: number | null;
+                }
+                namespace DiscountConfiguration {
+                    /**
+                     * Update the discount cap. Set to null to remove an existing cap.
+                     */
+                    interface Cap {
+                        /**
+                         * Accumulated spend ceiling above which the discount stops applying.
+                         */
+                        amount: number;
+                        /**
+                         * Alias of the spend tracker this cap is measured against.
+                         */
+                        spend_tracker_alias: string;
+                    }
+                }
+                interface ThresholdBalanceSpecifier {
+                    exclude: Array<ThresholdBalanceSpecifier.Exclude>;
+                }
+                namespace ThresholdBalanceSpecifier {
+                    interface Exclude {
+                        custom_field_filters: Array<Exclude.CustomFieldFilter>;
+                    }
+                    namespace Exclude {
+                        interface CustomFieldFilter {
+                            entity: 'Commit' | 'ContractCredit' | 'ContractCreditOrCommit';
+                            key: string;
+                            value: string;
+                        }
+                    }
+                }
+            }
+            interface UpdateRecurringCommit {
+                id: string;
+                access_amount?: UpdateRecurringCommit.AccessAmount;
+                ending_before?: string;
+                invoice_amount?: UpdateRecurringCommit.InvoiceAmount;
+                /**
+                 * Rounding configuration for prorated recurring commit amounts.
+                 */
+                proration_rounding?: UpdateRecurringCommit.ProrationRounding | null;
+                rate_type?: 'LIST_RATE' | 'COMMIT_RATE';
+            }
+            namespace UpdateRecurringCommit {
+                interface AccessAmount {
+                    quantity?: number;
+                    unit_price?: number;
+                }
+                interface InvoiceAmount {
+                    quantity?: number;
+                    unit_price?: number;
+                }
+                /**
+                 * Rounding configuration for prorated recurring commit amounts.
+                 */
+                interface ProrationRounding {
+                    access?: ProrationRounding.Access;
+                    invoice?: ProrationRounding.Invoice;
+                }
+                namespace ProrationRounding {
+                    interface Access {
+                        /**
+                         * Number of decimal places to round to. Applied directly to the stored monetary
+                         * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                         * nearest 100 in the stored unit).
+                         */
+                        decimal_places: number;
+                        rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                    }
+                    interface Invoice {
+                        /**
+                         * Number of decimal places to round to. Applied directly to the stored monetary
+                         * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                         * nearest 100 in the stored unit).
+                         */
+                        decimal_places: number;
+                        rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                    }
+                }
+            }
+            interface UpdateRecurringCredit {
+                id: string;
+                access_amount?: UpdateRecurringCredit.AccessAmount;
+                ending_before?: string;
+                /**
+                 * Rounding configuration for prorated recurring credit amounts.
+                 */
+                proration_rounding?: UpdateRecurringCredit.ProrationRounding | null;
+                rate_type?: 'LIST_RATE' | 'COMMIT_RATE';
+            }
+            namespace UpdateRecurringCredit {
+                interface AccessAmount {
+                    quantity?: number;
+                    unit_price?: number;
+                }
+                /**
+                 * Rounding configuration for prorated recurring credit amounts.
+                 */
+                interface ProrationRounding {
+                    access?: ProrationRounding.Access;
+                }
+                namespace ProrationRounding {
+                    interface Access {
+                        /**
+                         * Number of decimal places to round to. Applied directly to the stored monetary
+                         * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                         * nearest 100 in the stored unit).
+                         */
+                        decimal_places: number;
+                        rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                    }
+                }
+            }
+            interface UpdateRefundInvoice {
+                date: string;
+                invoice_id: string;
+            }
+            interface UpdateScheduledCharge {
+                id: string;
+                invoice_schedule?: UpdateScheduledCharge.InvoiceSchedule;
+                name?: string;
+                netsuite_sales_order_id?: string | null;
+            }
+            namespace UpdateScheduledCharge {
+                interface InvoiceSchedule {
+                    add_schedule_items?: Array<InvoiceSchedule.AddScheduleItem>;
+                    remove_schedule_items?: Array<InvoiceSchedule.RemoveScheduleItem>;
+                    update_schedule_items?: Array<InvoiceSchedule.UpdateScheduleItem>;
+                }
+                namespace InvoiceSchedule {
+                    interface AddScheduleItem {
+                        timestamp: string;
+                        amount?: number;
+                        quantity?: number;
+                        unit_price?: number;
+                    }
+                    interface RemoveScheduleItem {
+                        id: string;
+                    }
+                    interface UpdateScheduleItem {
+                        id: string;
+                        amount?: number;
+                        quantity?: number;
+                        timestamp?: string;
+                        unit_price?: number;
+                    }
+                }
+            }
+            interface UpdateSpendThresholdConfiguration {
+                commit?: Shared.UpdateBaseThresholdCommit;
+                discount_configuration?: UpdateSpendThresholdConfiguration.DiscountConfiguration | null;
+                /**
+                 * When set to false, the contract will not be evaluated against the
+                 * threshold_amount. Toggling to true will result an immediate evaluation,
+                 * regardless of prior state.
+                 */
+                is_enabled?: boolean;
+                payment_gate_config?: Shared.PaymentGateConfigV2;
+                /**
+                 * Specify the threshold amount for the contract. Each time the contract's usage
+                 * hits this amount, a threshold charge will be initiated.
+                 */
+                threshold_amount?: number;
+            }
+            namespace UpdateSpendThresholdConfiguration {
+                interface DiscountConfiguration {
+                    /**
+                     * Update the discount cap. Set to null to remove an existing cap.
+                     */
+                    cap?: DiscountConfiguration.Cap | null;
+                    /**
+                     * The fraction of the original amount that the customer pays after applying the
+                     * discount. Set to null to remove the discount fraction. For example, 0.85 means
+                     * the customer pays 85% of the original amount (a 15% discount).
+                     */
+                    payment_fraction?: number | null;
+                }
+                namespace DiscountConfiguration {
+                    /**
+                     * Update the discount cap. Set to null to remove an existing cap.
+                     */
+                    interface Cap {
+                        /**
+                         * Accumulated spend ceiling above which the discount stops applying.
+                         */
+                        amount: number;
+                        /**
+                         * Alias of the spend tracker this cap is measured against.
+                         */
+                        spend_tracker_alias: string;
+                    }
+                }
+            }
+            interface UpdateSubscription {
+                id: string;
+                ending_before?: string;
+                quantity_updates?: Array<UpdateSubscription.QuantityUpdate>;
+                /**
+                 * Manage subscription seats for subscriptions in SEAT_BASED mode.
+                 */
+                seat_updates?: UpdateSubscription.SeatUpdates;
+            }
+            namespace UpdateSubscription {
+                interface QuantityUpdate {
+                    starting_at: string;
+                    quantity?: number;
+                    quantity_delta?: number;
+                }
+                /**
+                 * Manage subscription seats for subscriptions in SEAT_BASED mode.
+                 */
+                interface SeatUpdates {
+                    /**
+                     * Adds seat IDs to the subscription. If there are unassigned seats, the new seat
+                     * IDs will fill these unassigned seats and not increase the total subscription
+                     * quantity. Otherwise, if there are more new seat IDs than unassigned seats, the
+                     * total subscription quantity will increase.
+                     */
+                    add_seat_ids?: Array<SeatUpdates.AddSeatID>;
+                    /**
+                     * Adds unassigned seats to the subscription. This will increase the total
+                     * subscription quantity.
+                     */
+                    add_unassigned_seats?: Array<SeatUpdates.AddUnassignedSeat>;
+                    /**
+                     * Removes seat IDs from the subscription, if possible. If a seat ID is removed,
+                     * the total subscription quantity will decrease. Otherwise, if the seat ID is not
+                     * found on the subscription, this is a no-op.
+                     */
+                    remove_seat_ids?: Array<SeatUpdates.RemoveSeatID>;
+                    /**
+                     * Removes unassigned seats from the subscription. This will decrease the total
+                     * subscription quantity if there are are unassigned seats.
+                     */
+                    remove_unassigned_seats?: Array<SeatUpdates.RemoveUnassignedSeat>;
+                }
+                namespace SeatUpdates {
+                    interface AddSeatID {
+                        seat_ids: Array<string>;
+                        /**
+                         * Assigned seats will be added/removed starting at this date.
+                         */
+                        starting_at: string;
+                    }
+                    interface AddUnassignedSeat {
+                        /**
+                         * The number of unassigned seats on the subscription will increase/decrease by
+                         * this delta. Must be greater than 0.
+                         */
+                        quantity: number;
+                        /**
+                         * Unassigned seats will be updated starting at this date.
+                         */
+                        starting_at: string;
+                    }
+                    interface RemoveSeatID {
+                        seat_ids: Array<string>;
+                        /**
+                         * Assigned seats will be added/removed starting at this date.
+                         */
+                        starting_at: string;
+                    }
+                    interface RemoveUnassignedSeat {
+                        /**
+                         * The number of unassigned seats on the subscription will increase/decrease by
+                         * this delta. Must be greater than 0.
+                         */
+                        quantity: number;
+                        /**
+                         * Unassigned seats will be updated starting at this date.
+                         */
+                        starting_at: string;
+                    }
+                }
+            }
+        }
+    }
 }
 export interface ContractEditCommitResponse {
     data: Shared.ID;
@@ -414,6 +1733,7 @@ export declare namespace ContractGetEditHistoryResponse {
         }
         namespace AddOverride {
             interface OverrideSpecifier {
+                any_commit_or_credit_ids?: Array<string>;
                 billing_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
                 commit_ids?: Array<string>;
                 presentation_group_values?: {
@@ -521,6 +1841,10 @@ export declare namespace ContractGetEditHistoryResponse {
              * the default is FIRST_AND_LAST (i.e. prorate both the first and last commits).
              */
             proration?: 'NONE' | 'FIRST' | 'LAST' | 'FIRST_AND_LAST';
+            /**
+             * Rounding configuration for prorated recurring commit amounts.
+             */
+            proration_rounding?: AddRecurringCommit.ProrationRounding | null;
             /**
              * The frequency at which the recurring commits will be created. If not provided: -
              * The commits will be created on the usage invoice frequency. If provided: - The
@@ -528,7 +1852,7 @@ export declare namespace ContractGetEditHistoryResponse {
              * be created aligned with the recurring commit's starting_at rather than the usage
              * invoice dates.
              */
-            recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
+            recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY' | 'DAILY';
             /**
              * Will be passed down to the individual commits. This controls how much of an
              * individual unexpired commit will roll over upon contract transition. Must be
@@ -577,6 +1901,33 @@ export declare namespace ContractGetEditHistoryResponse {
                 quantity: number;
                 unit_price: number;
             }
+            /**
+             * Rounding configuration for prorated recurring commit amounts.
+             */
+            interface ProrationRounding {
+                access?: ProrationRounding.Access;
+                invoice?: ProrationRounding.Invoice;
+            }
+            namespace ProrationRounding {
+                interface Access {
+                    /**
+                     * Number of decimal places to round to. Applied directly to the stored monetary
+                     * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                     * nearest 100 in the stored unit).
+                     */
+                    decimal_places: number;
+                    rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                }
+                interface Invoice {
+                    /**
+                     * Number of decimal places to round to. Applied directly to the stored monetary
+                     * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                     * nearest 100 in the stored unit).
+                     */
+                    decimal_places: number;
+                    rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                }
+            }
         }
         interface AddRecurringCredit {
             id: string;
@@ -635,6 +1986,10 @@ export declare namespace ContractGetEditHistoryResponse {
              * the default is FIRST_AND_LAST (i.e. prorate both the first and last commits).
              */
             proration?: 'NONE' | 'FIRST' | 'LAST' | 'FIRST_AND_LAST';
+            /**
+             * Rounding configuration for prorated recurring credit amounts.
+             */
+            proration_rounding?: AddRecurringCredit.ProrationRounding | null;
             /**
              * The frequency at which the recurring commits will be created. If not provided: -
              * The commits will be created on the usage invoice frequency. If provided: - The
@@ -642,7 +1997,7 @@ export declare namespace ContractGetEditHistoryResponse {
              * be created aligned with the recurring commit's starting_at rather than the usage
              * invoice dates.
              */
-            recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
+            recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY' | 'DAILY';
             /**
              * Will be passed down to the individual commits. This controls how much of an
              * individual unexpired commit will roll over upon contract transition. Must be
@@ -683,6 +2038,23 @@ export declare namespace ContractGetEditHistoryResponse {
             interface Contract {
                 id: string;
             }
+            /**
+             * Rounding configuration for prorated recurring credit amounts.
+             */
+            interface ProrationRounding {
+                access?: ProrationRounding.Access;
+            }
+            namespace ProrationRounding {
+                interface Access {
+                    /**
+                     * Number of decimal places to round to. Applied directly to the stored monetary
+                     * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                     * nearest 100 in the stored unit).
+                     */
+                    decimal_places: number;
+                    rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                }
+            }
         }
         interface AddResellerRoyalty {
             reseller_type: 'AWS' | 'AWS_PRO_SERVICE' | 'GCP' | 'GCP_PRO_SERVICE';
@@ -745,6 +2117,7 @@ export declare namespace ContractGetEditHistoryResponse {
             starting_at: string;
             subscription_rate: AddSubscription.SubscriptionRate;
             id?: string;
+            billing_cycle_config?: AddSubscription.BillingCycleConfig;
             /**
              * Custom fields to be added eg. { "key1": "value1", "key2": "value2" }
              */
@@ -783,6 +2156,18 @@ export declare namespace ContractGetEditHistoryResponse {
             interface Proration {
                 invoice_behavior: 'BILL_IMMEDIATELY' | 'BILL_ON_NEXT_COLLECTION_DATE';
                 is_prorated: boolean;
+                rounding?: Proration.Rounding;
+            }
+            namespace Proration {
+                interface Rounding {
+                    /**
+                     * Number of decimal places to round to. Applied directly to the stored monetary
+                     * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                     * nearest 100 in the stored unit).
+                     */
+                    decimal_places: number;
+                    rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                }
             }
             interface QuantitySchedule {
                 quantity: number;
@@ -799,6 +2184,17 @@ export declare namespace ContractGetEditHistoryResponse {
                     name: string;
                 }
             }
+            interface BillingCycleConfig {
+                /**
+                 * The date this subscription's billing cycle is anchored to.
+                 */
+                anchor_date: string;
+                /**
+                 * Controls whether this subscription consolidates onto usage invoices or gets its
+                 * own scheduled invoice.
+                 */
+                invoice_placement: 'ON_SCHEDULED_INVOICE' | 'ON_USAGE_INVOICE';
+            }
             interface SeatConfig {
                 /**
                  * The property name, sent on usage events, that identifies the seat ID associated
@@ -1143,6 +2539,11 @@ export declare namespace ContractGetEditHistoryResponse {
              * lowers to this amount, a threshold charge will be initiated.
              */
             threshold_amount?: number;
+            /**
+             * Determines which balances are excluded from remaining balance calculation for
+             * threshold billing.
+             */
+            threshold_balance_specifiers?: Array<UpdatePrepaidBalanceThresholdConfiguration.ThresholdBalanceSpecifier> | null;
         }
         namespace UpdatePrepaidBalanceThresholdConfiguration {
             interface Commit extends Shared.UpdateBaseThresholdCommit {
@@ -1168,6 +2569,10 @@ export declare namespace ContractGetEditHistoryResponse {
                 specifiers?: Array<Shared.CommitSpecifierInput> | null;
             }
             interface DiscountConfiguration {
+                /**
+                 * Update the discount cap. Set to null to remove an existing cap.
+                 */
+                cap?: DiscountConfiguration.Cap | null;
                 /**
                  * The fraction of the original amount that the customer pays after applying the
                  * discount. Set to null to remove the discount fraction. For example, 0.85 means
@@ -1175,12 +2580,46 @@ export declare namespace ContractGetEditHistoryResponse {
                  */
                 payment_fraction?: number | null;
             }
+            namespace DiscountConfiguration {
+                /**
+                 * Update the discount cap. Set to null to remove an existing cap.
+                 */
+                interface Cap {
+                    /**
+                     * Accumulated spend ceiling above which the discount stops applying.
+                     */
+                    amount: number;
+                    /**
+                     * Alias of the spend tracker this cap is measured against.
+                     */
+                    spend_tracker_alias: string;
+                }
+            }
+            interface ThresholdBalanceSpecifier {
+                exclude: Array<ThresholdBalanceSpecifier.Exclude>;
+            }
+            namespace ThresholdBalanceSpecifier {
+                interface Exclude {
+                    custom_field_filters: Array<Exclude.CustomFieldFilter>;
+                }
+                namespace Exclude {
+                    interface CustomFieldFilter {
+                        entity: 'Commit' | 'ContractCredit' | 'ContractCreditOrCommit';
+                        key: string;
+                        value: string;
+                    }
+                }
+            }
         }
         interface UpdateRecurringCommit {
             id: string;
             access_amount?: UpdateRecurringCommit.AccessAmount;
             ending_before?: string;
             invoice_amount?: UpdateRecurringCommit.InvoiceAmount;
+            /**
+             * Rounding configuration for prorated recurring commit amounts.
+             */
+            proration_rounding?: UpdateRecurringCommit.ProrationRounding | null;
             rate_type?: 'LIST_RATE' | 'COMMIT_RATE';
         }
         namespace UpdateRecurringCommit {
@@ -1192,11 +2631,42 @@ export declare namespace ContractGetEditHistoryResponse {
                 quantity?: number;
                 unit_price?: number;
             }
+            /**
+             * Rounding configuration for prorated recurring commit amounts.
+             */
+            interface ProrationRounding {
+                access?: ProrationRounding.Access;
+                invoice?: ProrationRounding.Invoice;
+            }
+            namespace ProrationRounding {
+                interface Access {
+                    /**
+                     * Number of decimal places to round to. Applied directly to the stored monetary
+                     * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                     * nearest 100 in the stored unit).
+                     */
+                    decimal_places: number;
+                    rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                }
+                interface Invoice {
+                    /**
+                     * Number of decimal places to round to. Applied directly to the stored monetary
+                     * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                     * nearest 100 in the stored unit).
+                     */
+                    decimal_places: number;
+                    rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                }
+            }
         }
         interface UpdateRecurringCredit {
             id: string;
             access_amount?: UpdateRecurringCredit.AccessAmount;
             ending_before?: string;
+            /**
+             * Rounding configuration for prorated recurring credit amounts.
+             */
+            proration_rounding?: UpdateRecurringCredit.ProrationRounding | null;
             rate_type?: 'LIST_RATE' | 'COMMIT_RATE';
         }
         namespace UpdateRecurringCredit {
@@ -1204,6 +2674,23 @@ export declare namespace ContractGetEditHistoryResponse {
                 quantity?: number;
                 unit_price?: number;
             }
+            /**
+             * Rounding configuration for prorated recurring credit amounts.
+             */
+            interface ProrationRounding {
+                access?: ProrationRounding.Access;
+            }
+            namespace ProrationRounding {
+                interface Access {
+                    /**
+                     * Number of decimal places to round to. Applied directly to the stored monetary
+                     * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                     * nearest 100 in the stored unit).
+                     */
+                    decimal_places: number;
+                    rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+                }
+            }
         }
         interface UpdateRefundInvoice {
             date: string;
@@ -1258,6 +2745,10 @@ export declare namespace ContractGetEditHistoryResponse {
         }
         namespace UpdateSpendThresholdConfiguration {
             interface DiscountConfiguration {
+                /**
+                 * Update the discount cap. Set to null to remove an existing cap.
+                 */
+                cap?: DiscountConfiguration.Cap | null;
                 /**
                  * The fraction of the original amount that the customer pays after applying the
                  * discount. Set to null to remove the discount fraction. For example, 0.85 means
@@ -1265,6 +2756,21 @@ export declare namespace ContractGetEditHistoryResponse {
                  */
                 payment_fraction?: number | null;
             }
+            namespace DiscountConfiguration {
+                /**
+                 * Update the discount cap. Set to null to remove an existing cap.
+                 */
+                interface Cap {
+                    /**
+                     * Accumulated spend ceiling above which the discount stops applying.
+                     */
+                    amount: number;
+                    /**
+                     * Alias of the spend tracker this cap is measured against.
+                     */
+                    spend_tracker_alias: string;
+                }
+            }
         }
         interface UpdateSubscription {
             id: string;
@@ -1431,6 +2937,11 @@ export interface ContractEditParams {
     add_revenue_system_configuration_update?: ContractEditParams.AddRevenueSystemConfigurationUpdate;
     add_scheduled_charges?: Array<ContractEditParams.AddScheduledCharge>;
     add_spend_threshold_configuration?: Shared.SpendThresholdConfigurationV2;
+    /**
+     * Spend trackers to add to this contract. Aliases must be unique within a
+     * contract.
+     */
+    add_spend_trackers?: Array<ContractEditParams.AddSpendTracker>;
     /**
      * Optional list of
      * [subscriptions](https://docs.metronome.com/manage-product-access/create-subscription/)
@@ -1456,6 +2967,10 @@ export interface ContractEditParams {
      * IDs of scheduled charges to archive
      */
     archive_scheduled_charges?: Array<ContractEditParams.ArchiveScheduledCharge>;
+    /**
+     * Aliases of spend trackers to archive.
+     */
+    archive_spend_trackers?: Array<string>;
     /**
      * IDs of overrides to remove
      */
@@ -1608,6 +3123,10 @@ export declare namespace ContractEditParams {
          * body of `specifiers`.
          */
         specifiers?: Array<Shared.CommitSpecifierInput>;
+        /**
+         * Optional attributes for spend tracker integration. Immutable after creation.
+         */
+        spend_tracker_attributes?: AddCommit.SpendTrackerAttributes;
         /**
          * A temporary ID for the commit that can be used to reference the commit for
          * commit specific overrides.
@@ -1795,6 +3314,16 @@ export declare namespace ContractEditParams {
                 on_session_payment?: boolean;
             }
         }
+        /**
+         * Optional attributes for spend tracker integration. Immutable after creation.
+         */
+        interface SpendTrackerAttributes {
+            /**
+             * If true, this commit will be included in spend trackers with discounted set to
+             * DISCOUNTED_ONLY
+             */
+            counts_as_discounted: boolean;
+        }
     }
     interface AddCredit {
         /**
@@ -2045,6 +3574,14 @@ export declare namespace ContractEditParams {
     }
     namespace AddOverride {
         interface OverrideSpecifier {
+            /**
+             * Can only be used for commit specific overrides. Must be used in conjunction with
+             * one of `product_id`, `product_tags`, `pricing_group_values`, or
+             * `presentation_group_values`. Must be used instead of both `commit_ids` and
+             * `recurring_commit_ids` If provided, the override will apply to any specified
+             * commit, credit, recurring commit or recurring credit IDs.
+             */
+            any_commit_or_credit_ids?: Array<string>;
             billing_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
             /**
              * If provided, the override will only apply to the specified commits. Can only be
@@ -2206,6 +3743,10 @@ export declare namespace ContractEditParams {
          * the default is FIRST_AND_LAST (i.e. prorate both the first and last commits).
          */
         proration?: 'NONE' | 'FIRST' | 'LAST' | 'FIRST_AND_LAST';
+        /**
+         * Optional rounding configuration for prorated recurring commit amounts.
+         */
+        proration_rounding?: AddRecurringCommit.ProrationRounding;
         /**
          * Whether the created commits will use the commit rate or list rate
          */
@@ -2217,7 +3758,7 @@ export declare namespace ContractEditParams {
          * be created aligned with the recurring commit's starting_at rather than the usage
          * invoice dates.
          */
-        recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
+        recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY' | 'DAILY';
         /**
          * Will be passed down to the individual commits. This controls how much of an
          * individual unexpired commit will roll over upon contract transition. Must be
@@ -2273,6 +3814,33 @@ export declare namespace ContractEditParams {
             quantity: number;
             unit_price: number;
         }
+        /**
+         * Optional rounding configuration for prorated recurring commit amounts.
+         */
+        interface ProrationRounding {
+            access?: ProrationRounding.Access;
+            invoice?: ProrationRounding.Invoice;
+        }
+        namespace ProrationRounding {
+            interface Access {
+                /**
+                 * Number of decimal places to round to. Applied directly to the stored monetary
+                 * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                 * nearest 100 in the stored unit).
+                 */
+                decimal_places: number;
+                rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+            }
+            interface Invoice {
+                /**
+                 * Number of decimal places to round to. Applied directly to the stored monetary
+                 * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                 * nearest 100 in the stored unit).
+                 */
+                decimal_places: number;
+                rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+            }
+        }
         /**
          * Attach a subscription to the recurring commit/credit.
          */
@@ -2350,6 +3918,10 @@ export declare namespace ContractEditParams {
          * the default is FIRST_AND_LAST (i.e. prorate both the first and last commits).
          */
         proration?: 'NONE' | 'FIRST' | 'LAST' | 'FIRST_AND_LAST';
+        /**
+         * Optional rounding configuration for prorated recurring credit amounts.
+         */
+        proration_rounding?: AddRecurringCredit.ProrationRounding;
         /**
          * Whether the created commits will use the commit rate or list rate
          */
@@ -2361,7 +3933,7 @@ export declare namespace ContractEditParams {
          * be created aligned with the recurring commit's starting_at rather than the usage
          * invoice dates.
          */
-        recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY';
+        recurrence_frequency?: 'MONTHLY' | 'QUARTERLY' | 'ANNUAL' | 'WEEKLY' | 'DAILY';
         /**
          * Will be passed down to the individual commits. This controls how much of an
          * individual unexpired commit will roll over upon contract transition. Must be
@@ -2409,6 +3981,23 @@ export declare namespace ContractEditParams {
             value: number;
             unit?: 'PERIODS';
         }
+        /**
+         * Optional rounding configuration for prorated recurring credit amounts.
+         */
+        interface ProrationRounding {
+            access?: ProrationRounding.Access;
+        }
+        namespace ProrationRounding {
+            interface Access {
+                /**
+                 * Number of decimal places to round to. Applied directly to the stored monetary
+                 * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                 * nearest 100 in the stored unit).
+                 */
+                decimal_places: number;
+                rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+            }
+        }
         /**
          * Attach a subscription to the recurring commit/credit.
          */
@@ -2598,10 +4187,30 @@ export declare namespace ContractEditParams {
             }
         }
     }
+    interface AddSpendTracker {
+        /**
+         * Human-readable identifier, unique per contract.
+         */
+        alias: string;
+        applicable_spend_specifiers: Array<AddSpendTracker.ApplicableSpendSpecifier>;
+        credit_type_id: string;
+        reset_frequency: 'BILLING_PERIOD';
+    }
+    namespace AddSpendTracker {
+        interface ApplicableSpendSpecifier {
+            sources: Array<'THRESHOLD_RECHARGE' | 'MANUAL'>;
+            spend_type: 'COMMIT_PURCHASE';
+            /**
+             * Filter by whether the spend was discounted. Defaults to ANY if omitted.
+             */
+            discounted?: 'ANY' | 'DISCOUNTED_ONLY' | 'UNDISCOUNTED_ONLY';
+        }
+    }
     interface AddSubscription {
         collection_schedule: 'ADVANCE' | 'ARREARS';
         proration: AddSubscription.Proration;
         subscription_rate: AddSubscription.SubscriptionRate;
+        billing_cycle_config?: AddSubscription.BillingCycleConfig;
         /**
          * Custom fields to be added eg. { "key1": "value1", "key2": "value2" }
          */
@@ -2658,6 +4267,18 @@ export declare namespace ContractEditParams {
              * Indicates if the partial period will be prorated or charged a full amount.
              */
             is_prorated?: boolean;
+            rounding?: Proration.Rounding;
+        }
+        namespace Proration {
+            interface Rounding {
+                /**
+                 * Number of decimal places to round to. Applied directly to the stored monetary
+                 * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                 * nearest 100 in the stored unit).
+                 */
+                decimal_places: number;
+                rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+            }
         }
         interface SubscriptionRate {
             /**
@@ -2670,6 +4291,18 @@ export declare namespace ContractEditParams {
              */
             product_id: string;
         }
+        interface BillingCycleConfig {
+            /**
+             * The date to anchor the billing cycle to. If omitted, defaults to the contract's
+             * usage invoice billing cycle anchor date.
+             */
+            anchor_date?: string;
+            /**
+             * Controls whether this subscription consolidates onto usage invoices or gets its
+             * own scheduled invoice. Defaults to ON_USAGE_INVOICE if omitted.
+             */
+            invoice_placement?: 'ON_SCHEDULED_INVOICE' | 'ON_USAGE_INVOICE';
+        }
         interface SeatConfig {
             /**
              * The initial assigned seats on this subscription.
@@ -2860,6 +4493,11 @@ export declare namespace ContractEditParams {
          * lowers to this amount, a threshold charge will be initiated.
          */
         threshold_amount?: number;
+        /**
+         * Determines which balances are excluded from remaining balance calculation for
+         * threshold billing.
+         */
+        threshold_balance_specifiers?: Array<UpdatePrepaidBalanceThresholdConfiguration.ThresholdBalanceSpecifier> | null;
     }
     namespace UpdatePrepaidBalanceThresholdConfiguration {
         interface Commit extends Shared.UpdateBaseThresholdCommit {
@@ -2885,6 +4523,10 @@ export declare namespace ContractEditParams {
             specifiers?: Array<Shared.CommitSpecifierInput> | null;
         }
         interface DiscountConfiguration {
+            /**
+             * Update the discount cap. Set to null to remove an existing cap.
+             */
+            cap?: DiscountConfiguration.Cap | null;
             /**
              * The fraction of the original amount that the customer pays after applying the
              * discount. Set to null to remove the discount fraction. For example, 0.85 means
@@ -2892,12 +4534,47 @@ export declare namespace ContractEditParams {
              */
             payment_fraction?: number | null;
         }
+        namespace DiscountConfiguration {
+            /**
+             * Update the discount cap. Set to null to remove an existing cap.
+             */
+            interface Cap {
+                /**
+                 * Accumulated spend ceiling above which the discount stops applying.
+                 */
+                amount: number;
+                /**
+                 * Alias of the spend tracker this cap is measured against.
+                 */
+                spend_tracker_alias: string;
+            }
+        }
+        interface ThresholdBalanceSpecifier {
+            exclude: Array<ThresholdBalanceSpecifier.Exclude>;
+        }
+        namespace ThresholdBalanceSpecifier {
+            interface Exclude {
+                custom_field_filters: Array<Exclude.CustomFieldFilter>;
+            }
+            namespace Exclude {
+                interface CustomFieldFilter {
+                    entity: 'Commit' | 'ContractCredit' | 'ContractCreditOrCommit';
+                    key: string;
+                    value: string;
+                }
+            }
+        }
     }
     interface UpdateRecurringCommit {
         recurring_commit_id: string;
         access_amount?: UpdateRecurringCommit.AccessAmount;
         ending_before?: string | null;
         invoice_amount?: UpdateRecurringCommit.InvoiceAmount;
+        /**
+         * If provided, updates the rounding config on the recurring commit. Set to null to
+         * clear rounding. Omit to leave unchanged.
+         */
+        proration_rounding?: UpdateRecurringCommit.ProrationRounding | null;
         /**
          * If provided, updates the recurring commit to use the specified rate type when
          * generating future commits.
@@ -2913,11 +4590,44 @@ export declare namespace ContractEditParams {
             quantity?: number;
             unit_price?: number;
         }
+        /**
+         * If provided, updates the rounding config on the recurring commit. Set to null to
+         * clear rounding. Omit to leave unchanged.
+         */
+        interface ProrationRounding {
+            access?: ProrationRounding.Access | null;
+            invoice?: ProrationRounding.Invoice | null;
+        }
+        namespace ProrationRounding {
+            interface Access {
+                /**
+                 * Number of decimal places to round to. Applied directly to the stored monetary
+                 * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                 * nearest 100 in the stored unit).
+                 */
+                decimal_places: number;
+                rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+            }
+            interface Invoice {
+                /**
+                 * Number of decimal places to round to. Applied directly to the stored monetary
+                 * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                 * nearest 100 in the stored unit).
+                 */
+                decimal_places: number;
+                rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+            }
+        }
     }
     interface UpdateRecurringCredit {
         recurring_credit_id: string;
         access_amount?: UpdateRecurringCredit.AccessAmount;
         ending_before?: string | null;
+        /**
+         * If provided, updates the rounding config on the recurring credit. Set to null to
+         * clear rounding. Omit to leave unchanged.
+         */
+        proration_rounding?: UpdateRecurringCredit.ProrationRounding | null;
         /**
          * If provided, updates the recurring credit to use the specified rate type when
          * generating future credits.
@@ -2929,6 +4639,24 @@ export declare namespace ContractEditParams {
             quantity?: number;
             unit_price?: number;
         }
+        /**
+         * If provided, updates the rounding config on the recurring credit. Set to null to
+         * clear rounding. Omit to leave unchanged.
+         */
+        interface ProrationRounding {
+            access?: ProrationRounding.Access | null;
+        }
+        namespace ProrationRounding {
+            interface Access {
+                /**
+                 * Number of decimal places to round to. Applied directly to the stored monetary
+                 * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+                 * nearest 100 in the stored unit).
+                 */
+                decimal_places: number;
+                rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+            }
+        }
     }
     interface UpdateScheduledCharge {
         scheduled_charge_id: string;
@@ -2978,6 +4706,10 @@ export declare namespace ContractEditParams {
     }
     namespace UpdateSpendThresholdConfiguration {
         interface DiscountConfiguration {
+            /**
+             * Update the discount cap. Set to null to remove an existing cap.
+             */
+            cap?: DiscountConfiguration.Cap | null;
             /**
              * The fraction of the original amount that the customer pays after applying the
              * discount. Set to null to remove the discount fraction. For example, 0.85 means
@@ -2985,10 +4717,26 @@ export declare namespace ContractEditParams {
              */
             payment_fraction?: number | null;
         }
+        namespace DiscountConfiguration {
+            /**
+             * Update the discount cap. Set to null to remove an existing cap.
+             */
+            interface Cap {
+                /**
+                 * Accumulated spend ceiling above which the discount stops applying.
+                 */
+                amount: number;
+                /**
+                 * Alias of the spend tracker this cap is measured against.
+                 */
+                spend_tracker_alias: string;
+            }
+        }
     }
     interface UpdateSubscription {
         subscription_id: string;
         ending_before?: string | null;
+        proration_rounding?: UpdateSubscription.ProrationRounding | null;
         /**
          * Update the subscription's quantity management mode from QUANTITY_ONLY to
          * SEAT_BASED with the provided seat_group_key.
@@ -3003,6 +4751,15 @@ export declare namespace ContractEditParams {
         seat_updates?: UpdateSubscription.SeatUpdates;
     }
     namespace UpdateSubscription {
+        interface ProrationRounding {
+            /**
+             * Number of decimal places to round to. Applied directly to the stored monetary
+             * representation. Negative values round to powers of 10 (e.g., -2 rounds to
+             * nearest 100 in the stored unit).
+             */
+            decimal_places: number;
+            rounding_method: 'HALF_UP' | 'FLOOR' | 'CEILING';
+        }
         /**
          * Update the subscription's quantity management mode from QUANTITY_ONLY to
          * SEAT_BASED with the provided seat_group_key.