import * as z$1 from 'zod/v4-mini';
import * as z from 'zod/v4/core';

type Fetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
type Awaitable$1<T> = T | Promise<T>;
type RequestInput = {
    /**
     * The URL the request will use.
     */
    url: URL;
    /**
     * Options used to create a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request).
     */
    options?: RequestInit | undefined;
};
interface HTTPClientOptions {
    fetcher?: Fetcher;
}
type BeforeRequestHook$1 = (req: Request) => Awaitable$1<Request | void>;
type RequestErrorHook = (err: unknown, req: Request) => Awaitable$1<void>;
type ResponseHook = (res: Response, req: Request) => Awaitable$1<void>;
declare class HTTPClient {
    private options;
    private fetcher;
    private requestHooks;
    private requestErrorHooks;
    private responseHooks;
    constructor(options?: HTTPClientOptions);
    request(request: Request): Promise<Response>;
    /**
     * Registers a hook that is called before a request is made. The hook function
     * can mutate the request or return a new request. This may be useful to add
     * additional information to request such as request IDs and tracing headers.
     */
    addHook(hook: "beforeRequest", fn: BeforeRequestHook$1): this;
    /**
     * Registers a hook that is called when a request cannot be made due to a
     * network error.
     */
    addHook(hook: "requestError", fn: RequestErrorHook): this;
    /**
     * Registers a hook that is called when a response has been received from the
     * server.
     */
    addHook(hook: "response", fn: ResponseHook): this;
    /** Removes a hook that was previously registered with `addHook`. */
    removeHook(hook: "beforeRequest", fn: BeforeRequestHook$1): this;
    /** Removes a hook that was previously registered with `addHook`. */
    removeHook(hook: "requestError", fn: RequestErrorHook): this;
    /** Removes a hook that was previously registered with `addHook`. */
    removeHook(hook: "response", fn: ResponseHook): this;
    clone(): HTTPClient;
}

interface Logger {
    group(label?: string): void;
    groupEnd(): void;
    log(message: any, ...args: any[]): void;
}

type BackoffStrategy = {
    initialInterval: number;
    maxInterval: number;
    exponent: number;
    maxElapsedTime: number;
};
type RetryConfig = {
    strategy: "none";
} | {
    strategy: "backoff";
    backoff?: BackoffStrategy;
    retryConnectionErrors?: boolean;
};

/**
 * Contains the list of servers available to the SDK
 */
declare const ServerList: readonly ["https://api.useautumn.com"];
type SDKOptions = {
    secretKey?: string | (() => Promise<string>) | undefined;
    /**
     * Allows setting the xApiVersion parameter for all supported operations
     */
    xApiVersion?: string | undefined;
    /**
     * Allows setting the failOpen parameter for all supported operations
     */
    failOpen?: boolean | undefined;
    httpClient?: HTTPClient;
    /**
     * Allows overriding the default server used by the SDK
     */
    serverIdx?: number | undefined;
    /**
     * Allows overriding the default server URL used by the SDK
     */
    serverURL?: string | undefined;
    /**
     * Allows overriding the default user agent used by the SDK
     */
    userAgent?: string | undefined;
    /**
     * Allows overriding the default retry config used by the SDK
     */
    retryConfig?: RetryConfig;
    timeoutMs?: number;
    debugLogger?: Logger;
};
declare function serverURLFromOptions(options: SDKOptions): URL | null;
declare const SDK_METADATA: {
    readonly language: "typescript";
    readonly openapiDocVersion: "2.3.0";
    readonly sdkVersion: "0.10.17";
    readonly genVersion: "2.882.0";
    readonly userAgent: "speakeasy-sdk/typescript 0.10.17 2.882.0 2.3.0 @useautumn/sdk";
};

/**
 * Consumes a stream and returns a concatenated array buffer. Useful in
 * situations where we need to read the whole file because it forms part of a
 * larger payload containing other fields, and we can't modify the underlying
 * request structure.
 */
declare function readableStreamToArrayBuffer(readable: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
/**
 * Determines the MIME content type based on a file's extension.
 * Returns null if the extension is not recognized.
 */
declare function getContentTypeFromFileName(fileName: string): string | null;
/**
 * Creates a Blob from file content with the given MIME type.
 *
 * Node.js Buffers are Uint8Array subclasses that may share a pooled
 * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
 * such a Buffer directly to `new Blob([buf])` can include the entire
 * underlying pool on some runtimes, producing a Blob with extra bytes
 * that corrupts multipart uploads.
 *
 * Copying into a standalone Uint8Array ensures the Blob receives only the
 * intended bytes regardless of runtime behaviour.
 */
declare function bytesToBlob(content: Uint8Array<ArrayBufferLike> | ArrayBuffer | Blob | string, contentType: string): Blob;

declare const files_bytesToBlob: typeof bytesToBlob;
declare const files_getContentTypeFromFileName: typeof getContentTypeFromFileName;
declare const files_readableStreamToArrayBuffer: typeof readableStreamToArrayBuffer;
declare namespace files {
  export { files_bytesToBlob as bytesToBlob, files_getContentTypeFromFileName as getContentTypeFromFileName, files_readableStreamToArrayBuffer as readableStreamToArrayBuffer };
}

declare const __brand: unique symbol;
type Unrecognized<T> = T & {
    [__brand]: "unrecognized";
};
declare function unrecognized<T>(value: T): Unrecognized<T>;
declare function startCountingUnrecognized(): {
    /**
     * Ends counting and returns the delta.
     * @param delta - If provided, only this amount is added to the parent counter
     *   (used for nested unions where we only want to record the winning option's count).
     *   If not provided, records all counts since start().
     */
    end: (delta?: number) => number;
};

type ClosedEnum<T extends Readonly<Record<string, string | number>>> = T[keyof T];
type OpenEnum<T extends Readonly<Record<string, string | number>>> = T[keyof T] | Unrecognized<T[keyof T] extends number ? number : string>;

/**
 * A monad that captures the result of a function call or an error if it was not
 * successful. Railway programming, enabled by this type, can be a nicer
 * alternative to traditional exception throwing because it allows functions to
 * declare all _known_ errors with static types and then check for them
 * exhaustively in application code. Thrown exception have a type of `unknown`
 * and break out of regular control flow of programs making them harder to
 * inspect and more verbose work with due to try-catch blocks.
 */
type Result$1<T, E = unknown> = {
    ok: true;
    value: T;
    error?: never;
} | {
    ok: false;
    value?: never;
    error: E;
};

declare class SDKValidationError extends Error {
    /**
     * The raw value that failed validation.
     */
    readonly rawValue: unknown;
    /**
     * The raw message that failed validation.
     */
    readonly rawMessage: unknown;
    static [Symbol.hasInstance](instance: unknown): instance is SDKValidationError;
    constructor(message: string, cause: unknown, rawValue: unknown);
    /**
     * Return a pretty-formatted error message if the underlying validation error
     * is a ZodError or some other recognized error type, otherwise return the
     * default error message.
     */
    pretty(): string;
}
declare function formatZodError(err: z.$ZodError): string;

type AggregateEventsGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Feature ID(s) to aggregate events for
 */
type AggregateEventsFeatureId = string | Array<string>;
/**
 * Time range to aggregate events for. Either range or custom_range must be provided
 */
declare const Range: {
    readonly TwentyFourh: "24h";
    readonly Sevend: "7d";
    readonly Thirtyd: "30d";
    readonly Ninetyd: "90d";
    readonly LastCycle: "last_cycle";
    readonly Onebc: "1bc";
    readonly Threebc: "3bc";
};
/**
 * Time range to aggregate events for. Either range or custom_range must be provided
 */
type Range = ClosedEnum<typeof Range>;
/**
 * Size of the time bins to aggregate events for. Defaults to hour if range is 24h, otherwise day
 */
declare const BinSize: {
    readonly Day: "day";
    readonly Hour: "hour";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * Size of the time bins to aggregate events for. Defaults to hour if range is 24h, otherwise day
 */
type BinSize = ClosedEnum<typeof BinSize>;
/**
 * Custom time range to aggregate events for. If provided, range must not be provided
 */
type AggregateEventsCustomRange = {
    start: number;
    end: number;
};
type EventsAggregateParams = {
    /**
     * Customer ID to aggregate events for
     */
    customerId?: string | undefined;
    /**
     * Entity ID to filter aggregated events for (e.g., per-seat or per-resource limits)
     */
    entityId?: string | undefined;
    /**
     * Feature ID(s) to aggregate events for
     */
    featureId: string | Array<string>;
    /**
     * Property to group events by (e.g. "properties.region"), or "$customer_id" / "$entity_id" / "$plan_id" to group by those columns
     */
    groupBy?: string | undefined;
    /**
     * Time range to aggregate events for. Either range or custom_range must be provided
     */
    range?: Range | undefined;
    /**
     * Size of the time bins to aggregate events for. Defaults to hour if range is 24h, otherwise day
     */
    binSize?: BinSize | undefined;
    /**
     * Custom time range to aggregate events for. If provided, range must not be provided
     */
    customRange?: AggregateEventsCustomRange | undefined;
    /**
     * Filter events by property values, e.g. {"model": "gpt-4", "region": "us"}. Maximum 5 filters.
     */
    filterBy?: {
        [k: string]: string;
    } | undefined;
    /**
     * Maximum number of distinct group values to return per time bin when using group_by. Remaining values are bundled into an 'Other' bucket. Defaults to 9
     */
    maxGroups?: number | undefined;
};
type AggregateEventsList = {
    /**
     * Unix timestamp (epoch ms) for this time period
     */
    period: number;
    /**
     * Aggregated values per feature: { [featureId]: number }
     */
    values: {
        [k: string]: number;
    };
    /**
     * Values broken down by group (only present when group_by is used): { [featureId]: { [groupValue]: number } }
     */
    groupedValues?: {
        [k: string]: {
            [k: string]: number;
        };
    } | undefined;
};
type Total = {
    /**
     * Number of events for this feature
     */
    count: number;
    /**
     * Sum of event values for this feature
     */
    sum: number;
};
/**
 * OK
 */
type AggregateEventsResponse = {
    /**
     * Array of time periods with aggregated values
     */
    list: Array<AggregateEventsList>;
    /**
     * Total aggregations per feature. Keys are feature IDs, values contain count and sum.
     */
    total: {
        [k: string]: Total;
    };
};
/** @internal */
type AggregateEventsFeatureId$Outbound = string | Array<string>;
/** @internal */
declare const AggregateEventsFeatureId$outboundSchema: z$1.ZodMiniType<AggregateEventsFeatureId$Outbound, AggregateEventsFeatureId>;
declare function aggregateEventsFeatureIdToJSON(aggregateEventsFeatureId: AggregateEventsFeatureId): string;
/** @internal */
declare const Range$outboundSchema: z$1.ZodMiniEnum<typeof Range>;
/** @internal */
declare const BinSize$outboundSchema: z$1.ZodMiniEnum<typeof BinSize>;
/** @internal */
type AggregateEventsCustomRange$Outbound = {
    start: number;
    end: number;
};
/** @internal */
declare const AggregateEventsCustomRange$outboundSchema: z$1.ZodMiniType<AggregateEventsCustomRange$Outbound, AggregateEventsCustomRange>;
declare function aggregateEventsCustomRangeToJSON(aggregateEventsCustomRange: AggregateEventsCustomRange): string;
/** @internal */
type EventsAggregateParams$Outbound = {
    customer_id?: string | undefined;
    entity_id?: string | undefined;
    feature_id: string | Array<string>;
    group_by?: string | undefined;
    range?: string | undefined;
    bin_size: string;
    custom_range?: AggregateEventsCustomRange$Outbound | undefined;
    filter_by?: {
        [k: string]: string;
    } | undefined;
    max_groups?: number | undefined;
};
/** @internal */
declare const EventsAggregateParams$outboundSchema: z$1.ZodMiniType<EventsAggregateParams$Outbound, EventsAggregateParams>;
declare function eventsAggregateParamsToJSON(eventsAggregateParams: EventsAggregateParams): string;
/** @internal */
declare const AggregateEventsList$inboundSchema: z$1.ZodMiniType<AggregateEventsList, unknown>;
declare function aggregateEventsListFromJSON(jsonString: string): Result$1<AggregateEventsList, SDKValidationError>;
/** @internal */
declare const Total$inboundSchema: z$1.ZodMiniType<Total, unknown>;
declare function totalFromJSON(jsonString: string): Result$1<Total, SDKValidationError>;
/** @internal */
declare const AggregateEventsResponse$inboundSchema: z$1.ZodMiniType<AggregateEventsResponse, unknown>;
declare function aggregateEventsResponseFromJSON(jsonString: string): Result$1<AggregateEventsResponse, SDKValidationError>;

type AttachGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type AttachFeatureQuantity = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const AttachPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type AttachPriceInterval = ClosedEnum<typeof AttachPriceInterval>;
/**
 * Base price configuration for a plan.
 */
type AttachBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: AttachPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const AttachItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type AttachItemResetInterval = ClosedEnum<typeof AttachItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type AttachItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: AttachItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type AttachItemTo = number | string;
type AttachItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const AttachItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type AttachItemTierBehavior = ClosedEnum<typeof AttachItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const AttachItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type AttachItemPriceInterval = ClosedEnum<typeof AttachItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const AttachItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type AttachItemBillingMethod = ClosedEnum<typeof AttachItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type AttachItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<AttachItemTier> | undefined;
    tierBehavior?: AttachItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: AttachItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: AttachItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const AttachItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type AttachItemOnIncrease = ClosedEnum<typeof AttachItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const AttachItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type AttachItemOnDecrease = ClosedEnum<typeof AttachItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type AttachItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: AttachItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: AttachItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const AttachItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type AttachItemExpiryDurationType = ClosedEnum<typeof AttachItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type AttachItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: AttachItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type AttachItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: AttachItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: AttachItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: AttachItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: AttachItemRollover | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const AttachAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type AttachAddItemResetInterval = ClosedEnum<typeof AttachAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type AttachAddItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: AttachAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type AttachAddItemTo = number | string;
type AttachAddItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const AttachAddItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type AttachAddItemTierBehavior = ClosedEnum<typeof AttachAddItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const AttachAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type AttachAddItemPriceInterval = ClosedEnum<typeof AttachAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const AttachAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type AttachAddItemBillingMethod = ClosedEnum<typeof AttachAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type AttachAddItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<AttachAddItemTier> | undefined;
    tierBehavior?: AttachAddItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: AttachAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: AttachAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const AttachAddItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type AttachAddItemOnIncrease = ClosedEnum<typeof AttachAddItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const AttachAddItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type AttachAddItemOnDecrease = ClosedEnum<typeof AttachAddItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type AttachAddItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: AttachAddItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: AttachAddItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const AttachAddItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type AttachAddItemExpiryDurationType = ClosedEnum<typeof AttachAddItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type AttachAddItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: AttachAddItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type AttachAddItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: AttachAddItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: AttachAddItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: AttachAddItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: AttachAddItemRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const AttachRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type AttachRemoveItemBillingMethod = ClosedEnum<typeof AttachRemoveItemBillingMethod>;
declare const AttachIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type AttachIntervalRemoveItemEnum2 = ClosedEnum<typeof AttachIntervalRemoveItemEnum2>;
declare const AttachIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type AttachIntervalRemoveItemEnum1 = ClosedEnum<typeof AttachIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type AttachIntervalUnion = AttachIntervalRemoveItemEnum1 | AttachIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type AttachPlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: AttachRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: AttachIntervalRemoveItemEnum1 | AttachIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const AttachDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type AttachDurationType = ClosedEnum<typeof AttachDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const AttachOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type AttachOnEnd = ClosedEnum<typeof AttachOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type AttachFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: AttachDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: AttachOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const AttachPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type AttachPurchaseLimitInterval = ClosedEnum<typeof AttachPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type AttachPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: AttachPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type AttachAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: AttachPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const AttachLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type AttachLimitType = ClosedEnum<typeof AttachLimitType>;
type AttachSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: AttachLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const AttachUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type AttachUsageLimitInterval = ClosedEnum<typeof AttachUsageLimitInterval>;
type AttachProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type AttachFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type AttachUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: AttachUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: AttachFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const AttachThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type AttachThresholdType = ClosedEnum<typeof AttachThresholdType>;
type AttachUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: AttachThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type AttachOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type AttachBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<AttachAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<AttachSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<AttachUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<AttachUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<AttachOverageAllowed> | undefined;
};
/**
 * Customize the plan to attach. Can override the price, items, free trial, or a combination.
 */
type AttachCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: AttachBasePrice | null | undefined;
    /**
     * Override the items in the plan (PUT-style — replaces all existing items). Mutually exclusive with add_items / remove_items / deprecated update_items.
     */
    items?: Array<AttachItemPlanItem> | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<AttachAddItemPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<AttachPlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: AttachFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: AttachBillingControls | undefined;
};
/**
 * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
 */
type AttachInvoiceMode = {
    /**
     * When true, creates an invoice and sends it to the customer instead of charging their card immediately. Uses Stripe's send_invoice collection method.
     */
    enabled: boolean;
    /**
     * If true, enables the plan immediately even though the invoice is not paid yet.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * If true, finalizes the invoice so it can be sent to the customer. If false, keeps it as a draft for manual review.
     */
    finalize?: boolean | undefined;
    /**
     * ID of an invoice template (configured in billing settings) whose footer (e.g. bank details) is applied to the invoice.
     */
    invoiceTemplateId?: string | undefined;
    /**
     * Number of days the customer has to pay the invoice before it is due (Stripe days_until_due).
     */
    netTermsDays?: number | undefined;
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
declare const AttachProrationBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
type AttachProrationBehavior = ClosedEnum<typeof AttachProrationBehavior>;
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
declare const AttachRedirectMode: {
    readonly Always: "always";
    readonly IfRequired: "if_required";
    readonly Never: "never";
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
type AttachRedirectMode = ClosedEnum<typeof AttachRedirectMode>;
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type AttachAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
/**
 * When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled.
 */
declare const AttachPlanSchedule: {
    readonly Immediate: "immediate";
    readonly EndOfCycle: "end_of_cycle";
};
/**
 * When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled.
 */
type AttachPlanSchedule = ClosedEnum<typeof AttachPlanSchedule>;
type AttachCustomLineItem = {
    /**
     * Amount in dollars for this line item (e.g. 10.50). Can be negative for credits.
     */
    amount: number;
    /**
     * Description for the line item.
     */
    description: string;
};
/**
 * Whether to carry over balances from the previous plan.
 */
type AttachCarryOverBalances = {
    /**
     * Whether to carry over balances from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over balances from. If left undefined, all features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
/**
 * Whether to carry over usages from the previous plan.
 */
type AttachCarryOverUsages = {
    /**
     * Whether to carry over usages from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over usages for. If left undefined, all consumable features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
type AttachParams = {
    /**
     * The ID of the customer to attach the plan to.
     */
    customerId: string;
    /**
     * The ID of the entity to attach the plan to.
     */
    entityId?: string | undefined;
    /**
     * The ID of the plan.
     */
    planId: string;
    /**
     * If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan.
     */
    featureQuantities?: Array<AttachFeatureQuantity> | undefined;
    /**
     * The version of the plan to attach.
     */
    version?: number | undefined;
    /**
     * Customize the plan to attach. Can override the price, items, free trial, or a combination.
     */
    customize?: AttachCustomize | undefined;
    /**
     * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
     */
    invoiceMode?: AttachInvoiceMode | undefined;
    /**
     * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
     */
    prorationBehavior?: AttachProrationBehavior | undefined;
    /**
     * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
     */
    redirectMode?: AttachRedirectMode | undefined;
    /**
     * A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan.
     */
    subscriptionId?: string | undefined;
    /**
     * List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<AttachAttachDiscount> | undefined;
    /**
     * URL to redirect to after successful checkout.
     */
    successUrl?: string | undefined;
    /**
     * Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one.
     */
    newBillingSubscription?: boolean | undefined;
    /**
     * Reset the billing cycle anchor immediately with 'now'.
     */
    billingCycleAnchor?: "now" | undefined;
    /**
     * When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled.
     */
    planSchedule?: AttachPlanSchedule | undefined;
    /**
     * Unix timestamp in milliseconds for when the attached plan should start. Future dates create a scheduled subscription.
     */
    startsAt?: number | undefined;
    /**
     * Unix timestamp in milliseconds for when the attached plan should end.
     */
    endsAt?: number | undefined;
    /**
     * Additional parameters to pass into the creation of the Stripe checkout session.
     */
    checkoutSessionParams?: {
        [k: string]: any;
    } | undefined;
    /**
     * If true, returns an Autumn-hosted checkout link that can create a fresh Stripe checkout session when opened.
     */
    longLivedCheckout?: boolean | undefined;
    /**
     * Custom line items that override the auto-generated proration invoice. Only valid for immediate plan changes (eg. upgrades or one off plans).
     */
    customLineItems?: Array<AttachCustomLineItem> | undefined;
    /**
     * The processor subscription ID to link. Use this to attach an existing Stripe subscription instead of creating a new one.
     */
    processorSubscriptionId?: string | undefined;
    /**
     * Whether to carry over balances from the previous plan.
     */
    carryOverBalances?: AttachCarryOverBalances | undefined;
    /**
     * Whether to carry over usages from the previous plan.
     */
    carryOverUsages?: AttachCarryOverUsages | undefined;
    /**
     * Key-value metadata to attach to the Stripe subscription, invoice, and checkout session created during this attach flow. Keys prefixed with 'autumn_' are reserved and will be stripped.
     */
    metadata?: {
        [k: string]: string;
    } | undefined;
    /**
     * If true, skips any billing changes for the attach operation.
     */
    noBillingChanges?: boolean | undefined;
    /**
     * If true, the customer's plan is activated immediately even when payment is deferred (invoice mode) or pending (Stripe checkout). For Stripe checkout, the customer_product is inserted before the customer completes the hosted form.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * Stripe tax rate ID (txr_...) to apply as the default tax rate on the created subscription, invoice, or checkout session line items.
     */
    taxRateId?: string | undefined;
};
/**
 * Invoice details if an invoice was created. Only present when a charge was made.
 */
type AttachInvoice = {
    /**
     * The status of the invoice (e.g., 'paid', 'open', 'draft').
     */
    status: string | null;
    /**
     * The Stripe invoice ID.
     */
    stripeId: string;
    /**
     * The total amount of the invoice in cents.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * URL to the hosted invoice page where the customer can view and pay the invoice.
     */
    hostedInvoiceUrl: string | null;
};
/**
 * The type of action required to complete the payment.
 */
declare const AttachCode: {
    readonly ThreedsRequired: "3ds_required";
    readonly PaymentMethodRequired: "payment_method_required";
    readonly PaymentFailed: "payment_failed";
    readonly PaymentProcessing: "payment_processing";
};
/**
 * The type of action required to complete the payment.
 */
type AttachCode = OpenEnum<typeof AttachCode>;
/**
 * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
 */
type AttachRequiredAction = {
    /**
     * The type of action required to complete the payment.
     */
    code: AttachCode;
    /**
     * A human-readable explanation of why this action is required.
     */
    reason: string;
};
/**
 * OK
 */
type AttachResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the entity, if the plan was attached to an entity.
     */
    entityId?: string | undefined;
    /**
     * Invoice details if an invoice was created. Only present when a charge was made.
     */
    invoice?: AttachInvoice | undefined;
    /**
     * URL to redirect the customer to complete payment. Null if no payment action is required.
     */
    paymentUrl: string | null;
    /**
     * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
     */
    requiredAction?: AttachRequiredAction | undefined;
};
/** @internal */
type AttachFeatureQuantity$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const AttachFeatureQuantity$outboundSchema: z$1.ZodMiniType<AttachFeatureQuantity$Outbound, AttachFeatureQuantity>;
declare function attachFeatureQuantityToJSON(attachFeatureQuantity: AttachFeatureQuantity): string;
/** @internal */
declare const AttachPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof AttachPriceInterval>;
/** @internal */
type AttachBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const AttachBasePrice$outboundSchema: z$1.ZodMiniType<AttachBasePrice$Outbound, AttachBasePrice>;
declare function attachBasePriceToJSON(attachBasePrice: AttachBasePrice): string;
/** @internal */
declare const AttachItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof AttachItemResetInterval>;
/** @internal */
type AttachItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const AttachItemReset$outboundSchema: z$1.ZodMiniType<AttachItemReset$Outbound, AttachItemReset>;
declare function attachItemResetToJSON(attachItemReset: AttachItemReset): string;
/** @internal */
type AttachItemTo$Outbound = number | string;
/** @internal */
declare const AttachItemTo$outboundSchema: z$1.ZodMiniType<AttachItemTo$Outbound, AttachItemTo>;
declare function attachItemToToJSON(attachItemTo: AttachItemTo): string;
/** @internal */
type AttachItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const AttachItemTier$outboundSchema: z$1.ZodMiniType<AttachItemTier$Outbound, AttachItemTier>;
declare function attachItemTierToJSON(attachItemTier: AttachItemTier): string;
/** @internal */
declare const AttachItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof AttachItemTierBehavior>;
/** @internal */
declare const AttachItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof AttachItemPriceInterval>;
/** @internal */
declare const AttachItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof AttachItemBillingMethod>;
/** @internal */
type AttachItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<AttachItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const AttachItemPrice$outboundSchema: z$1.ZodMiniType<AttachItemPrice$Outbound, AttachItemPrice>;
declare function attachItemPriceToJSON(attachItemPrice: AttachItemPrice): string;
/** @internal */
declare const AttachItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof AttachItemOnIncrease>;
/** @internal */
declare const AttachItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof AttachItemOnDecrease>;
/** @internal */
type AttachItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const AttachItemProration$outboundSchema: z$1.ZodMiniType<AttachItemProration$Outbound, AttachItemProration>;
declare function attachItemProrationToJSON(attachItemProration: AttachItemProration): string;
/** @internal */
declare const AttachItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof AttachItemExpiryDurationType>;
/** @internal */
type AttachItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const AttachItemRollover$outboundSchema: z$1.ZodMiniType<AttachItemRollover$Outbound, AttachItemRollover>;
declare function attachItemRolloverToJSON(attachItemRollover: AttachItemRollover): string;
/** @internal */
type AttachItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: AttachItemReset$Outbound | undefined;
    price?: AttachItemPrice$Outbound | undefined;
    proration?: AttachItemProration$Outbound | undefined;
    rollover?: AttachItemRollover$Outbound | undefined;
};
/** @internal */
declare const AttachItemPlanItem$outboundSchema: z$1.ZodMiniType<AttachItemPlanItem$Outbound, AttachItemPlanItem>;
declare function attachItemPlanItemToJSON(attachItemPlanItem: AttachItemPlanItem): string;
/** @internal */
declare const AttachAddItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof AttachAddItemResetInterval>;
/** @internal */
type AttachAddItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const AttachAddItemReset$outboundSchema: z$1.ZodMiniType<AttachAddItemReset$Outbound, AttachAddItemReset>;
declare function attachAddItemResetToJSON(attachAddItemReset: AttachAddItemReset): string;
/** @internal */
type AttachAddItemTo$Outbound = number | string;
/** @internal */
declare const AttachAddItemTo$outboundSchema: z$1.ZodMiniType<AttachAddItemTo$Outbound, AttachAddItemTo>;
declare function attachAddItemToToJSON(attachAddItemTo: AttachAddItemTo): string;
/** @internal */
type AttachAddItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const AttachAddItemTier$outboundSchema: z$1.ZodMiniType<AttachAddItemTier$Outbound, AttachAddItemTier>;
declare function attachAddItemTierToJSON(attachAddItemTier: AttachAddItemTier): string;
/** @internal */
declare const AttachAddItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof AttachAddItemTierBehavior>;
/** @internal */
declare const AttachAddItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof AttachAddItemPriceInterval>;
/** @internal */
declare const AttachAddItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof AttachAddItemBillingMethod>;
/** @internal */
type AttachAddItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<AttachAddItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const AttachAddItemPrice$outboundSchema: z$1.ZodMiniType<AttachAddItemPrice$Outbound, AttachAddItemPrice>;
declare function attachAddItemPriceToJSON(attachAddItemPrice: AttachAddItemPrice): string;
/** @internal */
declare const AttachAddItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof AttachAddItemOnIncrease>;
/** @internal */
declare const AttachAddItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof AttachAddItemOnDecrease>;
/** @internal */
type AttachAddItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const AttachAddItemProration$outboundSchema: z$1.ZodMiniType<AttachAddItemProration$Outbound, AttachAddItemProration>;
declare function attachAddItemProrationToJSON(attachAddItemProration: AttachAddItemProration): string;
/** @internal */
declare const AttachAddItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof AttachAddItemExpiryDurationType>;
/** @internal */
type AttachAddItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const AttachAddItemRollover$outboundSchema: z$1.ZodMiniType<AttachAddItemRollover$Outbound, AttachAddItemRollover>;
declare function attachAddItemRolloverToJSON(attachAddItemRollover: AttachAddItemRollover): string;
/** @internal */
type AttachAddItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: AttachAddItemReset$Outbound | undefined;
    price?: AttachAddItemPrice$Outbound | undefined;
    proration?: AttachAddItemProration$Outbound | undefined;
    rollover?: AttachAddItemRollover$Outbound | undefined;
};
/** @internal */
declare const AttachAddItemPlanItem$outboundSchema: z$1.ZodMiniType<AttachAddItemPlanItem$Outbound, AttachAddItemPlanItem>;
declare function attachAddItemPlanItemToJSON(attachAddItemPlanItem: AttachAddItemPlanItem): string;
/** @internal */
declare const AttachRemoveItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof AttachRemoveItemBillingMethod>;
/** @internal */
declare const AttachIntervalRemoveItemEnum2$outboundSchema: z$1.ZodMiniEnum<typeof AttachIntervalRemoveItemEnum2>;
/** @internal */
declare const AttachIntervalRemoveItemEnum1$outboundSchema: z$1.ZodMiniEnum<typeof AttachIntervalRemoveItemEnum1>;
/** @internal */
type AttachIntervalUnion$Outbound = string | string;
/** @internal */
declare const AttachIntervalUnion$outboundSchema: z$1.ZodMiniType<AttachIntervalUnion$Outbound, AttachIntervalUnion>;
declare function attachIntervalUnionToJSON(attachIntervalUnion: AttachIntervalUnion): string;
/** @internal */
type AttachPlanItemFilter$Outbound = {
    feature_id?: string | undefined;
    billing_method?: string | undefined;
    interval?: string | string | undefined;
    interval_count?: number | undefined;
};
/** @internal */
declare const AttachPlanItemFilter$outboundSchema: z$1.ZodMiniType<AttachPlanItemFilter$Outbound, AttachPlanItemFilter>;
declare function attachPlanItemFilterToJSON(attachPlanItemFilter: AttachPlanItemFilter): string;
/** @internal */
declare const AttachDurationType$outboundSchema: z$1.ZodMiniEnum<typeof AttachDurationType>;
/** @internal */
declare const AttachOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof AttachOnEnd>;
/** @internal */
type AttachFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const AttachFreeTrialParams$outboundSchema: z$1.ZodMiniType<AttachFreeTrialParams$Outbound, AttachFreeTrialParams>;
declare function attachFreeTrialParamsToJSON(attachFreeTrialParams: AttachFreeTrialParams): string;
/** @internal */
declare const AttachPurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof AttachPurchaseLimitInterval>;
/** @internal */
type AttachPurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const AttachPurchaseLimit$outboundSchema: z$1.ZodMiniType<AttachPurchaseLimit$Outbound, AttachPurchaseLimit>;
declare function attachPurchaseLimitToJSON(attachPurchaseLimit: AttachPurchaseLimit): string;
/** @internal */
type AttachAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: AttachPurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const AttachAutoTopup$outboundSchema: z$1.ZodMiniType<AttachAutoTopup$Outbound, AttachAutoTopup>;
declare function attachAutoTopupToJSON(attachAutoTopup: AttachAutoTopup): string;
/** @internal */
declare const AttachLimitType$outboundSchema: z$1.ZodMiniEnum<typeof AttachLimitType>;
/** @internal */
type AttachSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const AttachSpendLimit$outboundSchema: z$1.ZodMiniType<AttachSpendLimit$Outbound, AttachSpendLimit>;
declare function attachSpendLimitToJSON(attachSpendLimit: AttachSpendLimit): string;
/** @internal */
declare const AttachUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof AttachUsageLimitInterval>;
/** @internal */
type AttachProperties$Outbound = string | number | boolean;
/** @internal */
declare const AttachProperties$outboundSchema: z$1.ZodMiniType<AttachProperties$Outbound, AttachProperties>;
declare function attachPropertiesToJSON(attachProperties: AttachProperties): string;
/** @internal */
type AttachFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const AttachFilter$outboundSchema: z$1.ZodMiniType<AttachFilter$Outbound, AttachFilter>;
declare function attachFilterToJSON(attachFilter: AttachFilter): string;
/** @internal */
type AttachUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: AttachFilter$Outbound | undefined;
};
/** @internal */
declare const AttachUsageLimit$outboundSchema: z$1.ZodMiniType<AttachUsageLimit$Outbound, AttachUsageLimit>;
declare function attachUsageLimitToJSON(attachUsageLimit: AttachUsageLimit): string;
/** @internal */
declare const AttachThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof AttachThresholdType>;
/** @internal */
type AttachUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const AttachUsageAlert$outboundSchema: z$1.ZodMiniType<AttachUsageAlert$Outbound, AttachUsageAlert>;
declare function attachUsageAlertToJSON(attachUsageAlert: AttachUsageAlert): string;
/** @internal */
type AttachOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const AttachOverageAllowed$outboundSchema: z$1.ZodMiniType<AttachOverageAllowed$Outbound, AttachOverageAllowed>;
declare function attachOverageAllowedToJSON(attachOverageAllowed: AttachOverageAllowed): string;
/** @internal */
type AttachBillingControls$Outbound = {
    auto_topups?: Array<AttachAutoTopup$Outbound> | undefined;
    spend_limits?: Array<AttachSpendLimit$Outbound> | undefined;
    usage_limits?: Array<AttachUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<AttachUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<AttachOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const AttachBillingControls$outboundSchema: z$1.ZodMiniType<AttachBillingControls$Outbound, AttachBillingControls>;
declare function attachBillingControlsToJSON(attachBillingControls: AttachBillingControls): string;
/** @internal */
type AttachCustomize$Outbound = {
    price?: AttachBasePrice$Outbound | null | undefined;
    items?: Array<AttachItemPlanItem$Outbound> | undefined;
    add_items?: Array<AttachAddItemPlanItem$Outbound> | undefined;
    remove_items?: Array<AttachPlanItemFilter$Outbound> | undefined;
    free_trial?: AttachFreeTrialParams$Outbound | null | undefined;
    billing_controls?: AttachBillingControls$Outbound | undefined;
};
/** @internal */
declare const AttachCustomize$outboundSchema: z$1.ZodMiniType<AttachCustomize$Outbound, AttachCustomize>;
declare function attachCustomizeToJSON(attachCustomize: AttachCustomize): string;
/** @internal */
type AttachInvoiceMode$Outbound = {
    enabled: boolean;
    enable_plan_immediately: boolean;
    finalize: boolean;
    invoice_template_id?: string | undefined;
    net_terms_days?: number | undefined;
};
/** @internal */
declare const AttachInvoiceMode$outboundSchema: z$1.ZodMiniType<AttachInvoiceMode$Outbound, AttachInvoiceMode>;
declare function attachInvoiceModeToJSON(attachInvoiceMode: AttachInvoiceMode): string;
/** @internal */
declare const AttachProrationBehavior$outboundSchema: z$1.ZodMiniEnum<typeof AttachProrationBehavior>;
/** @internal */
declare const AttachRedirectMode$outboundSchema: z$1.ZodMiniEnum<typeof AttachRedirectMode>;
/** @internal */
type AttachAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const AttachAttachDiscount$outboundSchema: z$1.ZodMiniType<AttachAttachDiscount$Outbound, AttachAttachDiscount>;
declare function attachAttachDiscountToJSON(attachAttachDiscount: AttachAttachDiscount): string;
/** @internal */
declare const AttachPlanSchedule$outboundSchema: z$1.ZodMiniEnum<typeof AttachPlanSchedule>;
/** @internal */
type AttachCustomLineItem$Outbound = {
    amount: number;
    description: string;
};
/** @internal */
declare const AttachCustomLineItem$outboundSchema: z$1.ZodMiniType<AttachCustomLineItem$Outbound, AttachCustomLineItem>;
declare function attachCustomLineItemToJSON(attachCustomLineItem: AttachCustomLineItem): string;
/** @internal */
type AttachCarryOverBalances$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const AttachCarryOverBalances$outboundSchema: z$1.ZodMiniType<AttachCarryOverBalances$Outbound, AttachCarryOverBalances>;
declare function attachCarryOverBalancesToJSON(attachCarryOverBalances: AttachCarryOverBalances): string;
/** @internal */
type AttachCarryOverUsages$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const AttachCarryOverUsages$outboundSchema: z$1.ZodMiniType<AttachCarryOverUsages$Outbound, AttachCarryOverUsages>;
declare function attachCarryOverUsagesToJSON(attachCarryOverUsages: AttachCarryOverUsages): string;
/** @internal */
type AttachParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    plan_id: string;
    feature_quantities?: Array<AttachFeatureQuantity$Outbound> | undefined;
    version?: number | undefined;
    customize?: AttachCustomize$Outbound | undefined;
    invoice_mode?: AttachInvoiceMode$Outbound | undefined;
    proration_behavior?: string | undefined;
    redirect_mode: string;
    subscription_id?: string | undefined;
    discounts?: Array<AttachAttachDiscount$Outbound> | undefined;
    success_url?: string | undefined;
    new_billing_subscription?: boolean | undefined;
    billing_cycle_anchor?: "now" | undefined;
    plan_schedule?: string | undefined;
    starts_at?: number | undefined;
    ends_at?: number | undefined;
    checkout_session_params?: {
        [k: string]: any;
    } | undefined;
    long_lived_checkout?: boolean | undefined;
    custom_line_items?: Array<AttachCustomLineItem$Outbound> | undefined;
    processor_subscription_id?: string | undefined;
    carry_over_balances?: AttachCarryOverBalances$Outbound | undefined;
    carry_over_usages?: AttachCarryOverUsages$Outbound | undefined;
    metadata?: {
        [k: string]: string;
    } | undefined;
    no_billing_changes?: boolean | undefined;
    enable_plan_immediately?: boolean | undefined;
    tax_rate_id?: string | undefined;
};
/** @internal */
declare const AttachParams$outboundSchema: z$1.ZodMiniType<AttachParams$Outbound, AttachParams>;
declare function attachParamsToJSON(attachParams: AttachParams): string;
/** @internal */
declare const AttachInvoice$inboundSchema: z$1.ZodMiniType<AttachInvoice, unknown>;
declare function attachInvoiceFromJSON(jsonString: string): Result$1<AttachInvoice, SDKValidationError>;
/** @internal */
declare const AttachCode$inboundSchema: z$1.ZodMiniType<AttachCode, unknown>;
/** @internal */
declare const AttachRequiredAction$inboundSchema: z$1.ZodMiniType<AttachRequiredAction, unknown>;
declare function attachRequiredActionFromJSON(jsonString: string): Result$1<AttachRequiredAction, SDKValidationError>;
/** @internal */
declare const AttachResponse$inboundSchema: z$1.ZodMiniType<AttachResponse, unknown>;
declare function attachResponseFromJSON(jsonString: string): Result$1<AttachResponse, SDKValidationError>;

/** The base class for all HTTP error responses */
declare class AutumnError extends Error {
    /** HTTP status code */
    readonly statusCode: number;
    /** HTTP body */
    readonly body: string;
    /** HTTP headers */
    readonly headers: Headers;
    /** HTTP content type */
    readonly contentType: string;
    /** Raw response */
    readonly rawResponse: Response;
    constructor(message: string, httpMeta: {
        response: Response;
        request: Request;
        body: string;
    });
}

/** The fallback error class if no more specific error class is matched */
declare class AutumnDefaultError extends AutumnError {
    constructor(message: string, httpMeta: {
        response: Response;
        request: Request;
        body: string;
    });
}

/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const BalanceType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type BalanceType = OpenEnum<typeof BalanceType>;
type BalanceCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type BalanceModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type BalanceProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type BalanceDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type BalanceFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: BalanceType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<BalanceCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: BalanceModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: BalanceProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: BalanceDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
declare const BalanceIntervalEnum: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type BalanceIntervalEnum = OpenEnum<typeof BalanceIntervalEnum>;
/**
 * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
 */
type BalanceIntervalUnion = BalanceIntervalEnum | string;
type BalanceReset = {
    /**
     * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
     */
    interval: BalanceIntervalEnum | string;
    /**
     * Number of intervals between resets (eg. 2 for bi-monthly).
     */
    intervalCount?: number | undefined;
    /**
     * Timestamp when the balance will next reset.
     */
    resetsAt: number | null;
};
type BalanceTo = number | string;
type BalanceTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
/**
 * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier).
 */
declare const BalanceTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
/**
 * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier).
 */
type BalanceTierBehavior = OpenEnum<typeof BalanceTierBehavior>;
/**
 * Whether usage is prepaid or billed pay-per-use.
 */
declare const BalanceBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Whether usage is prepaid or billed pay-per-use.
 */
type BalanceBillingMethod = OpenEnum<typeof BalanceBillingMethod>;
type BalancePrice = {
    /**
     * The per-unit price amount.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing configuration if applicable.
     */
    tiers?: Array<BalanceTier> | undefined;
    /**
     * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier).
     */
    tierBehavior?: BalanceTierBehavior | undefined;
    /**
     * The number of units per billing increment (eg. $9 / 250 units).
     */
    billingUnits: number;
    /**
     * Whether usage is prepaid or billed pay-per-use.
     */
    billingMethod: BalanceBillingMethod;
    /**
     * Maximum quantity that can be purchased, or null for unlimited.
     */
    maxPurchase: number | null;
};
type Breakdown = {
    /**
     * The unique identifier for this balance breakdown.
     */
    id: string;
    /**
     * The plan ID this balance originates from, or null for standalone balances.
     */
    planId: string | null;
    /**
     * Amount granted from the plan's included usage.
     */
    includedGrant: number;
    /**
     * Amount granted from prepaid purchases or top-ups.
     */
    prepaidGrant: number;
    /**
     * Remaining balance available for use.
     */
    remaining: number;
    /**
     * Amount consumed in the current period.
     */
    usage: number;
    /**
     * Whether this balance has unlimited usage.
     */
    unlimited: boolean;
    /**
     * Reset configuration for this balance, or null if no reset.
     */
    reset: BalanceReset | null;
    /**
     * Pricing configuration if this balance has usage-based pricing.
     */
    price: BalancePrice | null;
    /**
     * Timestamp when this balance expires, or null for no expiration.
     */
    expiresAt: number | null;
};
type BalanceRollover = {
    /**
     * Amount of balance rolled over from a previous period.
     */
    balance: number;
    /**
     * Timestamp when the rollover balance expires.
     */
    expiresAt: number;
};
type Balance = {
    /**
     * The feature ID this balance is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: BalanceFeature | undefined;
    /**
     * Total balance granted (included + prepaid).
     */
    granted: number;
    /**
     * Remaining balance available for use.
     */
    remaining: number;
    /**
     * Total usage consumed in the current period.
     */
    usage: number;
    /**
     * Whether this feature has unlimited usage.
     */
    unlimited: boolean;
    /**
     * Whether usage beyond the granted balance is allowed (with overage charges).
     */
    overageAllowed: boolean;
    /**
     * Maximum quantity that can be purchased as a top-up, or null for unlimited.
     */
    maxPurchase: number | null;
    /**
     * Timestamp when the balance will reset, or null for no reset.
     */
    nextResetAt: number | null;
    /**
     * Detailed breakdown of balance sources when stacking multiple plans or grants.
     */
    breakdown?: Array<Breakdown> | undefined;
    /**
     * Rollover balances carried over from previous periods.
     */
    rollovers?: Array<BalanceRollover> | undefined;
};
/** @internal */
declare const BalanceType$inboundSchema: z$1.ZodMiniType<BalanceType, unknown>;
/** @internal */
declare const BalanceCreditSchema$inboundSchema: z$1.ZodMiniType<BalanceCreditSchema, unknown>;
declare function balanceCreditSchemaFromJSON(jsonString: string): Result$1<BalanceCreditSchema, SDKValidationError>;
/** @internal */
declare const BalanceModelMarkups$inboundSchema: z$1.ZodMiniType<BalanceModelMarkups, unknown>;
declare function balanceModelMarkupsFromJSON(jsonString: string): Result$1<BalanceModelMarkups, SDKValidationError>;
/** @internal */
declare const BalanceProviderMarkups$inboundSchema: z$1.ZodMiniType<BalanceProviderMarkups, unknown>;
declare function balanceProviderMarkupsFromJSON(jsonString: string): Result$1<BalanceProviderMarkups, SDKValidationError>;
/** @internal */
declare const BalanceDisplay$inboundSchema: z$1.ZodMiniType<BalanceDisplay, unknown>;
declare function balanceDisplayFromJSON(jsonString: string): Result$1<BalanceDisplay, SDKValidationError>;
/** @internal */
declare const BalanceFeature$inboundSchema: z$1.ZodMiniType<BalanceFeature, unknown>;
declare function balanceFeatureFromJSON(jsonString: string): Result$1<BalanceFeature, SDKValidationError>;
/** @internal */
declare const BalanceIntervalEnum$inboundSchema: z$1.ZodMiniType<BalanceIntervalEnum, unknown>;
/** @internal */
declare const BalanceIntervalUnion$inboundSchema: z$1.ZodMiniType<BalanceIntervalUnion, unknown>;
declare function balanceIntervalUnionFromJSON(jsonString: string): Result$1<BalanceIntervalUnion, SDKValidationError>;
/** @internal */
declare const BalanceReset$inboundSchema: z$1.ZodMiniType<BalanceReset, unknown>;
declare function balanceResetFromJSON(jsonString: string): Result$1<BalanceReset, SDKValidationError>;
/** @internal */
declare const BalanceTo$inboundSchema: z$1.ZodMiniType<BalanceTo, unknown>;
declare function balanceToFromJSON(jsonString: string): Result$1<BalanceTo, SDKValidationError>;
/** @internal */
declare const BalanceTier$inboundSchema: z$1.ZodMiniType<BalanceTier, unknown>;
declare function balanceTierFromJSON(jsonString: string): Result$1<BalanceTier, SDKValidationError>;
/** @internal */
declare const BalanceTierBehavior$inboundSchema: z$1.ZodMiniType<BalanceTierBehavior, unknown>;
/** @internal */
declare const BalanceBillingMethod$inboundSchema: z$1.ZodMiniType<BalanceBillingMethod, unknown>;
/** @internal */
declare const BalancePrice$inboundSchema: z$1.ZodMiniType<BalancePrice, unknown>;
declare function balancePriceFromJSON(jsonString: string): Result$1<BalancePrice, SDKValidationError>;
/** @internal */
declare const Breakdown$inboundSchema: z$1.ZodMiniType<Breakdown, unknown>;
declare function breakdownFromJSON(jsonString: string): Result$1<Breakdown, SDKValidationError>;
/** @internal */
declare const BalanceRollover$inboundSchema: z$1.ZodMiniType<BalanceRollover, unknown>;
declare function balanceRolloverFromJSON(jsonString: string): Result$1<BalanceRollover, SDKValidationError>;
/** @internal */
declare const Balance$inboundSchema: z$1.ZodMiniType<Balance, unknown>;
declare function balanceFromJSON(jsonString: string): Result$1<Balance, SDKValidationError>;

type BatchTrackGlobals = {
    xApiVersion?: string | undefined;
};
type BatchTrackLock = {
    /**
     * A unique identifier for this lock. Used to finalize the lock later via balances.finalize.
     */
    lockId: string;
    /**
     * Must be true to enable locking.
     */
    enabled: true;
    /**
     * Unix timestamp (ms) when the lock automatically expires and releases the held balance.
     */
    expiresAt?: number | undefined;
};
type RequestBody = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the feature to track usage for. Required if event_name is not provided.
     */
    featureId?: string | undefined;
    /**
     * The ID of the entity for entity-scoped balances (e.g., per-seat limits).
     */
    entityId?: string | undefined;
    /**
     * Event name to track usage for. Use instead of feature_id when multiple features should be tracked from a single event.
     */
    eventName?: string | undefined;
    /**
     * The amount of usage to record. Defaults to 1. Use negative values to credit balance (e.g., when removing a seat).
     */
    value?: number | undefined;
    /**
     * Additional properties to attach to this usage event.
     */
    properties?: {
        [k: string]: any;
    } | undefined;
    /**
     * Unix timestamp in milliseconds to use for the usage event. Defaults to the current time.
     */
    timestamp?: number | undefined;
    /**
     * If true, enqueue the event for asynchronous processing and return 204 immediately. The response will not include balance information.
     */
    async?: boolean | undefined;
    lock?: BatchTrackLock | undefined;
};
/**
 * Batch accepted. All items passed synchronous validation. Enqueue is best-effort: partial failures (some items enqueued, some not) are logged server-side and are NOT surfaced in the response body; clients must not retry on 202. See the endpoint description for full partial-failure semantics.
 */
type BatchTrackResponse = {
    success: true;
};
/** @internal */
type BatchTrackLock$Outbound = {
    lock_id: string;
    enabled: true;
    expires_at?: number | undefined;
};
/** @internal */
declare const BatchTrackLock$outboundSchema: z$1.ZodMiniType<BatchTrackLock$Outbound, BatchTrackLock>;
declare function batchTrackLockToJSON(batchTrackLock: BatchTrackLock): string;
/** @internal */
type RequestBody$Outbound = {
    customer_id: string;
    feature_id?: string | undefined;
    entity_id?: string | undefined;
    event_name?: string | undefined;
    value?: number | undefined;
    properties?: {
        [k: string]: any;
    } | undefined;
    timestamp?: number | undefined;
    async?: boolean | undefined;
    lock?: BatchTrackLock$Outbound | undefined;
};
/** @internal */
declare const RequestBody$outboundSchema: z$1.ZodMiniType<RequestBody$Outbound, RequestBody>;
declare function requestBodyToJSON(requestBody: RequestBody): string;
/** @internal */
declare const BatchTrackResponse$inboundSchema: z$1.ZodMiniType<BatchTrackResponse, unknown>;
declare function batchTrackResponseFromJSON(jsonString: string): Result$1<BatchTrackResponse, SDKValidationError>;

type BillingUpdateGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type BillingUpdateFeatureQuantity = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const BillingUpdatePriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type BillingUpdatePriceInterval = ClosedEnum<typeof BillingUpdatePriceInterval>;
/**
 * Base price configuration for a plan.
 */
type BillingUpdateBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: BillingUpdatePriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const BillingUpdateItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type BillingUpdateItemResetInterval = ClosedEnum<typeof BillingUpdateItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type BillingUpdateItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: BillingUpdateItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type BillingUpdateItemTo = number | string;
type BillingUpdateItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const BillingUpdateItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type BillingUpdateItemTierBehavior = ClosedEnum<typeof BillingUpdateItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const BillingUpdateItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type BillingUpdateItemPriceInterval = ClosedEnum<typeof BillingUpdateItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const BillingUpdateItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type BillingUpdateItemBillingMethod = ClosedEnum<typeof BillingUpdateItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type BillingUpdateItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<BillingUpdateItemTier> | undefined;
    tierBehavior?: BillingUpdateItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: BillingUpdateItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: BillingUpdateItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const BillingUpdateItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type BillingUpdateItemOnIncrease = ClosedEnum<typeof BillingUpdateItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const BillingUpdateItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type BillingUpdateItemOnDecrease = ClosedEnum<typeof BillingUpdateItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type BillingUpdateItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: BillingUpdateItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: BillingUpdateItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const BillingUpdateItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type BillingUpdateItemExpiryDurationType = ClosedEnum<typeof BillingUpdateItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type BillingUpdateItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: BillingUpdateItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type BillingUpdateItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: BillingUpdateItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: BillingUpdateItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: BillingUpdateItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: BillingUpdateItemRollover | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const BillingUpdateAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type BillingUpdateAddItemResetInterval = ClosedEnum<typeof BillingUpdateAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type BillingUpdateAddItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: BillingUpdateAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type BillingUpdateAddItemTo = number | string;
type BillingUpdateAddItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const BillingUpdateAddItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type BillingUpdateAddItemTierBehavior = ClosedEnum<typeof BillingUpdateAddItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const BillingUpdateAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type BillingUpdateAddItemPriceInterval = ClosedEnum<typeof BillingUpdateAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const BillingUpdateAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type BillingUpdateAddItemBillingMethod = ClosedEnum<typeof BillingUpdateAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type BillingUpdateAddItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<BillingUpdateAddItemTier> | undefined;
    tierBehavior?: BillingUpdateAddItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: BillingUpdateAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: BillingUpdateAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const BillingUpdateAddItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type BillingUpdateAddItemOnIncrease = ClosedEnum<typeof BillingUpdateAddItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const BillingUpdateAddItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type BillingUpdateAddItemOnDecrease = ClosedEnum<typeof BillingUpdateAddItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type BillingUpdateAddItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: BillingUpdateAddItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: BillingUpdateAddItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const BillingUpdateAddItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type BillingUpdateAddItemExpiryDurationType = ClosedEnum<typeof BillingUpdateAddItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type BillingUpdateAddItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: BillingUpdateAddItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type BillingUpdateAddItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: BillingUpdateAddItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: BillingUpdateAddItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: BillingUpdateAddItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: BillingUpdateAddItemRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const BillingUpdateRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type BillingUpdateRemoveItemBillingMethod = ClosedEnum<typeof BillingUpdateRemoveItemBillingMethod>;
declare const BillingUpdateIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type BillingUpdateIntervalRemoveItemEnum2 = ClosedEnum<typeof BillingUpdateIntervalRemoveItemEnum2>;
declare const BillingUpdateIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type BillingUpdateIntervalRemoveItemEnum1 = ClosedEnum<typeof BillingUpdateIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type BillingUpdateIntervalUnion = BillingUpdateIntervalRemoveItemEnum1 | BillingUpdateIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type BillingUpdatePlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: BillingUpdateRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: BillingUpdateIntervalRemoveItemEnum1 | BillingUpdateIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const BillingUpdateDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type BillingUpdateDurationType = ClosedEnum<typeof BillingUpdateDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const BillingUpdateOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type BillingUpdateOnEnd = ClosedEnum<typeof BillingUpdateOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type BillingUpdateFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: BillingUpdateDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: BillingUpdateOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const BillingUpdatePurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type BillingUpdatePurchaseLimitInterval = ClosedEnum<typeof BillingUpdatePurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type BillingUpdatePurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: BillingUpdatePurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type BillingUpdateAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: BillingUpdatePurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const BillingUpdateLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type BillingUpdateLimitType = ClosedEnum<typeof BillingUpdateLimitType>;
type BillingUpdateSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: BillingUpdateLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const BillingUpdateUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type BillingUpdateUsageLimitInterval = ClosedEnum<typeof BillingUpdateUsageLimitInterval>;
type BillingUpdateProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type BillingUpdateFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type BillingUpdateUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: BillingUpdateUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: BillingUpdateFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const BillingUpdateThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type BillingUpdateThresholdType = ClosedEnum<typeof BillingUpdateThresholdType>;
type BillingUpdateUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: BillingUpdateThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type BillingUpdateOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type BillingUpdateBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<BillingUpdateAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<BillingUpdateSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<BillingUpdateUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<BillingUpdateUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<BillingUpdateOverageAllowed> | undefined;
};
/**
 * Customize the plan to attach. Can override the price, items, free trial, or a combination.
 */
type BillingUpdateCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: BillingUpdateBasePrice | null | undefined;
    /**
     * Override the items in the plan (PUT-style — replaces all existing items). Mutually exclusive with add_items / remove_items / deprecated update_items.
     */
    items?: Array<BillingUpdateItemPlanItem> | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<BillingUpdateAddItemPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<BillingUpdatePlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: BillingUpdateFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: BillingUpdateBillingControls | undefined;
};
/**
 * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
 */
type BillingUpdateInvoiceMode = {
    /**
     * When true, creates an invoice and sends it to the customer instead of charging their card immediately. Uses Stripe's send_invoice collection method.
     */
    enabled: boolean;
    /**
     * If true, enables the plan immediately even though the invoice is not paid yet.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * If true, finalizes the invoice so it can be sent to the customer. If false, keeps it as a draft for manual review.
     */
    finalize?: boolean | undefined;
    /**
     * ID of an invoice template (configured in billing settings) whose footer (e.g. bank details) is applied to the invoice.
     */
    invoiceTemplateId?: string | undefined;
    /**
     * Number of days the customer has to pay the invoice before it is due (Stripe days_until_due).
     */
    netTermsDays?: number | undefined;
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
declare const BillingUpdateProrationBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
type BillingUpdateProrationBehavior = ClosedEnum<typeof BillingUpdateProrationBehavior>;
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
declare const BillingUpdateRedirectMode: {
    readonly Always: "always";
    readonly IfRequired: "if_required";
    readonly Never: "never";
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
type BillingUpdateRedirectMode = ClosedEnum<typeof BillingUpdateRedirectMode>;
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type BillingUpdateAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
declare const BillingUpdateCancelAction: {
    readonly CancelImmediately: "cancel_immediately";
    readonly CancelEndOfCycle: "cancel_end_of_cycle";
    readonly Uncancel: "uncancel";
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
type BillingUpdateCancelAction = ClosedEnum<typeof BillingUpdateCancelAction>;
/**
 * Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment.
 */
declare const BillingUpdateRefundLastPayment: {
    readonly Prorated: "prorated";
    readonly Full: "full";
};
/**
 * Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment.
 */
type BillingUpdateRefundLastPayment = ClosedEnum<typeof BillingUpdateRefundLastPayment>;
/**
 * Controls whether balances should be recalculated during the subscription update.
 */
type BillingUpdateRecalculateBalances = {
    /**
     * If true, recalculates balances during the subscription update. Only applicable when updating feature quantities.
     */
    enabled: boolean;
};
/**
 * Whether to carry over usages from the previous plan.
 */
type BillingUpdateCarryOverUsages = {
    /**
     * Whether to carry over usages from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over usages for. If left undefined, all consumable features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
type UpdateSubscriptionParams = {
    /**
     * The ID of the customer to attach the plan to.
     */
    customerId: string;
    /**
     * The ID of the entity to attach the plan to.
     */
    entityId?: string | undefined;
    /**
     * The ID of the plan to update. Optional if subscription_id is provided, or if the customer has only one product.
     */
    planId?: string | undefined;
    /**
     * If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan.
     */
    featureQuantities?: Array<BillingUpdateFeatureQuantity> | undefined;
    /**
     * The version of the plan to attach.
     */
    version?: number | undefined;
    /**
     * Customize the plan to attach. Can override the price, items, free trial, or a combination.
     */
    customize?: BillingUpdateCustomize | undefined;
    /**
     * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
     */
    invoiceMode?: BillingUpdateInvoiceMode | undefined;
    /**
     * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
     */
    prorationBehavior?: BillingUpdateProrationBehavior | undefined;
    /**
     * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
     */
    redirectMode?: BillingUpdateRedirectMode | undefined;
    /**
     * A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan.
     */
    subscriptionId?: string | undefined;
    /**
     * List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<BillingUpdateAttachDiscount> | undefined;
    /**
     * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
     */
    cancelAction?: BillingUpdateCancelAction | undefined;
    /**
     * Reset the billing cycle anchor immediately with 'now'
     */
    billingCycleAnchor?: "now" | undefined;
    /**
     * If true, the subscription is updated internally without applying billing changes in Stripe.
     */
    noBillingChanges?: boolean | undefined;
    /**
     * Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment.
     */
    refundLastPayment?: BillingUpdateRefundLastPayment | undefined;
    /**
     * Controls whether balances should be recalculated during the subscription update.
     */
    recalculateBalances?: BillingUpdateRecalculateBalances | undefined;
    /**
     * Whether to carry over usages from the previous plan.
     */
    carryOverUsages?: BillingUpdateCarryOverUsages | undefined;
};
/**
 * Invoice details if an invoice was created. Only present when a charge was made.
 */
type BillingUpdateInvoice = {
    /**
     * The status of the invoice (e.g., 'paid', 'open', 'draft').
     */
    status: string | null;
    /**
     * The Stripe invoice ID.
     */
    stripeId: string;
    /**
     * The total amount of the invoice in cents.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * URL to the hosted invoice page where the customer can view and pay the invoice.
     */
    hostedInvoiceUrl: string | null;
};
/**
 * The type of action required to complete the payment.
 */
declare const BillingUpdateCode: {
    readonly ThreedsRequired: "3ds_required";
    readonly PaymentMethodRequired: "payment_method_required";
    readonly PaymentFailed: "payment_failed";
    readonly PaymentProcessing: "payment_processing";
};
/**
 * The type of action required to complete the payment.
 */
type BillingUpdateCode = OpenEnum<typeof BillingUpdateCode>;
/**
 * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
 */
type BillingUpdateRequiredAction = {
    /**
     * The type of action required to complete the payment.
     */
    code: BillingUpdateCode;
    /**
     * A human-readable explanation of why this action is required.
     */
    reason: string;
};
/**
 * OK
 */
type BillingUpdateResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the entity, if the plan was attached to an entity.
     */
    entityId?: string | undefined;
    /**
     * Invoice details if an invoice was created. Only present when a charge was made.
     */
    invoice?: BillingUpdateInvoice | undefined;
    /**
     * URL to redirect the customer to complete payment. Null if no payment action is required.
     */
    paymentUrl: string | null;
    /**
     * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
     */
    requiredAction?: BillingUpdateRequiredAction | undefined;
};
/** @internal */
type BillingUpdateFeatureQuantity$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const BillingUpdateFeatureQuantity$outboundSchema: z$1.ZodMiniType<BillingUpdateFeatureQuantity$Outbound, BillingUpdateFeatureQuantity>;
declare function billingUpdateFeatureQuantityToJSON(billingUpdateFeatureQuantity: BillingUpdateFeatureQuantity): string;
/** @internal */
declare const BillingUpdatePriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdatePriceInterval>;
/** @internal */
type BillingUpdateBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const BillingUpdateBasePrice$outboundSchema: z$1.ZodMiniType<BillingUpdateBasePrice$Outbound, BillingUpdateBasePrice>;
declare function billingUpdateBasePriceToJSON(billingUpdateBasePrice: BillingUpdateBasePrice): string;
/** @internal */
declare const BillingUpdateItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateItemResetInterval>;
/** @internal */
type BillingUpdateItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const BillingUpdateItemReset$outboundSchema: z$1.ZodMiniType<BillingUpdateItemReset$Outbound, BillingUpdateItemReset>;
declare function billingUpdateItemResetToJSON(billingUpdateItemReset: BillingUpdateItemReset): string;
/** @internal */
type BillingUpdateItemTo$Outbound = number | string;
/** @internal */
declare const BillingUpdateItemTo$outboundSchema: z$1.ZodMiniType<BillingUpdateItemTo$Outbound, BillingUpdateItemTo>;
declare function billingUpdateItemToToJSON(billingUpdateItemTo: BillingUpdateItemTo): string;
/** @internal */
type BillingUpdateItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const BillingUpdateItemTier$outboundSchema: z$1.ZodMiniType<BillingUpdateItemTier$Outbound, BillingUpdateItemTier>;
declare function billingUpdateItemTierToJSON(billingUpdateItemTier: BillingUpdateItemTier): string;
/** @internal */
declare const BillingUpdateItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateItemTierBehavior>;
/** @internal */
declare const BillingUpdateItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateItemPriceInterval>;
/** @internal */
declare const BillingUpdateItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateItemBillingMethod>;
/** @internal */
type BillingUpdateItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<BillingUpdateItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const BillingUpdateItemPrice$outboundSchema: z$1.ZodMiniType<BillingUpdateItemPrice$Outbound, BillingUpdateItemPrice>;
declare function billingUpdateItemPriceToJSON(billingUpdateItemPrice: BillingUpdateItemPrice): string;
/** @internal */
declare const BillingUpdateItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateItemOnIncrease>;
/** @internal */
declare const BillingUpdateItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateItemOnDecrease>;
/** @internal */
type BillingUpdateItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const BillingUpdateItemProration$outboundSchema: z$1.ZodMiniType<BillingUpdateItemProration$Outbound, BillingUpdateItemProration>;
declare function billingUpdateItemProrationToJSON(billingUpdateItemProration: BillingUpdateItemProration): string;
/** @internal */
declare const BillingUpdateItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateItemExpiryDurationType>;
/** @internal */
type BillingUpdateItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const BillingUpdateItemRollover$outboundSchema: z$1.ZodMiniType<BillingUpdateItemRollover$Outbound, BillingUpdateItemRollover>;
declare function billingUpdateItemRolloverToJSON(billingUpdateItemRollover: BillingUpdateItemRollover): string;
/** @internal */
type BillingUpdateItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: BillingUpdateItemReset$Outbound | undefined;
    price?: BillingUpdateItemPrice$Outbound | undefined;
    proration?: BillingUpdateItemProration$Outbound | undefined;
    rollover?: BillingUpdateItemRollover$Outbound | undefined;
};
/** @internal */
declare const BillingUpdateItemPlanItem$outboundSchema: z$1.ZodMiniType<BillingUpdateItemPlanItem$Outbound, BillingUpdateItemPlanItem>;
declare function billingUpdateItemPlanItemToJSON(billingUpdateItemPlanItem: BillingUpdateItemPlanItem): string;
/** @internal */
declare const BillingUpdateAddItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateAddItemResetInterval>;
/** @internal */
type BillingUpdateAddItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const BillingUpdateAddItemReset$outboundSchema: z$1.ZodMiniType<BillingUpdateAddItemReset$Outbound, BillingUpdateAddItemReset>;
declare function billingUpdateAddItemResetToJSON(billingUpdateAddItemReset: BillingUpdateAddItemReset): string;
/** @internal */
type BillingUpdateAddItemTo$Outbound = number | string;
/** @internal */
declare const BillingUpdateAddItemTo$outboundSchema: z$1.ZodMiniType<BillingUpdateAddItemTo$Outbound, BillingUpdateAddItemTo>;
declare function billingUpdateAddItemToToJSON(billingUpdateAddItemTo: BillingUpdateAddItemTo): string;
/** @internal */
type BillingUpdateAddItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const BillingUpdateAddItemTier$outboundSchema: z$1.ZodMiniType<BillingUpdateAddItemTier$Outbound, BillingUpdateAddItemTier>;
declare function billingUpdateAddItemTierToJSON(billingUpdateAddItemTier: BillingUpdateAddItemTier): string;
/** @internal */
declare const BillingUpdateAddItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateAddItemTierBehavior>;
/** @internal */
declare const BillingUpdateAddItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateAddItemPriceInterval>;
/** @internal */
declare const BillingUpdateAddItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateAddItemBillingMethod>;
/** @internal */
type BillingUpdateAddItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<BillingUpdateAddItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const BillingUpdateAddItemPrice$outboundSchema: z$1.ZodMiniType<BillingUpdateAddItemPrice$Outbound, BillingUpdateAddItemPrice>;
declare function billingUpdateAddItemPriceToJSON(billingUpdateAddItemPrice: BillingUpdateAddItemPrice): string;
/** @internal */
declare const BillingUpdateAddItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateAddItemOnIncrease>;
/** @internal */
declare const BillingUpdateAddItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateAddItemOnDecrease>;
/** @internal */
type BillingUpdateAddItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const BillingUpdateAddItemProration$outboundSchema: z$1.ZodMiniType<BillingUpdateAddItemProration$Outbound, BillingUpdateAddItemProration>;
declare function billingUpdateAddItemProrationToJSON(billingUpdateAddItemProration: BillingUpdateAddItemProration): string;
/** @internal */
declare const BillingUpdateAddItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateAddItemExpiryDurationType>;
/** @internal */
type BillingUpdateAddItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const BillingUpdateAddItemRollover$outboundSchema: z$1.ZodMiniType<BillingUpdateAddItemRollover$Outbound, BillingUpdateAddItemRollover>;
declare function billingUpdateAddItemRolloverToJSON(billingUpdateAddItemRollover: BillingUpdateAddItemRollover): string;
/** @internal */
type BillingUpdateAddItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: BillingUpdateAddItemReset$Outbound | undefined;
    price?: BillingUpdateAddItemPrice$Outbound | undefined;
    proration?: BillingUpdateAddItemProration$Outbound | undefined;
    rollover?: BillingUpdateAddItemRollover$Outbound | undefined;
};
/** @internal */
declare const BillingUpdateAddItemPlanItem$outboundSchema: z$1.ZodMiniType<BillingUpdateAddItemPlanItem$Outbound, BillingUpdateAddItemPlanItem>;
declare function billingUpdateAddItemPlanItemToJSON(billingUpdateAddItemPlanItem: BillingUpdateAddItemPlanItem): string;
/** @internal */
declare const BillingUpdateRemoveItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateRemoveItemBillingMethod>;
/** @internal */
declare const BillingUpdateIntervalRemoveItemEnum2$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateIntervalRemoveItemEnum2>;
/** @internal */
declare const BillingUpdateIntervalRemoveItemEnum1$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateIntervalRemoveItemEnum1>;
/** @internal */
type BillingUpdateIntervalUnion$Outbound = string | string;
/** @internal */
declare const BillingUpdateIntervalUnion$outboundSchema: z$1.ZodMiniType<BillingUpdateIntervalUnion$Outbound, BillingUpdateIntervalUnion>;
declare function billingUpdateIntervalUnionToJSON(billingUpdateIntervalUnion: BillingUpdateIntervalUnion): string;
/** @internal */
type BillingUpdatePlanItemFilter$Outbound = {
    feature_id?: string | undefined;
    billing_method?: string | undefined;
    interval?: string | string | undefined;
    interval_count?: number | undefined;
};
/** @internal */
declare const BillingUpdatePlanItemFilter$outboundSchema: z$1.ZodMiniType<BillingUpdatePlanItemFilter$Outbound, BillingUpdatePlanItemFilter>;
declare function billingUpdatePlanItemFilterToJSON(billingUpdatePlanItemFilter: BillingUpdatePlanItemFilter): string;
/** @internal */
declare const BillingUpdateDurationType$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateDurationType>;
/** @internal */
declare const BillingUpdateOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateOnEnd>;
/** @internal */
type BillingUpdateFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const BillingUpdateFreeTrialParams$outboundSchema: z$1.ZodMiniType<BillingUpdateFreeTrialParams$Outbound, BillingUpdateFreeTrialParams>;
declare function billingUpdateFreeTrialParamsToJSON(billingUpdateFreeTrialParams: BillingUpdateFreeTrialParams): string;
/** @internal */
declare const BillingUpdatePurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdatePurchaseLimitInterval>;
/** @internal */
type BillingUpdatePurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const BillingUpdatePurchaseLimit$outboundSchema: z$1.ZodMiniType<BillingUpdatePurchaseLimit$Outbound, BillingUpdatePurchaseLimit>;
declare function billingUpdatePurchaseLimitToJSON(billingUpdatePurchaseLimit: BillingUpdatePurchaseLimit): string;
/** @internal */
type BillingUpdateAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: BillingUpdatePurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const BillingUpdateAutoTopup$outboundSchema: z$1.ZodMiniType<BillingUpdateAutoTopup$Outbound, BillingUpdateAutoTopup>;
declare function billingUpdateAutoTopupToJSON(billingUpdateAutoTopup: BillingUpdateAutoTopup): string;
/** @internal */
declare const BillingUpdateLimitType$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateLimitType>;
/** @internal */
type BillingUpdateSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const BillingUpdateSpendLimit$outboundSchema: z$1.ZodMiniType<BillingUpdateSpendLimit$Outbound, BillingUpdateSpendLimit>;
declare function billingUpdateSpendLimitToJSON(billingUpdateSpendLimit: BillingUpdateSpendLimit): string;
/** @internal */
declare const BillingUpdateUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateUsageLimitInterval>;
/** @internal */
type BillingUpdateProperties$Outbound = string | number | boolean;
/** @internal */
declare const BillingUpdateProperties$outboundSchema: z$1.ZodMiniType<BillingUpdateProperties$Outbound, BillingUpdateProperties>;
declare function billingUpdatePropertiesToJSON(billingUpdateProperties: BillingUpdateProperties): string;
/** @internal */
type BillingUpdateFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const BillingUpdateFilter$outboundSchema: z$1.ZodMiniType<BillingUpdateFilter$Outbound, BillingUpdateFilter>;
declare function billingUpdateFilterToJSON(billingUpdateFilter: BillingUpdateFilter): string;
/** @internal */
type BillingUpdateUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: BillingUpdateFilter$Outbound | undefined;
};
/** @internal */
declare const BillingUpdateUsageLimit$outboundSchema: z$1.ZodMiniType<BillingUpdateUsageLimit$Outbound, BillingUpdateUsageLimit>;
declare function billingUpdateUsageLimitToJSON(billingUpdateUsageLimit: BillingUpdateUsageLimit): string;
/** @internal */
declare const BillingUpdateThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateThresholdType>;
/** @internal */
type BillingUpdateUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const BillingUpdateUsageAlert$outboundSchema: z$1.ZodMiniType<BillingUpdateUsageAlert$Outbound, BillingUpdateUsageAlert>;
declare function billingUpdateUsageAlertToJSON(billingUpdateUsageAlert: BillingUpdateUsageAlert): string;
/** @internal */
type BillingUpdateOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const BillingUpdateOverageAllowed$outboundSchema: z$1.ZodMiniType<BillingUpdateOverageAllowed$Outbound, BillingUpdateOverageAllowed>;
declare function billingUpdateOverageAllowedToJSON(billingUpdateOverageAllowed: BillingUpdateOverageAllowed): string;
/** @internal */
type BillingUpdateBillingControls$Outbound = {
    auto_topups?: Array<BillingUpdateAutoTopup$Outbound> | undefined;
    spend_limits?: Array<BillingUpdateSpendLimit$Outbound> | undefined;
    usage_limits?: Array<BillingUpdateUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<BillingUpdateUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<BillingUpdateOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const BillingUpdateBillingControls$outboundSchema: z$1.ZodMiniType<BillingUpdateBillingControls$Outbound, BillingUpdateBillingControls>;
declare function billingUpdateBillingControlsToJSON(billingUpdateBillingControls: BillingUpdateBillingControls): string;
/** @internal */
type BillingUpdateCustomize$Outbound = {
    price?: BillingUpdateBasePrice$Outbound | null | undefined;
    items?: Array<BillingUpdateItemPlanItem$Outbound> | undefined;
    add_items?: Array<BillingUpdateAddItemPlanItem$Outbound> | undefined;
    remove_items?: Array<BillingUpdatePlanItemFilter$Outbound> | undefined;
    free_trial?: BillingUpdateFreeTrialParams$Outbound | null | undefined;
    billing_controls?: BillingUpdateBillingControls$Outbound | undefined;
};
/** @internal */
declare const BillingUpdateCustomize$outboundSchema: z$1.ZodMiniType<BillingUpdateCustomize$Outbound, BillingUpdateCustomize>;
declare function billingUpdateCustomizeToJSON(billingUpdateCustomize: BillingUpdateCustomize): string;
/** @internal */
type BillingUpdateInvoiceMode$Outbound = {
    enabled: boolean;
    enable_plan_immediately: boolean;
    finalize: boolean;
    invoice_template_id?: string | undefined;
    net_terms_days?: number | undefined;
};
/** @internal */
declare const BillingUpdateInvoiceMode$outboundSchema: z$1.ZodMiniType<BillingUpdateInvoiceMode$Outbound, BillingUpdateInvoiceMode>;
declare function billingUpdateInvoiceModeToJSON(billingUpdateInvoiceMode: BillingUpdateInvoiceMode): string;
/** @internal */
declare const BillingUpdateProrationBehavior$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateProrationBehavior>;
/** @internal */
declare const BillingUpdateRedirectMode$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateRedirectMode>;
/** @internal */
type BillingUpdateAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const BillingUpdateAttachDiscount$outboundSchema: z$1.ZodMiniType<BillingUpdateAttachDiscount$Outbound, BillingUpdateAttachDiscount>;
declare function billingUpdateAttachDiscountToJSON(billingUpdateAttachDiscount: BillingUpdateAttachDiscount): string;
/** @internal */
declare const BillingUpdateCancelAction$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateCancelAction>;
/** @internal */
declare const BillingUpdateRefundLastPayment$outboundSchema: z$1.ZodMiniEnum<typeof BillingUpdateRefundLastPayment>;
/** @internal */
type BillingUpdateRecalculateBalances$Outbound = {
    enabled: boolean;
};
/** @internal */
declare const BillingUpdateRecalculateBalances$outboundSchema: z$1.ZodMiniType<BillingUpdateRecalculateBalances$Outbound, BillingUpdateRecalculateBalances>;
declare function billingUpdateRecalculateBalancesToJSON(billingUpdateRecalculateBalances: BillingUpdateRecalculateBalances): string;
/** @internal */
type BillingUpdateCarryOverUsages$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const BillingUpdateCarryOverUsages$outboundSchema: z$1.ZodMiniType<BillingUpdateCarryOverUsages$Outbound, BillingUpdateCarryOverUsages>;
declare function billingUpdateCarryOverUsagesToJSON(billingUpdateCarryOverUsages: BillingUpdateCarryOverUsages): string;
/** @internal */
type UpdateSubscriptionParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    plan_id?: string | undefined;
    feature_quantities?: Array<BillingUpdateFeatureQuantity$Outbound> | undefined;
    version?: number | undefined;
    customize?: BillingUpdateCustomize$Outbound | undefined;
    invoice_mode?: BillingUpdateInvoiceMode$Outbound | undefined;
    proration_behavior?: string | undefined;
    redirect_mode: string;
    subscription_id?: string | undefined;
    discounts?: Array<BillingUpdateAttachDiscount$Outbound> | undefined;
    cancel_action?: string | undefined;
    billing_cycle_anchor?: "now" | undefined;
    no_billing_changes?: boolean | undefined;
    refund_last_payment?: string | undefined;
    recalculate_balances?: BillingUpdateRecalculateBalances$Outbound | undefined;
    carry_over_usages?: BillingUpdateCarryOverUsages$Outbound | undefined;
};
/** @internal */
declare const UpdateSubscriptionParams$outboundSchema: z$1.ZodMiniType<UpdateSubscriptionParams$Outbound, UpdateSubscriptionParams>;
declare function updateSubscriptionParamsToJSON(updateSubscriptionParams: UpdateSubscriptionParams): string;
/** @internal */
declare const BillingUpdateInvoice$inboundSchema: z$1.ZodMiniType<BillingUpdateInvoice, unknown>;
declare function billingUpdateInvoiceFromJSON(jsonString: string): Result$1<BillingUpdateInvoice, SDKValidationError>;
/** @internal */
declare const BillingUpdateCode$inboundSchema: z$1.ZodMiniType<BillingUpdateCode, unknown>;
/** @internal */
declare const BillingUpdateRequiredAction$inboundSchema: z$1.ZodMiniType<BillingUpdateRequiredAction, unknown>;
declare function billingUpdateRequiredActionFromJSON(jsonString: string): Result$1<BillingUpdateRequiredAction, SDKValidationError>;
/** @internal */
declare const BillingUpdateResponse$inboundSchema: z$1.ZodMiniType<BillingUpdateResponse, unknown>;
declare function billingUpdateResponseFromJSON(jsonString: string): Result$1<BillingUpdateResponse, SDKValidationError>;

type CheckGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Reserve units of a feature upfront by passing a lock_id, then call balances.finalize to confirm or release the hold.
 */
type CheckLock = {
    /**
     * A unique identifier for this lock. Used to finalize the lock later via balances.finalize.
     */
    lockId: string;
    /**
     * Must be true to enable locking.
     */
    enabled: true;
    /**
     * Unix timestamp (ms) when the lock automatically expires and releases the held balance.
     */
    expiresAt?: number | undefined;
};
type CheckParams = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the feature.
     */
    featureId: string;
    /**
     * The ID of the entity for entity-scoped balances (e.g., per-seat limits).
     */
    entityId?: string | undefined;
    /**
     * Minimum balance required for access. Returns allowed: false if the customer's balance is below this value. Defaults to 1.
     */
    requiredBalance?: number | undefined;
    /**
     * Additional properties to attach to the usage event if send_event is true.
     */
    properties?: {
        [k: string]: any;
    } | undefined;
    /**
     * If true, atomically records a usage event while checking access. The required_balance value is used as the usage amount. Combines check + track in one call.
     */
    sendEvent?: boolean | undefined;
    /**
     * Reserve units of a feature upfront by passing a lock_id, then call balances.finalize to confirm or release the hold.
     */
    lock?: CheckLock | undefined;
    /**
     * If true, includes upgrade/upsell information in the response when access is denied. Useful for displaying paywalls.
     */
    withPreview?: boolean | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const FlagType2: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type FlagType2 = OpenEnum<typeof FlagType2>;
type CheckCreditSchema2 = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type CheckModelMarkups2 = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type CheckProviderMarkups2 = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type FlagDisplay2 = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type CheckFeature2 = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: FlagType2;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<CheckCreditSchema2> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: CheckModelMarkups2;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: CheckProviderMarkups2;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: FlagDisplay2 | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type Flag2 = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: CheckFeature2 | undefined;
};
/**
 * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
 */
declare const Scenario2: {
    readonly UsageLimit: "usage_limit";
    readonly FeatureFlag: "feature_flag";
};
/**
 * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
 */
type Scenario2 = OpenEnum<typeof Scenario2>;
/**
 * The environment of the product
 */
declare const CheckEnv2: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment of the product
 */
type CheckEnv2 = OpenEnum<typeof CheckEnv2>;
declare const ProductType2: {
    readonly Feature: "feature";
    readonly PricedFeature: "priced_feature";
    readonly Price: "price";
};
type ProductType2 = OpenEnum<typeof ProductType2>;
declare const FeatureType2: {
    readonly SingleUse: "single_use";
    readonly ContinuousUse: "continuous_use";
    readonly Boolean: "boolean";
    readonly Static: "static";
};
type FeatureType2 = OpenEnum<typeof FeatureType2>;
type IncludedUsage2 = number | string;
declare const CheckItemInterval2: {
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type CheckItemInterval2 = OpenEnum<typeof CheckItemInterval2>;
declare const CheckTierBehavior2: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type CheckTierBehavior2 = OpenEnum<typeof CheckTierBehavior2>;
declare const UsageModel2: {
    readonly Prepaid: "prepaid";
    readonly PayPerUse: "pay_per_use";
};
type UsageModel2 = OpenEnum<typeof UsageModel2>;
type ProductDisplay2 = {
    primaryText: string;
    secondaryText?: string | null | undefined;
};
declare const ConfigDuration2: {
    readonly Month: "month";
    readonly Forever: "forever";
};
type ConfigDuration2 = OpenEnum<typeof ConfigDuration2>;
type CheckRollover2 = {
    max?: number | null | undefined;
    maxPercentage?: number | null | undefined;
    duration: ConfigDuration2;
    length: number;
};
declare const CheckOnIncrease2: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
type CheckOnIncrease2 = OpenEnum<typeof CheckOnIncrease2>;
declare const CheckOnDecrease2: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
type CheckOnDecrease2 = OpenEnum<typeof CheckOnDecrease2>;
type CheckConfig2 = {
    rollover?: CheckRollover2 | null | undefined;
    onIncrease?: CheckOnIncrease2 | null | undefined;
    onDecrease?: CheckOnDecrease2 | null | undefined;
};
/**
 * Product item defining features and pricing within a product
 */
type CheckItem2 = {
    /**
     * The type of the product item
     */
    type?: ProductType2 | null | undefined;
    /**
     * The feature ID of the product item. If the item is a fixed price, should be `null`
     */
    featureId?: string | null | undefined;
    /**
     * Single use features are used once and then depleted, like API calls or credits. Continuous use features are those being used on an ongoing-basis, like storage or seats.
     */
    featureType?: FeatureType2 | null | undefined;
    /**
     * The amount of usage included for this feature.
     */
    includedUsage?: number | string | null | undefined;
    /**
     * The reset or billing interval of the product item. If null, feature will have no reset date, and if there's a price, it will be billed one-off.
     */
    interval?: CheckItemInterval2 | null | undefined;
    /**
     * The interval count of the product item.
     */
    intervalCount?: number | null | undefined;
    /**
     * The price of the product item. Should be `null` if tiered pricing is set.
     */
    price?: number | null | undefined;
    /**
     * Tiered pricing for the product item. Not applicable for fixed price items.
     */
    tiers?: Array<any | null> | null | undefined;
    /**
     * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier). Defaults to graduated.
     */
    tierBehavior?: CheckTierBehavior2 | null | undefined;
    /**
     * Whether the feature should be prepaid upfront or billed for how much they use end of billing period.
     */
    usageModel?: UsageModel2 | null | undefined;
    /**
     * The amount per billing unit (eg. $9 / 250 units)
     */
    billingUnits?: number | null | undefined;
    /**
     * Whether the usage should be reset when the product is enabled.
     */
    resetUsageWhenEnabled?: boolean | null | undefined;
    /**
     * The entity feature ID of the product item if applicable.
     */
    entityFeatureId?: string | null | undefined;
    /**
     * The display of the product item.
     */
    display?: ProductDisplay2 | null | undefined;
    /**
     * Used in customer context. Quantity of the feature the customer has prepaid for.
     */
    quantity?: number | null | undefined;
    /**
     * Used in customer context. Quantity of the feature the customer will prepay for in the next cycle.
     */
    nextCycleQuantity?: number | null | undefined;
    /**
     * Configuration for rollover and proration behavior of the feature.
     */
    config?: CheckConfig2 | null | undefined;
};
/**
 * The duration type of the free trial
 */
declare const FreeTrialDuration2: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * The duration type of the free trial
 */
type FreeTrialDuration2 = OpenEnum<typeof FreeTrialDuration2>;
declare const CheckOnEnd2: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
type CheckOnEnd2 = OpenEnum<typeof CheckOnEnd2>;
type CheckFreeTrial2 = {
    /**
     * The duration type of the free trial
     */
    duration: FreeTrialDuration2;
    /**
     * The length of the duration type specified
     */
    length: number;
    /**
     * Whether the free trial is limited to one per customer fingerprint
     */
    uniqueFingerprint: boolean;
    /**
     * Whether the free trial requires a card. If false, the customer can attach the product without going through a checkout flow or having a card on file.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: CheckOnEnd2 | null | undefined;
    /**
     * Used in customer context. Whether the free trial is available for the customer if they were to attach the product.
     */
    trialAvailable: boolean | null;
};
/**
 * The time interval for the purchase limit window.
 */
declare const CheckPurchaseLimitInterval2: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CheckPurchaseLimitInterval2 = OpenEnum<typeof CheckPurchaseLimitInterval2>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type CheckPurchaseLimit2 = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CheckPurchaseLimitInterval2;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type CheckAutoTopup2 = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: CheckPurchaseLimit2 | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CheckLimitType2: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CheckLimitType2 = OpenEnum<typeof CheckLimitType2>;
type CheckSpendLimit2 = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CheckLimitType2 | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CheckUsageLimitInterval2: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CheckUsageLimitInterval2 = OpenEnum<typeof CheckUsageLimitInterval2>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CheckFilter2 = {
    properties: {
        [k: string]: any;
    };
};
type CheckUsageLimit2 = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CheckUsageLimitInterval2;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CheckFilter2 | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CheckThresholdType2: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CheckThresholdType2 = OpenEnum<typeof CheckThresholdType2>;
type CheckUsageAlert2 = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CheckThresholdType2;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CheckOverageAllowed2 = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Plan-level billing controls used as customer defaults
 */
type CheckBillingControls2 = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CheckAutoTopup2> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CheckSpendLimit2> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<CheckUsageLimit2> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CheckUsageAlert2> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CheckOverageAllowed2> | undefined;
};
/**
 * Scenario for when this product is used in attach flows
 */
declare const ProductScenario2: {
    readonly Scheduled: "scheduled";
    readonly Active: "active";
    readonly New: "new";
    readonly Renew: "renew";
    readonly Upgrade: "upgrade";
    readonly UpdatePrepaidQuantity: "update_prepaid_quantity";
    readonly Downgrade: "downgrade";
    readonly Cancel: "cancel";
    readonly Expired: "expired";
    readonly PastDue: "past_due";
};
/**
 * Scenario for when this product is used in attach flows
 */
type ProductScenario2 = OpenEnum<typeof ProductScenario2>;
type CheckProperties2 = {
    /**
     * True if the product has no base price or usage prices
     */
    isFree: boolean;
    /**
     * True if the product only contains a one-time price
     */
    isOneOff: boolean;
    /**
     * The billing interval group for recurring products (e.g., 'monthly', 'yearly')
     */
    intervalGroup?: string | null | undefined;
    /**
     * True if the product includes a free trial
     */
    hasTrial?: boolean | null | undefined;
    /**
     * True if the product can be updated after creation (only applicable if there are prepaid recurring prices)
     */
    updateable?: boolean | null | undefined;
};
type CheckProduct2 = {
    /**
     * The ID of the product you set when creating the product
     */
    id: string;
    /**
     * The name of the product
     */
    name: string;
    /**
     * Product group which this product belongs to
     */
    group: string | null;
    /**
     * The environment of the product
     */
    env: CheckEnv2;
    /**
     * Whether the product is an add-on and can be purchased alongside other products
     */
    isAddOn: boolean;
    /**
     * Whether the product is the default product
     */
    isDefault: boolean;
    /**
     * Whether this product has been archived and is no longer available
     */
    archived: boolean;
    /**
     * The current version of the product
     */
    version: number;
    /**
     * The timestamp of when the product was created in milliseconds since epoch
     */
    createdAt: number;
    /**
     * Array of product items that define the product's features and pricing
     */
    items: Array<CheckItem2>;
    /**
     * Free trial configuration for this product, if available
     */
    freeTrial: CheckFreeTrial2 | null;
    /**
     * ID of the base variant this product is derived from
     */
    baseVariantId: string | null;
    /**
     * Plan-level billing controls used as customer defaults
     */
    billingControls?: CheckBillingControls2 | undefined;
    /**
     * Scenario for when this product is used in attach flows
     */
    scenario?: ProductScenario2 | undefined;
    properties?: CheckProperties2 | undefined;
};
/**
 * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
 */
type Preview2 = {
    /**
     * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
     */
    scenario: Scenario2;
    /**
     * A title suitable for displaying in a paywall or upgrade modal.
     */
    title: string;
    /**
     * A message explaining why access was denied.
     */
    message: string;
    /**
     * The ID of the feature that was checked.
     */
    featureId: string;
    /**
     * The display name of the feature.
     */
    featureName: string;
    /**
     * Products that would grant access to this feature. Use to display upgrade options.
     */
    products: Array<CheckProduct2>;
};
/**
 * Accepted. Autumn is experiencing degraded service from a downstream provider, so access was allowed fail-open.
 */
type CheckResponseBody2 = {
    /**
     * Whether the customer is allowed to use the feature. True if they have sufficient balance or the feature is unlimited/boolean.
     */
    allowed: boolean;
    /**
     * The ID of the customer that was checked.
     */
    customerId: string;
    /**
     * The ID of the entity, if an entity-scoped check was performed.
     */
    entityId?: string | null | undefined;
    /**
     * The required balance that was checked against.
     */
    requiredBalance?: number | undefined;
    /**
     * The customer's balance for this feature. Null if the customer has no balance for this feature.
     */
    balance: Balance | null;
    /**
     * Map of feature_id to balance for the checked feature and any related features (e.g. linked credit systems).
     */
    balances?: {
        [k: string]: Balance | null;
    } | undefined;
    /**
     * The flag associated with this check, if any.
     */
    flag: Flag2 | null;
    /**
     * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
     */
    preview?: Preview2 | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const FlagType1: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type FlagType1 = OpenEnum<typeof FlagType1>;
type CheckCreditSchema1 = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type CheckModelMarkups1 = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type CheckProviderMarkups1 = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type FlagDisplay1 = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type CheckFeature1 = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: FlagType1;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<CheckCreditSchema1> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: CheckModelMarkups1;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: CheckProviderMarkups1;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: FlagDisplay1 | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type Flag1 = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: CheckFeature1 | undefined;
};
/**
 * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
 */
declare const Scenario1: {
    readonly UsageLimit: "usage_limit";
    readonly FeatureFlag: "feature_flag";
};
/**
 * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
 */
type Scenario1 = OpenEnum<typeof Scenario1>;
/**
 * The environment of the product
 */
declare const CheckEnv1: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment of the product
 */
type CheckEnv1 = OpenEnum<typeof CheckEnv1>;
declare const ProductType1: {
    readonly Feature: "feature";
    readonly PricedFeature: "priced_feature";
    readonly Price: "price";
};
type ProductType1 = OpenEnum<typeof ProductType1>;
declare const FeatureType1: {
    readonly SingleUse: "single_use";
    readonly ContinuousUse: "continuous_use";
    readonly Boolean: "boolean";
    readonly Static: "static";
};
type FeatureType1 = OpenEnum<typeof FeatureType1>;
type IncludedUsage1 = number | string;
declare const CheckItemInterval1: {
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type CheckItemInterval1 = OpenEnum<typeof CheckItemInterval1>;
declare const CheckTierBehavior1: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type CheckTierBehavior1 = OpenEnum<typeof CheckTierBehavior1>;
declare const UsageModel1: {
    readonly Prepaid: "prepaid";
    readonly PayPerUse: "pay_per_use";
};
type UsageModel1 = OpenEnum<typeof UsageModel1>;
type ProductDisplay1 = {
    primaryText: string;
    secondaryText?: string | null | undefined;
};
declare const ConfigDuration1: {
    readonly Month: "month";
    readonly Forever: "forever";
};
type ConfigDuration1 = OpenEnum<typeof ConfigDuration1>;
type CheckRollover1 = {
    max?: number | null | undefined;
    maxPercentage?: number | null | undefined;
    duration: ConfigDuration1;
    length: number;
};
declare const CheckOnIncrease1: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
type CheckOnIncrease1 = OpenEnum<typeof CheckOnIncrease1>;
declare const CheckOnDecrease1: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
type CheckOnDecrease1 = OpenEnum<typeof CheckOnDecrease1>;
type CheckConfig1 = {
    rollover?: CheckRollover1 | null | undefined;
    onIncrease?: CheckOnIncrease1 | null | undefined;
    onDecrease?: CheckOnDecrease1 | null | undefined;
};
/**
 * Product item defining features and pricing within a product
 */
type CheckItem1 = {
    /**
     * The type of the product item
     */
    type?: ProductType1 | null | undefined;
    /**
     * The feature ID of the product item. If the item is a fixed price, should be `null`
     */
    featureId?: string | null | undefined;
    /**
     * Single use features are used once and then depleted, like API calls or credits. Continuous use features are those being used on an ongoing-basis, like storage or seats.
     */
    featureType?: FeatureType1 | null | undefined;
    /**
     * The amount of usage included for this feature.
     */
    includedUsage?: number | string | null | undefined;
    /**
     * The reset or billing interval of the product item. If null, feature will have no reset date, and if there's a price, it will be billed one-off.
     */
    interval?: CheckItemInterval1 | null | undefined;
    /**
     * The interval count of the product item.
     */
    intervalCount?: number | null | undefined;
    /**
     * The price of the product item. Should be `null` if tiered pricing is set.
     */
    price?: number | null | undefined;
    /**
     * Tiered pricing for the product item. Not applicable for fixed price items.
     */
    tiers?: Array<any | null> | null | undefined;
    /**
     * How tiers are applied: graduated (split across bands) or volume (flat rate for the matched tier). Defaults to graduated.
     */
    tierBehavior?: CheckTierBehavior1 | null | undefined;
    /**
     * Whether the feature should be prepaid upfront or billed for how much they use end of billing period.
     */
    usageModel?: UsageModel1 | null | undefined;
    /**
     * The amount per billing unit (eg. $9 / 250 units)
     */
    billingUnits?: number | null | undefined;
    /**
     * Whether the usage should be reset when the product is enabled.
     */
    resetUsageWhenEnabled?: boolean | null | undefined;
    /**
     * The entity feature ID of the product item if applicable.
     */
    entityFeatureId?: string | null | undefined;
    /**
     * The display of the product item.
     */
    display?: ProductDisplay1 | null | undefined;
    /**
     * Used in customer context. Quantity of the feature the customer has prepaid for.
     */
    quantity?: number | null | undefined;
    /**
     * Used in customer context. Quantity of the feature the customer will prepay for in the next cycle.
     */
    nextCycleQuantity?: number | null | undefined;
    /**
     * Configuration for rollover and proration behavior of the feature.
     */
    config?: CheckConfig1 | null | undefined;
};
/**
 * The duration type of the free trial
 */
declare const FreeTrialDuration1: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * The duration type of the free trial
 */
type FreeTrialDuration1 = OpenEnum<typeof FreeTrialDuration1>;
declare const CheckOnEnd1: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
type CheckOnEnd1 = OpenEnum<typeof CheckOnEnd1>;
type CheckFreeTrial1 = {
    /**
     * The duration type of the free trial
     */
    duration: FreeTrialDuration1;
    /**
     * The length of the duration type specified
     */
    length: number;
    /**
     * Whether the free trial is limited to one per customer fingerprint
     */
    uniqueFingerprint: boolean;
    /**
     * Whether the free trial requires a card. If false, the customer can attach the product without going through a checkout flow or having a card on file.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: CheckOnEnd1 | null | undefined;
    /**
     * Used in customer context. Whether the free trial is available for the customer if they were to attach the product.
     */
    trialAvailable: boolean | null;
};
/**
 * The time interval for the purchase limit window.
 */
declare const CheckPurchaseLimitInterval1: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CheckPurchaseLimitInterval1 = OpenEnum<typeof CheckPurchaseLimitInterval1>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type CheckPurchaseLimit1 = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CheckPurchaseLimitInterval1;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type CheckAutoTopup1 = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: CheckPurchaseLimit1 | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CheckLimitType1: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CheckLimitType1 = OpenEnum<typeof CheckLimitType1>;
type CheckSpendLimit1 = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CheckLimitType1 | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CheckUsageLimitInterval1: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CheckUsageLimitInterval1 = OpenEnum<typeof CheckUsageLimitInterval1>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CheckFilter1 = {
    properties: {
        [k: string]: any;
    };
};
type CheckUsageLimit1 = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CheckUsageLimitInterval1;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CheckFilter1 | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CheckThresholdType1: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CheckThresholdType1 = OpenEnum<typeof CheckThresholdType1>;
type CheckUsageAlert1 = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CheckThresholdType1;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CheckOverageAllowed1 = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Plan-level billing controls used as customer defaults
 */
type CheckBillingControls1 = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CheckAutoTopup1> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CheckSpendLimit1> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<CheckUsageLimit1> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CheckUsageAlert1> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CheckOverageAllowed1> | undefined;
};
/**
 * Scenario for when this product is used in attach flows
 */
declare const ProductScenario1: {
    readonly Scheduled: "scheduled";
    readonly Active: "active";
    readonly New: "new";
    readonly Renew: "renew";
    readonly Upgrade: "upgrade";
    readonly UpdatePrepaidQuantity: "update_prepaid_quantity";
    readonly Downgrade: "downgrade";
    readonly Cancel: "cancel";
    readonly Expired: "expired";
    readonly PastDue: "past_due";
};
/**
 * Scenario for when this product is used in attach flows
 */
type ProductScenario1 = OpenEnum<typeof ProductScenario1>;
type CheckProperties1 = {
    /**
     * True if the product has no base price or usage prices
     */
    isFree: boolean;
    /**
     * True if the product only contains a one-time price
     */
    isOneOff: boolean;
    /**
     * The billing interval group for recurring products (e.g., 'monthly', 'yearly')
     */
    intervalGroup?: string | null | undefined;
    /**
     * True if the product includes a free trial
     */
    hasTrial?: boolean | null | undefined;
    /**
     * True if the product can be updated after creation (only applicable if there are prepaid recurring prices)
     */
    updateable?: boolean | null | undefined;
};
type CheckProduct1 = {
    /**
     * The ID of the product you set when creating the product
     */
    id: string;
    /**
     * The name of the product
     */
    name: string;
    /**
     * Product group which this product belongs to
     */
    group: string | null;
    /**
     * The environment of the product
     */
    env: CheckEnv1;
    /**
     * Whether the product is an add-on and can be purchased alongside other products
     */
    isAddOn: boolean;
    /**
     * Whether the product is the default product
     */
    isDefault: boolean;
    /**
     * Whether this product has been archived and is no longer available
     */
    archived: boolean;
    /**
     * The current version of the product
     */
    version: number;
    /**
     * The timestamp of when the product was created in milliseconds since epoch
     */
    createdAt: number;
    /**
     * Array of product items that define the product's features and pricing
     */
    items: Array<CheckItem1>;
    /**
     * Free trial configuration for this product, if available
     */
    freeTrial: CheckFreeTrial1 | null;
    /**
     * ID of the base variant this product is derived from
     */
    baseVariantId: string | null;
    /**
     * Plan-level billing controls used as customer defaults
     */
    billingControls?: CheckBillingControls1 | undefined;
    /**
     * Scenario for when this product is used in attach flows
     */
    scenario?: ProductScenario1 | undefined;
    properties?: CheckProperties1 | undefined;
};
/**
 * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
 */
type Preview1 = {
    /**
     * The reason access was denied. 'usage_limit' means the customer exceeded their balance, 'feature_flag' means the feature is not included in their plan.
     */
    scenario: Scenario1;
    /**
     * A title suitable for displaying in a paywall or upgrade modal.
     */
    title: string;
    /**
     * A message explaining why access was denied.
     */
    message: string;
    /**
     * The ID of the feature that was checked.
     */
    featureId: string;
    /**
     * The display name of the feature.
     */
    featureName: string;
    /**
     * Products that would grant access to this feature. Use to display upgrade options.
     */
    products: Array<CheckProduct1>;
};
/**
 * OK
 */
type CheckResponseBody1 = {
    /**
     * Whether the customer is allowed to use the feature. True if they have sufficient balance or the feature is unlimited/boolean.
     */
    allowed: boolean;
    /**
     * The ID of the customer that was checked.
     */
    customerId: string;
    /**
     * The ID of the entity, if an entity-scoped check was performed.
     */
    entityId?: string | null | undefined;
    /**
     * The required balance that was checked against.
     */
    requiredBalance?: number | undefined;
    /**
     * The customer's balance for this feature. Null if the customer has no balance for this feature.
     */
    balance: Balance | null;
    /**
     * Map of feature_id to balance for the checked feature and any related features (e.g. linked credit systems).
     */
    balances?: {
        [k: string]: Balance | null;
    } | undefined;
    /**
     * The flag associated with this check, if any.
     */
    flag: Flag1 | null;
    /**
     * Upgrade/upsell information when access is denied. Only present if with_preview was true and allowed is false.
     */
    preview?: Preview1 | undefined;
};
type CheckResponse = CheckResponseBody1 | CheckResponseBody2;
/** @internal */
type CheckLock$Outbound = {
    lock_id: string;
    enabled: true;
    expires_at?: number | undefined;
};
/** @internal */
declare const CheckLock$outboundSchema: z$1.ZodMiniType<CheckLock$Outbound, CheckLock>;
declare function checkLockToJSON(checkLock: CheckLock): string;
/** @internal */
type CheckParams$Outbound = {
    customer_id: string;
    feature_id: string;
    entity_id?: string | undefined;
    required_balance?: number | undefined;
    properties?: {
        [k: string]: any;
    } | undefined;
    send_event?: boolean | undefined;
    lock?: CheckLock$Outbound | undefined;
    with_preview?: boolean | undefined;
};
/** @internal */
declare const CheckParams$outboundSchema: z$1.ZodMiniType<CheckParams$Outbound, CheckParams>;
declare function checkParamsToJSON(checkParams: CheckParams): string;
/** @internal */
declare const FlagType2$inboundSchema: z$1.ZodMiniType<FlagType2, unknown>;
/** @internal */
declare const CheckCreditSchema2$inboundSchema: z$1.ZodMiniType<CheckCreditSchema2, unknown>;
declare function checkCreditSchema2FromJSON(jsonString: string): Result$1<CheckCreditSchema2, SDKValidationError>;
/** @internal */
declare const CheckModelMarkups2$inboundSchema: z$1.ZodMiniType<CheckModelMarkups2, unknown>;
declare function checkModelMarkups2FromJSON(jsonString: string): Result$1<CheckModelMarkups2, SDKValidationError>;
/** @internal */
declare const CheckProviderMarkups2$inboundSchema: z$1.ZodMiniType<CheckProviderMarkups2, unknown>;
declare function checkProviderMarkups2FromJSON(jsonString: string): Result$1<CheckProviderMarkups2, SDKValidationError>;
/** @internal */
declare const FlagDisplay2$inboundSchema: z$1.ZodMiniType<FlagDisplay2, unknown>;
declare function flagDisplay2FromJSON(jsonString: string): Result$1<FlagDisplay2, SDKValidationError>;
/** @internal */
declare const CheckFeature2$inboundSchema: z$1.ZodMiniType<CheckFeature2, unknown>;
declare function checkFeature2FromJSON(jsonString: string): Result$1<CheckFeature2, SDKValidationError>;
/** @internal */
declare const Flag2$inboundSchema: z$1.ZodMiniType<Flag2, unknown>;
declare function flag2FromJSON(jsonString: string): Result$1<Flag2, SDKValidationError>;
/** @internal */
declare const Scenario2$inboundSchema: z$1.ZodMiniType<Scenario2, unknown>;
/** @internal */
declare const CheckEnv2$inboundSchema: z$1.ZodMiniType<CheckEnv2, unknown>;
/** @internal */
declare const ProductType2$inboundSchema: z$1.ZodMiniType<ProductType2, unknown>;
/** @internal */
declare const FeatureType2$inboundSchema: z$1.ZodMiniType<FeatureType2, unknown>;
/** @internal */
declare const IncludedUsage2$inboundSchema: z$1.ZodMiniType<IncludedUsage2, unknown>;
declare function includedUsage2FromJSON(jsonString: string): Result$1<IncludedUsage2, SDKValidationError>;
/** @internal */
declare const CheckItemInterval2$inboundSchema: z$1.ZodMiniType<CheckItemInterval2, unknown>;
/** @internal */
declare const CheckTierBehavior2$inboundSchema: z$1.ZodMiniType<CheckTierBehavior2, unknown>;
/** @internal */
declare const UsageModel2$inboundSchema: z$1.ZodMiniType<UsageModel2, unknown>;
/** @internal */
declare const ProductDisplay2$inboundSchema: z$1.ZodMiniType<ProductDisplay2, unknown>;
declare function productDisplay2FromJSON(jsonString: string): Result$1<ProductDisplay2, SDKValidationError>;
/** @internal */
declare const ConfigDuration2$inboundSchema: z$1.ZodMiniType<ConfigDuration2, unknown>;
/** @internal */
declare const CheckRollover2$inboundSchema: z$1.ZodMiniType<CheckRollover2, unknown>;
declare function checkRollover2FromJSON(jsonString: string): Result$1<CheckRollover2, SDKValidationError>;
/** @internal */
declare const CheckOnIncrease2$inboundSchema: z$1.ZodMiniType<CheckOnIncrease2, unknown>;
/** @internal */
declare const CheckOnDecrease2$inboundSchema: z$1.ZodMiniType<CheckOnDecrease2, unknown>;
/** @internal */
declare const CheckConfig2$inboundSchema: z$1.ZodMiniType<CheckConfig2, unknown>;
declare function checkConfig2FromJSON(jsonString: string): Result$1<CheckConfig2, SDKValidationError>;
/** @internal */
declare const CheckItem2$inboundSchema: z$1.ZodMiniType<CheckItem2, unknown>;
declare function checkItem2FromJSON(jsonString: string): Result$1<CheckItem2, SDKValidationError>;
/** @internal */
declare const FreeTrialDuration2$inboundSchema: z$1.ZodMiniType<FreeTrialDuration2, unknown>;
/** @internal */
declare const CheckOnEnd2$inboundSchema: z$1.ZodMiniType<CheckOnEnd2, unknown>;
/** @internal */
declare const CheckFreeTrial2$inboundSchema: z$1.ZodMiniType<CheckFreeTrial2, unknown>;
declare function checkFreeTrial2FromJSON(jsonString: string): Result$1<CheckFreeTrial2, SDKValidationError>;
/** @internal */
declare const CheckPurchaseLimitInterval2$inboundSchema: z$1.ZodMiniType<CheckPurchaseLimitInterval2, unknown>;
/** @internal */
declare const CheckPurchaseLimit2$inboundSchema: z$1.ZodMiniType<CheckPurchaseLimit2, unknown>;
declare function checkPurchaseLimit2FromJSON(jsonString: string): Result$1<CheckPurchaseLimit2, SDKValidationError>;
/** @internal */
declare const CheckAutoTopup2$inboundSchema: z$1.ZodMiniType<CheckAutoTopup2, unknown>;
declare function checkAutoTopup2FromJSON(jsonString: string): Result$1<CheckAutoTopup2, SDKValidationError>;
/** @internal */
declare const CheckLimitType2$inboundSchema: z$1.ZodMiniType<CheckLimitType2, unknown>;
/** @internal */
declare const CheckSpendLimit2$inboundSchema: z$1.ZodMiniType<CheckSpendLimit2, unknown>;
declare function checkSpendLimit2FromJSON(jsonString: string): Result$1<CheckSpendLimit2, SDKValidationError>;
/** @internal */
declare const CheckUsageLimitInterval2$inboundSchema: z$1.ZodMiniType<CheckUsageLimitInterval2, unknown>;
/** @internal */
declare const CheckFilter2$inboundSchema: z$1.ZodMiniType<CheckFilter2, unknown>;
declare function checkFilter2FromJSON(jsonString: string): Result$1<CheckFilter2, SDKValidationError>;
/** @internal */
declare const CheckUsageLimit2$inboundSchema: z$1.ZodMiniType<CheckUsageLimit2, unknown>;
declare function checkUsageLimit2FromJSON(jsonString: string): Result$1<CheckUsageLimit2, SDKValidationError>;
/** @internal */
declare const CheckThresholdType2$inboundSchema: z$1.ZodMiniType<CheckThresholdType2, unknown>;
/** @internal */
declare const CheckUsageAlert2$inboundSchema: z$1.ZodMiniType<CheckUsageAlert2, unknown>;
declare function checkUsageAlert2FromJSON(jsonString: string): Result$1<CheckUsageAlert2, SDKValidationError>;
/** @internal */
declare const CheckOverageAllowed2$inboundSchema: z$1.ZodMiniType<CheckOverageAllowed2, unknown>;
declare function checkOverageAllowed2FromJSON(jsonString: string): Result$1<CheckOverageAllowed2, SDKValidationError>;
/** @internal */
declare const CheckBillingControls2$inboundSchema: z$1.ZodMiniType<CheckBillingControls2, unknown>;
declare function checkBillingControls2FromJSON(jsonString: string): Result$1<CheckBillingControls2, SDKValidationError>;
/** @internal */
declare const ProductScenario2$inboundSchema: z$1.ZodMiniType<ProductScenario2, unknown>;
/** @internal */
declare const CheckProperties2$inboundSchema: z$1.ZodMiniType<CheckProperties2, unknown>;
declare function checkProperties2FromJSON(jsonString: string): Result$1<CheckProperties2, SDKValidationError>;
/** @internal */
declare const CheckProduct2$inboundSchema: z$1.ZodMiniType<CheckProduct2, unknown>;
declare function checkProduct2FromJSON(jsonString: string): Result$1<CheckProduct2, SDKValidationError>;
/** @internal */
declare const Preview2$inboundSchema: z$1.ZodMiniType<Preview2, unknown>;
declare function preview2FromJSON(jsonString: string): Result$1<Preview2, SDKValidationError>;
/** @internal */
declare const CheckResponseBody2$inboundSchema: z$1.ZodMiniType<CheckResponseBody2, unknown>;
declare function checkResponseBody2FromJSON(jsonString: string): Result$1<CheckResponseBody2, SDKValidationError>;
/** @internal */
declare const FlagType1$inboundSchema: z$1.ZodMiniType<FlagType1, unknown>;
/** @internal */
declare const CheckCreditSchema1$inboundSchema: z$1.ZodMiniType<CheckCreditSchema1, unknown>;
declare function checkCreditSchema1FromJSON(jsonString: string): Result$1<CheckCreditSchema1, SDKValidationError>;
/** @internal */
declare const CheckModelMarkups1$inboundSchema: z$1.ZodMiniType<CheckModelMarkups1, unknown>;
declare function checkModelMarkups1FromJSON(jsonString: string): Result$1<CheckModelMarkups1, SDKValidationError>;
/** @internal */
declare const CheckProviderMarkups1$inboundSchema: z$1.ZodMiniType<CheckProviderMarkups1, unknown>;
declare function checkProviderMarkups1FromJSON(jsonString: string): Result$1<CheckProviderMarkups1, SDKValidationError>;
/** @internal */
declare const FlagDisplay1$inboundSchema: z$1.ZodMiniType<FlagDisplay1, unknown>;
declare function flagDisplay1FromJSON(jsonString: string): Result$1<FlagDisplay1, SDKValidationError>;
/** @internal */
declare const CheckFeature1$inboundSchema: z$1.ZodMiniType<CheckFeature1, unknown>;
declare function checkFeature1FromJSON(jsonString: string): Result$1<CheckFeature1, SDKValidationError>;
/** @internal */
declare const Flag1$inboundSchema: z$1.ZodMiniType<Flag1, unknown>;
declare function flag1FromJSON(jsonString: string): Result$1<Flag1, SDKValidationError>;
/** @internal */
declare const Scenario1$inboundSchema: z$1.ZodMiniType<Scenario1, unknown>;
/** @internal */
declare const CheckEnv1$inboundSchema: z$1.ZodMiniType<CheckEnv1, unknown>;
/** @internal */
declare const ProductType1$inboundSchema: z$1.ZodMiniType<ProductType1, unknown>;
/** @internal */
declare const FeatureType1$inboundSchema: z$1.ZodMiniType<FeatureType1, unknown>;
/** @internal */
declare const IncludedUsage1$inboundSchema: z$1.ZodMiniType<IncludedUsage1, unknown>;
declare function includedUsage1FromJSON(jsonString: string): Result$1<IncludedUsage1, SDKValidationError>;
/** @internal */
declare const CheckItemInterval1$inboundSchema: z$1.ZodMiniType<CheckItemInterval1, unknown>;
/** @internal */
declare const CheckTierBehavior1$inboundSchema: z$1.ZodMiniType<CheckTierBehavior1, unknown>;
/** @internal */
declare const UsageModel1$inboundSchema: z$1.ZodMiniType<UsageModel1, unknown>;
/** @internal */
declare const ProductDisplay1$inboundSchema: z$1.ZodMiniType<ProductDisplay1, unknown>;
declare function productDisplay1FromJSON(jsonString: string): Result$1<ProductDisplay1, SDKValidationError>;
/** @internal */
declare const ConfigDuration1$inboundSchema: z$1.ZodMiniType<ConfigDuration1, unknown>;
/** @internal */
declare const CheckRollover1$inboundSchema: z$1.ZodMiniType<CheckRollover1, unknown>;
declare function checkRollover1FromJSON(jsonString: string): Result$1<CheckRollover1, SDKValidationError>;
/** @internal */
declare const CheckOnIncrease1$inboundSchema: z$1.ZodMiniType<CheckOnIncrease1, unknown>;
/** @internal */
declare const CheckOnDecrease1$inboundSchema: z$1.ZodMiniType<CheckOnDecrease1, unknown>;
/** @internal */
declare const CheckConfig1$inboundSchema: z$1.ZodMiniType<CheckConfig1, unknown>;
declare function checkConfig1FromJSON(jsonString: string): Result$1<CheckConfig1, SDKValidationError>;
/** @internal */
declare const CheckItem1$inboundSchema: z$1.ZodMiniType<CheckItem1, unknown>;
declare function checkItem1FromJSON(jsonString: string): Result$1<CheckItem1, SDKValidationError>;
/** @internal */
declare const FreeTrialDuration1$inboundSchema: z$1.ZodMiniType<FreeTrialDuration1, unknown>;
/** @internal */
declare const CheckOnEnd1$inboundSchema: z$1.ZodMiniType<CheckOnEnd1, unknown>;
/** @internal */
declare const CheckFreeTrial1$inboundSchema: z$1.ZodMiniType<CheckFreeTrial1, unknown>;
declare function checkFreeTrial1FromJSON(jsonString: string): Result$1<CheckFreeTrial1, SDKValidationError>;
/** @internal */
declare const CheckPurchaseLimitInterval1$inboundSchema: z$1.ZodMiniType<CheckPurchaseLimitInterval1, unknown>;
/** @internal */
declare const CheckPurchaseLimit1$inboundSchema: z$1.ZodMiniType<CheckPurchaseLimit1, unknown>;
declare function checkPurchaseLimit1FromJSON(jsonString: string): Result$1<CheckPurchaseLimit1, SDKValidationError>;
/** @internal */
declare const CheckAutoTopup1$inboundSchema: z$1.ZodMiniType<CheckAutoTopup1, unknown>;
declare function checkAutoTopup1FromJSON(jsonString: string): Result$1<CheckAutoTopup1, SDKValidationError>;
/** @internal */
declare const CheckLimitType1$inboundSchema: z$1.ZodMiniType<CheckLimitType1, unknown>;
/** @internal */
declare const CheckSpendLimit1$inboundSchema: z$1.ZodMiniType<CheckSpendLimit1, unknown>;
declare function checkSpendLimit1FromJSON(jsonString: string): Result$1<CheckSpendLimit1, SDKValidationError>;
/** @internal */
declare const CheckUsageLimitInterval1$inboundSchema: z$1.ZodMiniType<CheckUsageLimitInterval1, unknown>;
/** @internal */
declare const CheckFilter1$inboundSchema: z$1.ZodMiniType<CheckFilter1, unknown>;
declare function checkFilter1FromJSON(jsonString: string): Result$1<CheckFilter1, SDKValidationError>;
/** @internal */
declare const CheckUsageLimit1$inboundSchema: z$1.ZodMiniType<CheckUsageLimit1, unknown>;
declare function checkUsageLimit1FromJSON(jsonString: string): Result$1<CheckUsageLimit1, SDKValidationError>;
/** @internal */
declare const CheckThresholdType1$inboundSchema: z$1.ZodMiniType<CheckThresholdType1, unknown>;
/** @internal */
declare const CheckUsageAlert1$inboundSchema: z$1.ZodMiniType<CheckUsageAlert1, unknown>;
declare function checkUsageAlert1FromJSON(jsonString: string): Result$1<CheckUsageAlert1, SDKValidationError>;
/** @internal */
declare const CheckOverageAllowed1$inboundSchema: z$1.ZodMiniType<CheckOverageAllowed1, unknown>;
declare function checkOverageAllowed1FromJSON(jsonString: string): Result$1<CheckOverageAllowed1, SDKValidationError>;
/** @internal */
declare const CheckBillingControls1$inboundSchema: z$1.ZodMiniType<CheckBillingControls1, unknown>;
declare function checkBillingControls1FromJSON(jsonString: string): Result$1<CheckBillingControls1, SDKValidationError>;
/** @internal */
declare const ProductScenario1$inboundSchema: z$1.ZodMiniType<ProductScenario1, unknown>;
/** @internal */
declare const CheckProperties1$inboundSchema: z$1.ZodMiniType<CheckProperties1, unknown>;
declare function checkProperties1FromJSON(jsonString: string): Result$1<CheckProperties1, SDKValidationError>;
/** @internal */
declare const CheckProduct1$inboundSchema: z$1.ZodMiniType<CheckProduct1, unknown>;
declare function checkProduct1FromJSON(jsonString: string): Result$1<CheckProduct1, SDKValidationError>;
/** @internal */
declare const Preview1$inboundSchema: z$1.ZodMiniType<Preview1, unknown>;
declare function preview1FromJSON(jsonString: string): Result$1<Preview1, SDKValidationError>;
/** @internal */
declare const CheckResponseBody1$inboundSchema: z$1.ZodMiniType<CheckResponseBody1, unknown>;
declare function checkResponseBody1FromJSON(jsonString: string): Result$1<CheckResponseBody1, SDKValidationError>;
/** @internal */
declare const CheckResponse$inboundSchema: z$1.ZodMiniType<CheckResponse, unknown>;
declare function checkResponseFromJSON(jsonString: string): Result$1<CheckResponse, SDKValidationError>;

type CreateBalanceGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * The interval at which the balance resets (e.g., 'month', 'day', 'year').
 */
declare const CreateBalanceInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * The interval at which the balance resets (e.g., 'month', 'day', 'year').
 */
type CreateBalanceInterval = ClosedEnum<typeof CreateBalanceInterval>;
/**
 * Reset configuration for the balance. If not provided, the balance is a one-time grant that never resets.
 */
type CreateBalanceReset = {
    /**
     * The interval at which the balance resets (e.g., 'month', 'day', 'year').
     */
    interval: CreateBalanceInterval;
    /**
     * Number of intervals between resets. Defaults to 1 (e.g., interval_count: 2 with interval: 'month' resets every 2 months).
     */
    intervalCount?: number | undefined;
};
declare const CreateBalanceDuration: {
    readonly Month: "month";
    readonly Forever: "forever";
};
type CreateBalanceDuration = ClosedEnum<typeof CreateBalanceDuration>;
/**
 * Rollover configuration for the balance.
 */
type CreateBalanceRollover = {
    max?: number | null | undefined;
    maxPercentage?: number | null | undefined;
    duration?: CreateBalanceDuration | undefined;
    length: number;
};
type CreateBalanceParams = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the feature.
     */
    featureId: string;
    /**
     * The ID of the entity for entity-scoped balances (e.g., per-seat limits).
     */
    entityId?: string | undefined;
    /**
     * The initial balance amount to grant. For metered features, this is the number of units the customer can use.
     */
    includedGrant?: number | undefined;
    /**
     * If true, the balance has unlimited usage. Cannot be combined with 'included_grant'.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for the balance. If not provided, the balance is a one-time grant that never resets.
     */
    reset?: CreateBalanceReset | undefined;
    /**
     * Rollover configuration for the balance.
     */
    rollover?: CreateBalanceRollover | undefined;
    /**
     * Unix timestamp (milliseconds) when the balance expires. Mutually exclusive with reset.
     */
    expiresAt?: number | undefined;
    /**
     * Unix timestamp (milliseconds) for the first reset boundary, allowing a custom (e.g. shorter) first period. Requires 'reset', and must occur before 'expires_at' if both are provided. Subsequent resets advance by one reset interval from this boundary.
     */
    nextResetAt?: number | undefined;
    /**
     * A unique identifier for this balance. Use this to target the balance in future update / delete calls.
     */
    balanceId?: string | undefined;
};
/**
 * OK
 */
type CreateBalanceResponse = {
    success: boolean;
};
/** @internal */
declare const CreateBalanceInterval$outboundSchema: z$1.ZodMiniEnum<typeof CreateBalanceInterval>;
/** @internal */
type CreateBalanceReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const CreateBalanceReset$outboundSchema: z$1.ZodMiniType<CreateBalanceReset$Outbound, CreateBalanceReset>;
declare function createBalanceResetToJSON(createBalanceReset: CreateBalanceReset): string;
/** @internal */
declare const CreateBalanceDuration$outboundSchema: z$1.ZodMiniEnum<typeof CreateBalanceDuration>;
/** @internal */
type CreateBalanceRollover$Outbound = {
    max?: number | null | undefined;
    max_percentage?: number | null | undefined;
    duration: string;
    length: number;
};
/** @internal */
declare const CreateBalanceRollover$outboundSchema: z$1.ZodMiniType<CreateBalanceRollover$Outbound, CreateBalanceRollover>;
declare function createBalanceRolloverToJSON(createBalanceRollover: CreateBalanceRollover): string;
/** @internal */
type CreateBalanceParams$Outbound = {
    customer_id: string;
    feature_id: string;
    entity_id?: string | undefined;
    included_grant?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: CreateBalanceReset$Outbound | undefined;
    rollover?: CreateBalanceRollover$Outbound | undefined;
    expires_at?: number | undefined;
    next_reset_at?: number | undefined;
    balance_id?: string | undefined;
};
/** @internal */
declare const CreateBalanceParams$outboundSchema: z$1.ZodMiniType<CreateBalanceParams$Outbound, CreateBalanceParams>;
declare function createBalanceParamsToJSON(createBalanceParams: CreateBalanceParams): string;
/** @internal */
declare const CreateBalanceResponse$inboundSchema: z$1.ZodMiniType<CreateBalanceResponse, unknown>;
declare function createBalanceResponseFromJSON(jsonString: string): Result$1<CreateBalanceResponse, SDKValidationError>;

/**
 * The time interval for the purchase limit window.
 */
declare const CustomerDataPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CustomerDataPurchaseLimitInterval = ClosedEnum<typeof CustomerDataPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type CustomerDataPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CustomerDataPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type CustomerDataAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: CustomerDataPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CustomerDataLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CustomerDataLimitType = ClosedEnum<typeof CustomerDataLimitType>;
type CustomerDataSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CustomerDataLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CustomerDataUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CustomerDataUsageLimitInterval = ClosedEnum<typeof CustomerDataUsageLimitInterval>;
type Properties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CustomerDataFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type CustomerDataUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CustomerDataUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CustomerDataFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CustomerDataThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CustomerDataThresholdType = ClosedEnum<typeof CustomerDataThresholdType>;
type CustomerDataUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CustomerDataThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CustomerDataOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Billing controls for the customer (auto top-ups, etc.)
 */
type CustomerDataBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CustomerDataAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CustomerDataSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<CustomerDataUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CustomerDataUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CustomerDataOverageAllowed> | undefined;
};
/**
 * Miscellaneous configurations for the customer.
 */
type CustomerDataConfig = {
    /**
     * Whether to disable the shared customer-level pool for entities.
     */
    disablePooledBalance?: boolean | undefined;
    /**
     * Stops Autumn from posting usage-overage line items to Stripe for this customer. Check/track and balance resets still behave normally. When set, this overrides the organization-level disable_overage_billing setting.
     */
    disableOverageBilling?: boolean | undefined;
};
/**
 * Customer details to set when creating a customer
 */
type CustomerData = {
    /**
     * Customer's name
     */
    name?: string | null | undefined;
    /**
     * Customer's email address
     */
    email?: string | null | undefined;
    /**
     * Unique identifier (eg, serial number) to detect duplicate customers and prevent free trial abuse
     */
    fingerprint?: string | null | undefined;
    /**
     * Additional metadata for the customer
     */
    metadata?: {
        [k: string]: any;
    } | null | undefined;
    /**
     * Stripe customer ID if you already have one
     */
    stripeId?: string | null | undefined;
    /**
     * Whether to create the customer in Stripe
     */
    createInStripe?: boolean | undefined;
    /**
     * The ID of the free plan to auto-enable for the customer
     */
    autoEnablePlanId?: string | undefined;
    /**
     * Whether to send email receipts to this customer
     */
    sendEmailReceipts?: boolean | undefined;
    /**
     * Billing controls for the customer (auto top-ups, etc.)
     */
    billingControls?: CustomerDataBillingControls | undefined;
    /**
     * Miscellaneous configurations for the customer.
     */
    config?: CustomerDataConfig | undefined;
};
/** @internal */
declare const CustomerDataPurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof CustomerDataPurchaseLimitInterval>;
/** @internal */
type CustomerDataPurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const CustomerDataPurchaseLimit$outboundSchema: z$1.ZodMiniType<CustomerDataPurchaseLimit$Outbound, CustomerDataPurchaseLimit>;
declare function customerDataPurchaseLimitToJSON(customerDataPurchaseLimit: CustomerDataPurchaseLimit): string;
/** @internal */
type CustomerDataAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: CustomerDataPurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const CustomerDataAutoTopup$outboundSchema: z$1.ZodMiniType<CustomerDataAutoTopup$Outbound, CustomerDataAutoTopup>;
declare function customerDataAutoTopupToJSON(customerDataAutoTopup: CustomerDataAutoTopup): string;
/** @internal */
declare const CustomerDataLimitType$outboundSchema: z$1.ZodMiniEnum<typeof CustomerDataLimitType>;
/** @internal */
type CustomerDataSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const CustomerDataSpendLimit$outboundSchema: z$1.ZodMiniType<CustomerDataSpendLimit$Outbound, CustomerDataSpendLimit>;
declare function customerDataSpendLimitToJSON(customerDataSpendLimit: CustomerDataSpendLimit): string;
/** @internal */
declare const CustomerDataUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof CustomerDataUsageLimitInterval>;
/** @internal */
type Properties$Outbound = string | number | boolean;
/** @internal */
declare const Properties$outboundSchema: z$1.ZodMiniType<Properties$Outbound, Properties>;
declare function propertiesToJSON(properties: Properties): string;
/** @internal */
type CustomerDataFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const CustomerDataFilter$outboundSchema: z$1.ZodMiniType<CustomerDataFilter$Outbound, CustomerDataFilter>;
declare function customerDataFilterToJSON(customerDataFilter: CustomerDataFilter): string;
/** @internal */
type CustomerDataUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: CustomerDataFilter$Outbound | undefined;
};
/** @internal */
declare const CustomerDataUsageLimit$outboundSchema: z$1.ZodMiniType<CustomerDataUsageLimit$Outbound, CustomerDataUsageLimit>;
declare function customerDataUsageLimitToJSON(customerDataUsageLimit: CustomerDataUsageLimit): string;
/** @internal */
declare const CustomerDataThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof CustomerDataThresholdType>;
/** @internal */
type CustomerDataUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const CustomerDataUsageAlert$outboundSchema: z$1.ZodMiniType<CustomerDataUsageAlert$Outbound, CustomerDataUsageAlert>;
declare function customerDataUsageAlertToJSON(customerDataUsageAlert: CustomerDataUsageAlert): string;
/** @internal */
type CustomerDataOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const CustomerDataOverageAllowed$outboundSchema: z$1.ZodMiniType<CustomerDataOverageAllowed$Outbound, CustomerDataOverageAllowed>;
declare function customerDataOverageAllowedToJSON(customerDataOverageAllowed: CustomerDataOverageAllowed): string;
/** @internal */
type CustomerDataBillingControls$Outbound = {
    auto_topups?: Array<CustomerDataAutoTopup$Outbound> | undefined;
    spend_limits?: Array<CustomerDataSpendLimit$Outbound> | undefined;
    usage_limits?: Array<CustomerDataUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<CustomerDataUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<CustomerDataOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const CustomerDataBillingControls$outboundSchema: z$1.ZodMiniType<CustomerDataBillingControls$Outbound, CustomerDataBillingControls>;
declare function customerDataBillingControlsToJSON(customerDataBillingControls: CustomerDataBillingControls): string;
/** @internal */
type CustomerDataConfig$Outbound = {
    disable_pooled_balance?: boolean | undefined;
    disable_overage_billing?: boolean | undefined;
};
/** @internal */
declare const CustomerDataConfig$outboundSchema: z$1.ZodMiniType<CustomerDataConfig$Outbound, CustomerDataConfig>;
declare function customerDataConfigToJSON(customerDataConfig: CustomerDataConfig): string;
/** @internal */
type CustomerData$Outbound = {
    name?: string | null | undefined;
    email?: string | null | undefined;
    fingerprint?: string | null | undefined;
    metadata?: {
        [k: string]: any;
    } | null | undefined;
    stripe_id?: string | null | undefined;
    create_in_stripe?: boolean | undefined;
    auto_enable_plan_id?: string | undefined;
    send_email_receipts?: boolean | undefined;
    billing_controls?: CustomerDataBillingControls$Outbound | undefined;
    config?: CustomerDataConfig$Outbound | undefined;
};
/** @internal */
declare const CustomerData$outboundSchema: z$1.ZodMiniType<CustomerData$Outbound, CustomerData>;
declare function customerDataToJSON(customerData: CustomerData): string;

/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const PlanPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type PlanPriceInterval = OpenEnum<typeof PlanPriceInterval>;
/**
 * Display text for showing this price in pricing pages.
 */
type PlanPriceDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
type PlanPrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: PlanPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Display text for showing this price in pricing pages.
     */
    display?: PlanPriceDisplay | undefined;
};
/**
 * The type of the feature
 */
declare const PlanType: {
    readonly Static: "static";
    readonly Boolean: "boolean";
    readonly SingleUse: "single_use";
    readonly ContinuousUse: "continuous_use";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * The type of the feature
 */
type PlanType = OpenEnum<typeof PlanType>;
type PlanFeatureDisplay = {
    /**
     * The singular display name for the feature.
     */
    singular: string;
    /**
     * The plural display name for the feature.
     */
    plural: string;
};
type PlanCreditSchema = {
    /**
     * The ID of the metered feature (should be a single_use feature).
     */
    meteredFeatureId: string;
    /**
     * The credit cost of the metered feature.
     */
    creditCost: number;
};
/**
 * The full feature object if expanded.
 */
type PlanFeature = {
    /**
     * The ID of the feature, used to refer to it in other API calls like /track or /check.
     */
    id: string;
    /**
     * The name of the feature.
     */
    name?: string | null | undefined;
    /**
     * The type of the feature
     */
    type: PlanType;
    /**
     * Singular and plural display names for the feature.
     */
    display?: PlanFeatureDisplay | null | undefined;
    /**
     * Credit cost schema for credit system features.
     */
    creditSchema?: Array<PlanCreditSchema> | null | undefined;
    /**
     * Whether or not the feature is archived.
     */
    archived?: boolean | null | undefined;
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
declare const PlanResetItemInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
type PlanResetItemInterval = OpenEnum<typeof PlanResetItemInterval>;
type PlanItemReset = {
    /**
     * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
     */
    interval: PlanResetItemInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type PlanItemTo = number | string;
type PlanItemTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const PlanItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type PlanItemTierBehavior = OpenEnum<typeof PlanItemTierBehavior>;
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
declare const PlanPriceItemInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
type PlanPriceItemInterval = OpenEnum<typeof PlanPriceItemInterval>;
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
declare const PlanItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
type PlanItemBillingMethod = OpenEnum<typeof PlanItemBillingMethod>;
type PlanItemPrice = {
    /**
     * Price per billing_units after included usage is consumed. Mutually exclusive with tiers.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing configuration. Each tier's 'to' INCLUDES the included amount. Either 'tiers' or 'amount' is required.
     */
    tiers?: Array<PlanItemTier> | undefined;
    tierBehavior?: PlanItemTierBehavior | undefined;
    /**
     * Billing interval for this price. For consumable features, should match reset.interval.
     */
    interval: PlanPriceItemInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Number of units per price increment. Usage is rounded UP to the nearest billing_units when billed (e.g. billing_units=100 means 101 usage rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
     */
    billingMethod: PlanItemBillingMethod;
    /**
     * Maximum units a customer can purchase beyond included. E.g. if included=100 and max_purchase=300, customer can use up to 400 total before usage is capped. Null for no limit.
     */
    maxPurchase: number | null;
};
/**
 * Display text for showing this item in pricing pages.
 */
type PlanItemDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
/**
 * When rolled over units expire.
 */
declare const ItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type ItemExpiryDurationType = OpenEnum<typeof ItemExpiryDurationType>;
/**
 * Rollover configuration for unused units. If set, unused included units roll over to the next period.
 */
type PlanItemRollover = {
    /**
     * Maximum rollover units. Null for unlimited rollover.
     */
    max: number | null;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | null | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: ItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
type Item = {
    /**
     * The ID of the feature this item configures.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: PlanFeature | undefined;
    /**
     * Number of free units included. For consumable features, balance resets to this number each interval.
     */
    included: number;
    /**
     * Whether the customer has unlimited access to this feature.
     */
    unlimited: boolean;
    /**
     * Reset configuration for consumable features. Null for non-consumable features like seats where usage persists across billing cycles.
     */
    reset: PlanItemReset | null;
    /**
     * Pricing configuration for usage beyond included units. Null if feature is entirely free.
     */
    price: PlanItemPrice | null;
    /**
     * Display text for showing this item in pricing pages.
     */
    display?: PlanItemDisplay | undefined;
    /**
     * Rollover configuration for unused units. If set, unused included units roll over to the next period.
     */
    rollover?: PlanItemRollover | undefined;
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
declare const PlanDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
type PlanDurationType = OpenEnum<typeof PlanDurationType>;
declare const OnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
type OnEnd = OpenEnum<typeof OnEnd>;
/**
 * Free trial configuration. If set, new customers can try this plan before being charged.
 */
type FreeTrial = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial duration ('day', 'month', 'year').
     */
    durationType: PlanDurationType;
    /**
     * Whether a payment method is required to start the trial. If true, customer will be charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: OnEnd | null | undefined;
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
declare const PlanEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
type PlanEnv = OpenEnum<typeof PlanEnv>;
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const PlanPriceVariantDetailsInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type PlanPriceVariantDetailsInterval = OpenEnum<typeof PlanPriceVariantDetailsInterval>;
/**
 * Base price configuration for a plan.
 */
type BasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: PlanPriceVariantDetailsInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const PlanAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type PlanAddItemResetInterval = OpenEnum<typeof PlanAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type PlanVariantDetailsReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: PlanAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type PlanVariantDetailsTo = number | string;
type PlanVariantDetailsTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const PlanVariantDetailsTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type PlanVariantDetailsTierBehavior = OpenEnum<typeof PlanVariantDetailsTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const PlanAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type PlanAddItemPriceInterval = OpenEnum<typeof PlanAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const PlanAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type PlanAddItemBillingMethod = OpenEnum<typeof PlanAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type PlanVariantDetailsPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<PlanVariantDetailsTier> | undefined;
    tierBehavior?: PlanVariantDetailsTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: PlanAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount: number;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: PlanAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const OnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type OnIncrease = OpenEnum<typeof OnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const OnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type OnDecrease = OpenEnum<typeof OnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type Proration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: OnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: OnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const VariantDetailsExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type VariantDetailsExpiryDurationType = OpenEnum<typeof VariantDetailsExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type PlanVariantDetailsRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: VariantDetailsExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type PlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: PlanVariantDetailsReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: PlanVariantDetailsPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: Proration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: PlanVariantDetailsRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const PlanRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type PlanRemoveItemBillingMethod = OpenEnum<typeof PlanRemoveItemBillingMethod>;
declare const PlanIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type PlanIntervalRemoveItemEnum2 = OpenEnum<typeof PlanIntervalRemoveItemEnum2>;
declare const PlanIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type PlanIntervalRemoveItemEnum1 = OpenEnum<typeof PlanIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type PlanIntervalUnion = PlanIntervalRemoveItemEnum1 | PlanIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type PlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: PlanRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: PlanIntervalRemoveItemEnum1 | PlanIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const PlanVariantDetailsDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type PlanVariantDetailsDurationType = OpenEnum<typeof PlanVariantDetailsDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const VariantDetailsOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type VariantDetailsOnEnd = OpenEnum<typeof VariantDetailsOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type FreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType: PlanVariantDetailsDurationType;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: VariantDetailsOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const PlanVariantDetailsPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type PlanVariantDetailsPurchaseLimitInterval = OpenEnum<typeof PlanVariantDetailsPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type PlanVariantDetailsPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: PlanVariantDetailsPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type PlanVariantDetailsAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: PlanVariantDetailsPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const PlanVariantDetailsLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type PlanVariantDetailsLimitType = OpenEnum<typeof PlanVariantDetailsLimitType>;
type PlanVariantDetailsSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: PlanVariantDetailsLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const PlanVariantDetailsUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type PlanVariantDetailsUsageLimitInterval = OpenEnum<typeof PlanVariantDetailsUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type PlanVariantDetailsFilter = {
    properties: {
        [k: string]: any;
    };
};
type PlanVariantDetailsUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: PlanVariantDetailsUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: PlanVariantDetailsFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const PlanVariantDetailsThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type PlanVariantDetailsThresholdType = OpenEnum<typeof PlanVariantDetailsThresholdType>;
type PlanVariantDetailsUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: PlanVariantDetailsThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type PlanVariantDetailsOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type PlanVariantDetailsBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<PlanVariantDetailsAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<PlanVariantDetailsSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<PlanVariantDetailsUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<PlanVariantDetailsUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<PlanVariantDetailsOverageAllowed> | undefined;
};
/**
 * The customization that transforms the base plan into this variant.
 */
type Customize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: BasePrice | null | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<PlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<PlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: FreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: PlanVariantDetailsBillingControls | undefined;
};
/**
 * Details about how this variant relates to its latest base plan.
 */
type VariantDetails = {
    /**
     * The ID of the base plan this variant was derived from.
     */
    basePlanId: string;
    /**
     * The customization that transforms the base plan into this variant.
     */
    customize?: Customize | undefined;
};
/**
 * Miscellaneous plan-level configuration flags.
 */
type PlanConfig = {
    /**
     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
     */
    ignorePastDue: boolean;
};
/**
 * The time interval for the purchase limit window.
 */
declare const PlanPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type PlanPurchaseLimitInterval = OpenEnum<typeof PlanPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type PlanPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: PlanPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type PlanAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: PlanPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const PlanLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type PlanLimitType = OpenEnum<typeof PlanLimitType>;
type PlanSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: PlanLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const PlanUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type PlanUsageLimitInterval = OpenEnum<typeof PlanUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type PlanFilter = {
    properties: {
        [k: string]: any;
    };
};
type PlanUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: PlanUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: PlanFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const PlanThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type PlanThresholdType = OpenEnum<typeof PlanThresholdType>;
type PlanUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: PlanThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type PlanOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Plan-level billing controls used as customer defaults.
 */
type PlanBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<PlanAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<PlanSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<PlanUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<PlanUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<PlanOverageAllowed> | undefined;
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
declare const PlanStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
type PlanStatus = OpenEnum<typeof PlanStatus>;
/**
 * The action that would occur if this plan were attached to the customer.
 */
declare const AttachAction: {
    readonly Activate: "activate";
    readonly Upgrade: "upgrade";
    readonly Downgrade: "downgrade";
    readonly None: "none";
    readonly Purchase: "purchase";
};
/**
 * The action that would occur if this plan were attached to the customer.
 */
type AttachAction = OpenEnum<typeof AttachAction>;
type CustomerEligibility = {
    /**
     * Whether the trial on this plan is available to this customer. For example, if the customer used the trial in the past, this will be false.
     */
    trialAvailable?: boolean | undefined;
    /**
     * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
     */
    status?: PlanStatus | undefined;
    /**
     * Whether the customer's active instance of this plan is set to cancel.
     */
    canceling?: boolean | undefined;
    /**
     * Whether the customer is currently on a free trial of this plan.
     */
    trialing?: boolean | undefined;
    /**
     * The action that would occur if this plan were attached to the customer.
     */
    attachAction: AttachAction;
};
type Plan = {
    /**
     * Unique identifier for the plan.
     */
    id: string;
    /**
     * Display name of the plan.
     */
    name: string;
    /**
     * Optional description of the plan.
     */
    description: string | null;
    /**
     * Group identifier for organizing related plans. Plans in the same group are mutually exclusive.
     */
    group: string | null;
    /**
     * Version number of the plan. Incremented when plan configuration changes.
     */
    version: number;
    /**
     * Whether this is an add-on plan that can be attached alongside a main plan.
     */
    addOn: boolean;
    /**
     * If true, this plan is automatically attached when a customer is created. Used for free plans.
     */
    autoEnable: boolean;
    /**
     * Base recurring price for the plan. Null for free plans or usage-only plans.
     */
    price: PlanPrice | null;
    /**
     * Feature configurations included in this plan. Each item defines included units, pricing, and reset behavior for a feature.
     */
    items: Array<Item>;
    /**
     * Free trial configuration. If set, new customers can try this plan before being charged.
     */
    freeTrial?: FreeTrial | undefined;
    /**
     * Unix timestamp (ms) when the plan was created.
     */
    createdAt: number;
    /**
     * Environment this plan belongs to ('sandbox' or 'live').
     */
    env: PlanEnv;
    /**
     * Whether the plan is archived. Archived plans cannot be attached to new customers.
     */
    archived: boolean;
    /**
     * Deprecated. Use variant_details.base_plan_id instead. If this is a variant, the ID of the base plan it was created from.
     */
    baseVariantId: string | null;
    /**
     * Details about how this variant relates to its latest base plan.
     */
    variantDetails?: VariantDetails | undefined;
    /**
     * Miscellaneous plan-level configuration flags.
     */
    config: PlanConfig;
    /**
     * Plan-level billing controls used as customer defaults.
     */
    billingControls?: PlanBillingControls | undefined;
    /**
     * Arbitrary key-value metadata defined by you for your own use. Shared across all versions of the plan.
     */
    metadata: {
        [k: string]: any;
    };
    customerEligibility?: CustomerEligibility | undefined;
};
/** @internal */
declare const PlanPriceInterval$inboundSchema: z$1.ZodMiniType<PlanPriceInterval, unknown>;
/** @internal */
declare const PlanPriceDisplay$inboundSchema: z$1.ZodMiniType<PlanPriceDisplay, unknown>;
declare function planPriceDisplayFromJSON(jsonString: string): Result$1<PlanPriceDisplay, SDKValidationError>;
/** @internal */
declare const PlanPrice$inboundSchema: z$1.ZodMiniType<PlanPrice, unknown>;
declare function planPriceFromJSON(jsonString: string): Result$1<PlanPrice, SDKValidationError>;
/** @internal */
declare const PlanType$inboundSchema: z$1.ZodMiniType<PlanType, unknown>;
/** @internal */
declare const PlanFeatureDisplay$inboundSchema: z$1.ZodMiniType<PlanFeatureDisplay, unknown>;
declare function planFeatureDisplayFromJSON(jsonString: string): Result$1<PlanFeatureDisplay, SDKValidationError>;
/** @internal */
declare const PlanCreditSchema$inboundSchema: z$1.ZodMiniType<PlanCreditSchema, unknown>;
declare function planCreditSchemaFromJSON(jsonString: string): Result$1<PlanCreditSchema, SDKValidationError>;
/** @internal */
declare const PlanFeature$inboundSchema: z$1.ZodMiniType<PlanFeature, unknown>;
declare function planFeatureFromJSON(jsonString: string): Result$1<PlanFeature, SDKValidationError>;
/** @internal */
declare const PlanResetItemInterval$inboundSchema: z$1.ZodMiniType<PlanResetItemInterval, unknown>;
/** @internal */
declare const PlanItemReset$inboundSchema: z$1.ZodMiniType<PlanItemReset, unknown>;
declare function planItemResetFromJSON(jsonString: string): Result$1<PlanItemReset, SDKValidationError>;
/** @internal */
declare const PlanItemTo$inboundSchema: z$1.ZodMiniType<PlanItemTo, unknown>;
declare function planItemToFromJSON(jsonString: string): Result$1<PlanItemTo, SDKValidationError>;
/** @internal */
declare const PlanItemTier$inboundSchema: z$1.ZodMiniType<PlanItemTier, unknown>;
declare function planItemTierFromJSON(jsonString: string): Result$1<PlanItemTier, SDKValidationError>;
/** @internal */
declare const PlanItemTierBehavior$inboundSchema: z$1.ZodMiniType<PlanItemTierBehavior, unknown>;
/** @internal */
declare const PlanPriceItemInterval$inboundSchema: z$1.ZodMiniType<PlanPriceItemInterval, unknown>;
/** @internal */
declare const PlanItemBillingMethod$inboundSchema: z$1.ZodMiniType<PlanItemBillingMethod, unknown>;
/** @internal */
declare const PlanItemPrice$inboundSchema: z$1.ZodMiniType<PlanItemPrice, unknown>;
declare function planItemPriceFromJSON(jsonString: string): Result$1<PlanItemPrice, SDKValidationError>;
/** @internal */
declare const PlanItemDisplay$inboundSchema: z$1.ZodMiniType<PlanItemDisplay, unknown>;
declare function planItemDisplayFromJSON(jsonString: string): Result$1<PlanItemDisplay, SDKValidationError>;
/** @internal */
declare const ItemExpiryDurationType$inboundSchema: z$1.ZodMiniType<ItemExpiryDurationType, unknown>;
/** @internal */
declare const PlanItemRollover$inboundSchema: z$1.ZodMiniType<PlanItemRollover, unknown>;
declare function planItemRolloverFromJSON(jsonString: string): Result$1<PlanItemRollover, SDKValidationError>;
/** @internal */
declare const Item$inboundSchema: z$1.ZodMiniType<Item, unknown>;
declare function itemFromJSON(jsonString: string): Result$1<Item, SDKValidationError>;
/** @internal */
declare const PlanDurationType$inboundSchema: z$1.ZodMiniType<PlanDurationType, unknown>;
/** @internal */
declare const OnEnd$inboundSchema: z$1.ZodMiniType<OnEnd, unknown>;
/** @internal */
declare const FreeTrial$inboundSchema: z$1.ZodMiniType<FreeTrial, unknown>;
declare function freeTrialFromJSON(jsonString: string): Result$1<FreeTrial, SDKValidationError>;
/** @internal */
declare const PlanEnv$inboundSchema: z$1.ZodMiniType<PlanEnv, unknown>;
/** @internal */
declare const PlanPriceVariantDetailsInterval$inboundSchema: z$1.ZodMiniType<PlanPriceVariantDetailsInterval, unknown>;
/** @internal */
declare const BasePrice$inboundSchema: z$1.ZodMiniType<BasePrice, unknown>;
declare function basePriceFromJSON(jsonString: string): Result$1<BasePrice, SDKValidationError>;
/** @internal */
declare const PlanAddItemResetInterval$inboundSchema: z$1.ZodMiniType<PlanAddItemResetInterval, unknown>;
/** @internal */
declare const PlanVariantDetailsReset$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsReset, unknown>;
declare function planVariantDetailsResetFromJSON(jsonString: string): Result$1<PlanVariantDetailsReset, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsTo$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsTo, unknown>;
declare function planVariantDetailsToFromJSON(jsonString: string): Result$1<PlanVariantDetailsTo, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsTier$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsTier, unknown>;
declare function planVariantDetailsTierFromJSON(jsonString: string): Result$1<PlanVariantDetailsTier, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsTierBehavior$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsTierBehavior, unknown>;
/** @internal */
declare const PlanAddItemPriceInterval$inboundSchema: z$1.ZodMiniType<PlanAddItemPriceInterval, unknown>;
/** @internal */
declare const PlanAddItemBillingMethod$inboundSchema: z$1.ZodMiniType<PlanAddItemBillingMethod, unknown>;
/** @internal */
declare const PlanVariantDetailsPrice$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsPrice, unknown>;
declare function planVariantDetailsPriceFromJSON(jsonString: string): Result$1<PlanVariantDetailsPrice, SDKValidationError>;
/** @internal */
declare const OnIncrease$inboundSchema: z$1.ZodMiniType<OnIncrease, unknown>;
/** @internal */
declare const OnDecrease$inboundSchema: z$1.ZodMiniType<OnDecrease, unknown>;
/** @internal */
declare const Proration$inboundSchema: z$1.ZodMiniType<Proration, unknown>;
declare function prorationFromJSON(jsonString: string): Result$1<Proration, SDKValidationError>;
/** @internal */
declare const VariantDetailsExpiryDurationType$inboundSchema: z$1.ZodMiniType<VariantDetailsExpiryDurationType, unknown>;
/** @internal */
declare const PlanVariantDetailsRollover$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsRollover, unknown>;
declare function planVariantDetailsRolloverFromJSON(jsonString: string): Result$1<PlanVariantDetailsRollover, SDKValidationError>;
/** @internal */
declare const PlanItem$inboundSchema: z$1.ZodMiniType<PlanItem, unknown>;
declare function planItemFromJSON(jsonString: string): Result$1<PlanItem, SDKValidationError>;
/** @internal */
declare const PlanRemoveItemBillingMethod$inboundSchema: z$1.ZodMiniType<PlanRemoveItemBillingMethod, unknown>;
/** @internal */
declare const PlanIntervalRemoveItemEnum2$inboundSchema: z$1.ZodMiniType<PlanIntervalRemoveItemEnum2, unknown>;
/** @internal */
declare const PlanIntervalRemoveItemEnum1$inboundSchema: z$1.ZodMiniType<PlanIntervalRemoveItemEnum1, unknown>;
/** @internal */
declare const PlanIntervalUnion$inboundSchema: z$1.ZodMiniType<PlanIntervalUnion, unknown>;
declare function planIntervalUnionFromJSON(jsonString: string): Result$1<PlanIntervalUnion, SDKValidationError>;
/** @internal */
declare const PlanItemFilter$inboundSchema: z$1.ZodMiniType<PlanItemFilter, unknown>;
declare function planItemFilterFromJSON(jsonString: string): Result$1<PlanItemFilter, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsDurationType$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsDurationType, unknown>;
/** @internal */
declare const VariantDetailsOnEnd$inboundSchema: z$1.ZodMiniType<VariantDetailsOnEnd, unknown>;
/** @internal */
declare const FreeTrialParams$inboundSchema: z$1.ZodMiniType<FreeTrialParams, unknown>;
declare function freeTrialParamsFromJSON(jsonString: string): Result$1<FreeTrialParams, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsPurchaseLimitInterval, unknown>;
/** @internal */
declare const PlanVariantDetailsPurchaseLimit$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsPurchaseLimit, unknown>;
declare function planVariantDetailsPurchaseLimitFromJSON(jsonString: string): Result$1<PlanVariantDetailsPurchaseLimit, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsAutoTopup$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsAutoTopup, unknown>;
declare function planVariantDetailsAutoTopupFromJSON(jsonString: string): Result$1<PlanVariantDetailsAutoTopup, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsLimitType$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsLimitType, unknown>;
/** @internal */
declare const PlanVariantDetailsSpendLimit$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsSpendLimit, unknown>;
declare function planVariantDetailsSpendLimitFromJSON(jsonString: string): Result$1<PlanVariantDetailsSpendLimit, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsUsageLimitInterval$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsUsageLimitInterval, unknown>;
/** @internal */
declare const PlanVariantDetailsFilter$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsFilter, unknown>;
declare function planVariantDetailsFilterFromJSON(jsonString: string): Result$1<PlanVariantDetailsFilter, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsUsageLimit$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsUsageLimit, unknown>;
declare function planVariantDetailsUsageLimitFromJSON(jsonString: string): Result$1<PlanVariantDetailsUsageLimit, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsThresholdType$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsThresholdType, unknown>;
/** @internal */
declare const PlanVariantDetailsUsageAlert$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsUsageAlert, unknown>;
declare function planVariantDetailsUsageAlertFromJSON(jsonString: string): Result$1<PlanVariantDetailsUsageAlert, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsOverageAllowed$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsOverageAllowed, unknown>;
declare function planVariantDetailsOverageAllowedFromJSON(jsonString: string): Result$1<PlanVariantDetailsOverageAllowed, SDKValidationError>;
/** @internal */
declare const PlanVariantDetailsBillingControls$inboundSchema: z$1.ZodMiniType<PlanVariantDetailsBillingControls, unknown>;
declare function planVariantDetailsBillingControlsFromJSON(jsonString: string): Result$1<PlanVariantDetailsBillingControls, SDKValidationError>;
/** @internal */
declare const Customize$inboundSchema: z$1.ZodMiniType<Customize, unknown>;
declare function customizeFromJSON(jsonString: string): Result$1<Customize, SDKValidationError>;
/** @internal */
declare const VariantDetails$inboundSchema: z$1.ZodMiniType<VariantDetails, unknown>;
declare function variantDetailsFromJSON(jsonString: string): Result$1<VariantDetails, SDKValidationError>;
/** @internal */
declare const PlanConfig$inboundSchema: z$1.ZodMiniType<PlanConfig, unknown>;
declare function planConfigFromJSON(jsonString: string): Result$1<PlanConfig, SDKValidationError>;
/** @internal */
declare const PlanPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<PlanPurchaseLimitInterval, unknown>;
/** @internal */
declare const PlanPurchaseLimit$inboundSchema: z$1.ZodMiniType<PlanPurchaseLimit, unknown>;
declare function planPurchaseLimitFromJSON(jsonString: string): Result$1<PlanPurchaseLimit, SDKValidationError>;
/** @internal */
declare const PlanAutoTopup$inboundSchema: z$1.ZodMiniType<PlanAutoTopup, unknown>;
declare function planAutoTopupFromJSON(jsonString: string): Result$1<PlanAutoTopup, SDKValidationError>;
/** @internal */
declare const PlanLimitType$inboundSchema: z$1.ZodMiniType<PlanLimitType, unknown>;
/** @internal */
declare const PlanSpendLimit$inboundSchema: z$1.ZodMiniType<PlanSpendLimit, unknown>;
declare function planSpendLimitFromJSON(jsonString: string): Result$1<PlanSpendLimit, SDKValidationError>;
/** @internal */
declare const PlanUsageLimitInterval$inboundSchema: z$1.ZodMiniType<PlanUsageLimitInterval, unknown>;
/** @internal */
declare const PlanFilter$inboundSchema: z$1.ZodMiniType<PlanFilter, unknown>;
declare function planFilterFromJSON(jsonString: string): Result$1<PlanFilter, SDKValidationError>;
/** @internal */
declare const PlanUsageLimit$inboundSchema: z$1.ZodMiniType<PlanUsageLimit, unknown>;
declare function planUsageLimitFromJSON(jsonString: string): Result$1<PlanUsageLimit, SDKValidationError>;
/** @internal */
declare const PlanThresholdType$inboundSchema: z$1.ZodMiniType<PlanThresholdType, unknown>;
/** @internal */
declare const PlanUsageAlert$inboundSchema: z$1.ZodMiniType<PlanUsageAlert, unknown>;
declare function planUsageAlertFromJSON(jsonString: string): Result$1<PlanUsageAlert, SDKValidationError>;
/** @internal */
declare const PlanOverageAllowed$inboundSchema: z$1.ZodMiniType<PlanOverageAllowed, unknown>;
declare function planOverageAllowedFromJSON(jsonString: string): Result$1<PlanOverageAllowed, SDKValidationError>;
/** @internal */
declare const PlanBillingControls$inboundSchema: z$1.ZodMiniType<PlanBillingControls, unknown>;
declare function planBillingControlsFromJSON(jsonString: string): Result$1<PlanBillingControls, SDKValidationError>;
/** @internal */
declare const PlanStatus$inboundSchema: z$1.ZodMiniType<PlanStatus, unknown>;
/** @internal */
declare const AttachAction$inboundSchema: z$1.ZodMiniType<AttachAction, unknown>;
/** @internal */
declare const CustomerEligibility$inboundSchema: z$1.ZodMiniType<CustomerEligibility, unknown>;
declare function customerEligibilityFromJSON(jsonString: string): Result$1<CustomerEligibility, SDKValidationError>;
/** @internal */
declare const Plan$inboundSchema: z$1.ZodMiniType<Plan, unknown>;
declare function planFromJSON(jsonString: string): Result$1<Plan, SDKValidationError>;

type CreateEntityGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CreateEntityLimitTypeRequestBody: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CreateEntityLimitTypeRequestBody = ClosedEnum<typeof CreateEntityLimitTypeRequestBody>;
type CreateEntitySpendLimitRequest = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CreateEntityLimitTypeRequestBody | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CreateEntityIntervalRequestBody: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CreateEntityIntervalRequestBody = ClosedEnum<typeof CreateEntityIntervalRequestBody>;
type CreateEntityProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CreateEntityFilterRequest = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type CreateEntityUsageLimitRequest = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CreateEntityIntervalRequestBody;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CreateEntityFilterRequest | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CreateEntityThresholdTypeRequestBody: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CreateEntityThresholdTypeRequestBody = ClosedEnum<typeof CreateEntityThresholdTypeRequestBody>;
type CreateEntityUsageAlertRequestBody = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CreateEntityThresholdTypeRequestBody;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CreateEntityOverageAllowedRequest = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Billing controls for the entity.
 */
type CreateEntityBillingControlsRequest = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<CreateEntitySpendLimitRequest> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<CreateEntityUsageLimitRequest> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CreateEntityUsageAlertRequestBody> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CreateEntityOverageAllowedRequest> | undefined;
};
type CreateEntityParams = {
    /**
     * The name of the entity
     */
    name?: string | null | undefined;
    /**
     * The ID of the feature this entity is associated with
     */
    featureId: string;
    /**
     * Billing controls for the entity.
     */
    billingControls?: CreateEntityBillingControlsRequest | undefined;
    /**
     * Customer details to set when creating a customer
     */
    customerData?: CustomerData | undefined;
    /**
     * The ID of the customer to create the entity for.
     */
    customerId: string;
    /**
     * The ID of the entity.
     */
    entityId: string;
};
/**
 * The environment (sandbox/live)
 */
declare const CreateEntityEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment (sandbox/live)
 */
type CreateEntityEnv = OpenEnum<typeof CreateEntityEnv>;
/**
 * Current status of the subscription.
 */
declare const CreateEntityStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type CreateEntityStatus = OpenEnum<typeof CreateEntityStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const CreateEntitySubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type CreateEntitySubscriptionScope = OpenEnum<typeof CreateEntitySubscriptionScope>;
type CreateEntitySubscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: CreateEntityStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: CreateEntitySubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const CreateEntityPurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type CreateEntityPurchaseScope = OpenEnum<typeof CreateEntityPurchaseScope>;
type CreateEntityPurchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: CreateEntityPurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const CreateEntityType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type CreateEntityType = OpenEnum<typeof CreateEntityType>;
type CreateEntityCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type CreateEntityModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type CreateEntityProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type CreateEntityDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type CreateEntityFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: CreateEntityType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<CreateEntityCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: CreateEntityModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: CreateEntityProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: CreateEntityDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type CreateEntityFlags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: CreateEntityFeature | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CreateEntityLimitTypeResponse: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CreateEntityLimitTypeResponse = OpenEnum<typeof CreateEntityLimitTypeResponse>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const CreateEntitySpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type CreateEntitySpendLimitSource = OpenEnum<typeof CreateEntitySpendLimitSource>;
type CreateEntitySpendLimitResponse = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CreateEntityLimitTypeResponse | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: CreateEntitySpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CreateEntityIntervalResponse: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CreateEntityIntervalResponse = OpenEnum<typeof CreateEntityIntervalResponse>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CreateEntityFilterResponse = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const CreateEntityUsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type CreateEntityUsageLimitSource = OpenEnum<typeof CreateEntityUsageLimitSource>;
type CreateEntityUsageLimitResponse = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CreateEntityIntervalResponse;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CreateEntityFilterResponse | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: CreateEntityUsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CreateEntityThresholdTypeResponse: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CreateEntityThresholdTypeResponse = OpenEnum<typeof CreateEntityThresholdTypeResponse>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const CreateEntityUsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type CreateEntityUsageAlertSource = OpenEnum<typeof CreateEntityUsageAlertSource>;
type CreateEntityUsageAlertResponse = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CreateEntityThresholdTypeResponse;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: CreateEntityUsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const CreateEntityOverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type CreateEntityOverageAllowedSource = OpenEnum<typeof CreateEntityOverageAllowedSource>;
type CreateEntityOverageAllowedResponse = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: CreateEntityOverageAllowedSource | undefined;
};
/**
 * Billing controls for the entity.
 */
type CreateEntityBillingControlsResponse = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<CreateEntitySpendLimitResponse> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<CreateEntityUsageLimitResponse> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CreateEntityUsageAlertResponse> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CreateEntityOverageAllowedResponse> | undefined;
};
/**
 * The billing processor that owns this invoice.
 */
declare const CreateEntityProcessorType: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The billing processor that owns this invoice.
 */
type CreateEntityProcessorType = OpenEnum<typeof CreateEntityProcessorType>;
type CreateEntityInvoice = {
    /**
     * Array of plan IDs included in this invoice
     */
    planIds: Array<string>;
    /**
     * The Stripe invoice ID
     */
    stripeId: string;
    /**
     * The billing processor that owns this invoice.
     */
    processorType: CreateEntityProcessorType;
    /**
     * The status of the invoice
     */
    status: string;
    /**
     * The total amount of the invoice
     */
    total: number;
    /**
     * The currency code for the invoice
     */
    currency: string;
    /**
     * Timestamp when the invoice was created
     */
    createdAt: number;
    /**
     * URL to the Stripe-hosted invoice page
     */
    hostedInvoiceUrl?: string | null | undefined;
};
/**
 * OK
 */
type CreateEntityResponse = {
    /**
     * The unique identifier of the entity
     */
    id: string | null;
    /**
     * The name of the entity
     */
    name: string | null;
    /**
     * The customer ID this entity belongs to
     */
    customerId?: string | null | undefined;
    /**
     * The feature ID this entity belongs to
     */
    featureId?: string | null | undefined;
    /**
     * Unix timestamp when the entity was created
     */
    createdAt: number;
    /**
     * The environment (sandbox/live)
     */
    env: CreateEntityEnv;
    subscriptions: Array<CreateEntitySubscription>;
    purchases: Array<CreateEntityPurchase>;
    balances: {
        [k: string]: Balance;
    };
    flags: {
        [k: string]: CreateEntityFlags;
    };
    /**
     * Billing controls for the entity.
     */
    billingControls?: CreateEntityBillingControlsResponse | undefined;
    /**
     * Invoices for this entity (only included when expand=invoices)
     */
    invoices?: Array<CreateEntityInvoice> | undefined;
};
/** @internal */
declare const CreateEntityLimitTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreateEntityLimitTypeRequestBody>;
/** @internal */
type CreateEntitySpendLimitRequest$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const CreateEntitySpendLimitRequest$outboundSchema: z$1.ZodMiniType<CreateEntitySpendLimitRequest$Outbound, CreateEntitySpendLimitRequest>;
declare function createEntitySpendLimitRequestToJSON(createEntitySpendLimitRequest: CreateEntitySpendLimitRequest): string;
/** @internal */
declare const CreateEntityIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreateEntityIntervalRequestBody>;
/** @internal */
type CreateEntityProperties$Outbound = string | number | boolean;
/** @internal */
declare const CreateEntityProperties$outboundSchema: z$1.ZodMiniType<CreateEntityProperties$Outbound, CreateEntityProperties>;
declare function createEntityPropertiesToJSON(createEntityProperties: CreateEntityProperties): string;
/** @internal */
type CreateEntityFilterRequest$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const CreateEntityFilterRequest$outboundSchema: z$1.ZodMiniType<CreateEntityFilterRequest$Outbound, CreateEntityFilterRequest>;
declare function createEntityFilterRequestToJSON(createEntityFilterRequest: CreateEntityFilterRequest): string;
/** @internal */
type CreateEntityUsageLimitRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: CreateEntityFilterRequest$Outbound | undefined;
};
/** @internal */
declare const CreateEntityUsageLimitRequest$outboundSchema: z$1.ZodMiniType<CreateEntityUsageLimitRequest$Outbound, CreateEntityUsageLimitRequest>;
declare function createEntityUsageLimitRequestToJSON(createEntityUsageLimitRequest: CreateEntityUsageLimitRequest): string;
/** @internal */
declare const CreateEntityThresholdTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreateEntityThresholdTypeRequestBody>;
/** @internal */
type CreateEntityUsageAlertRequestBody$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const CreateEntityUsageAlertRequestBody$outboundSchema: z$1.ZodMiniType<CreateEntityUsageAlertRequestBody$Outbound, CreateEntityUsageAlertRequestBody>;
declare function createEntityUsageAlertRequestBodyToJSON(createEntityUsageAlertRequestBody: CreateEntityUsageAlertRequestBody): string;
/** @internal */
type CreateEntityOverageAllowedRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const CreateEntityOverageAllowedRequest$outboundSchema: z$1.ZodMiniType<CreateEntityOverageAllowedRequest$Outbound, CreateEntityOverageAllowedRequest>;
declare function createEntityOverageAllowedRequestToJSON(createEntityOverageAllowedRequest: CreateEntityOverageAllowedRequest): string;
/** @internal */
type CreateEntityBillingControlsRequest$Outbound = {
    spend_limits?: Array<CreateEntitySpendLimitRequest$Outbound> | undefined;
    usage_limits?: Array<CreateEntityUsageLimitRequest$Outbound> | undefined;
    usage_alerts?: Array<CreateEntityUsageAlertRequestBody$Outbound> | undefined;
    overage_allowed?: Array<CreateEntityOverageAllowedRequest$Outbound> | undefined;
};
/** @internal */
declare const CreateEntityBillingControlsRequest$outboundSchema: z$1.ZodMiniType<CreateEntityBillingControlsRequest$Outbound, CreateEntityBillingControlsRequest>;
declare function createEntityBillingControlsRequestToJSON(createEntityBillingControlsRequest: CreateEntityBillingControlsRequest): string;
/** @internal */
type CreateEntityParams$Outbound = {
    name?: string | null | undefined;
    feature_id: string;
    billing_controls?: CreateEntityBillingControlsRequest$Outbound | undefined;
    customer_data?: CustomerData$Outbound | undefined;
    customer_id: string;
    entity_id: string;
};
/** @internal */
declare const CreateEntityParams$outboundSchema: z$1.ZodMiniType<CreateEntityParams$Outbound, CreateEntityParams>;
declare function createEntityParamsToJSON(createEntityParams: CreateEntityParams): string;
/** @internal */
declare const CreateEntityEnv$inboundSchema: z$1.ZodMiniType<CreateEntityEnv, unknown>;
/** @internal */
declare const CreateEntityStatus$inboundSchema: z$1.ZodMiniType<CreateEntityStatus, unknown>;
/** @internal */
declare const CreateEntitySubscriptionScope$inboundSchema: z$1.ZodMiniType<CreateEntitySubscriptionScope, unknown>;
/** @internal */
declare const CreateEntitySubscription$inboundSchema: z$1.ZodMiniType<CreateEntitySubscription, unknown>;
declare function createEntitySubscriptionFromJSON(jsonString: string): Result$1<CreateEntitySubscription, SDKValidationError>;
/** @internal */
declare const CreateEntityPurchaseScope$inboundSchema: z$1.ZodMiniType<CreateEntityPurchaseScope, unknown>;
/** @internal */
declare const CreateEntityPurchase$inboundSchema: z$1.ZodMiniType<CreateEntityPurchase, unknown>;
declare function createEntityPurchaseFromJSON(jsonString: string): Result$1<CreateEntityPurchase, SDKValidationError>;
/** @internal */
declare const CreateEntityType$inboundSchema: z$1.ZodMiniType<CreateEntityType, unknown>;
/** @internal */
declare const CreateEntityCreditSchema$inboundSchema: z$1.ZodMiniType<CreateEntityCreditSchema, unknown>;
declare function createEntityCreditSchemaFromJSON(jsonString: string): Result$1<CreateEntityCreditSchema, SDKValidationError>;
/** @internal */
declare const CreateEntityModelMarkups$inboundSchema: z$1.ZodMiniType<CreateEntityModelMarkups, unknown>;
declare function createEntityModelMarkupsFromJSON(jsonString: string): Result$1<CreateEntityModelMarkups, SDKValidationError>;
/** @internal */
declare const CreateEntityProviderMarkups$inboundSchema: z$1.ZodMiniType<CreateEntityProviderMarkups, unknown>;
declare function createEntityProviderMarkupsFromJSON(jsonString: string): Result$1<CreateEntityProviderMarkups, SDKValidationError>;
/** @internal */
declare const CreateEntityDisplay$inboundSchema: z$1.ZodMiniType<CreateEntityDisplay, unknown>;
declare function createEntityDisplayFromJSON(jsonString: string): Result$1<CreateEntityDisplay, SDKValidationError>;
/** @internal */
declare const CreateEntityFeature$inboundSchema: z$1.ZodMiniType<CreateEntityFeature, unknown>;
declare function createEntityFeatureFromJSON(jsonString: string): Result$1<CreateEntityFeature, SDKValidationError>;
/** @internal */
declare const CreateEntityFlags$inboundSchema: z$1.ZodMiniType<CreateEntityFlags, unknown>;
declare function createEntityFlagsFromJSON(jsonString: string): Result$1<CreateEntityFlags, SDKValidationError>;
/** @internal */
declare const CreateEntityLimitTypeResponse$inboundSchema: z$1.ZodMiniType<CreateEntityLimitTypeResponse, unknown>;
/** @internal */
declare const CreateEntitySpendLimitSource$inboundSchema: z$1.ZodMiniType<CreateEntitySpendLimitSource, unknown>;
/** @internal */
declare const CreateEntitySpendLimitResponse$inboundSchema: z$1.ZodMiniType<CreateEntitySpendLimitResponse, unknown>;
declare function createEntitySpendLimitResponseFromJSON(jsonString: string): Result$1<CreateEntitySpendLimitResponse, SDKValidationError>;
/** @internal */
declare const CreateEntityIntervalResponse$inboundSchema: z$1.ZodMiniType<CreateEntityIntervalResponse, unknown>;
/** @internal */
declare const CreateEntityFilterResponse$inboundSchema: z$1.ZodMiniType<CreateEntityFilterResponse, unknown>;
declare function createEntityFilterResponseFromJSON(jsonString: string): Result$1<CreateEntityFilterResponse, SDKValidationError>;
/** @internal */
declare const CreateEntityUsageLimitSource$inboundSchema: z$1.ZodMiniType<CreateEntityUsageLimitSource, unknown>;
/** @internal */
declare const CreateEntityUsageLimitResponse$inboundSchema: z$1.ZodMiniType<CreateEntityUsageLimitResponse, unknown>;
declare function createEntityUsageLimitResponseFromJSON(jsonString: string): Result$1<CreateEntityUsageLimitResponse, SDKValidationError>;
/** @internal */
declare const CreateEntityThresholdTypeResponse$inboundSchema: z$1.ZodMiniType<CreateEntityThresholdTypeResponse, unknown>;
/** @internal */
declare const CreateEntityUsageAlertSource$inboundSchema: z$1.ZodMiniType<CreateEntityUsageAlertSource, unknown>;
/** @internal */
declare const CreateEntityUsageAlertResponse$inboundSchema: z$1.ZodMiniType<CreateEntityUsageAlertResponse, unknown>;
declare function createEntityUsageAlertResponseFromJSON(jsonString: string): Result$1<CreateEntityUsageAlertResponse, SDKValidationError>;
/** @internal */
declare const CreateEntityOverageAllowedSource$inboundSchema: z$1.ZodMiniType<CreateEntityOverageAllowedSource, unknown>;
/** @internal */
declare const CreateEntityOverageAllowedResponse$inboundSchema: z$1.ZodMiniType<CreateEntityOverageAllowedResponse, unknown>;
declare function createEntityOverageAllowedResponseFromJSON(jsonString: string): Result$1<CreateEntityOverageAllowedResponse, SDKValidationError>;
/** @internal */
declare const CreateEntityBillingControlsResponse$inboundSchema: z$1.ZodMiniType<CreateEntityBillingControlsResponse, unknown>;
declare function createEntityBillingControlsResponseFromJSON(jsonString: string): Result$1<CreateEntityBillingControlsResponse, SDKValidationError>;
/** @internal */
declare const CreateEntityProcessorType$inboundSchema: z$1.ZodMiniType<CreateEntityProcessorType, unknown>;
/** @internal */
declare const CreateEntityInvoice$inboundSchema: z$1.ZodMiniType<CreateEntityInvoice, unknown>;
declare function createEntityInvoiceFromJSON(jsonString: string): Result$1<CreateEntityInvoice, SDKValidationError>;
/** @internal */
declare const CreateEntityResponse$inboundSchema: z$1.ZodMiniType<CreateEntityResponse, unknown>;
declare function createEntityResponseFromJSON(jsonString: string): Result$1<CreateEntityResponse, SDKValidationError>;

type CreateFeatureGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system.
 */
declare const CreateFeatureTypeRequestBody: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system.
 */
type CreateFeatureTypeRequestBody = ClosedEnum<typeof CreateFeatureTypeRequestBody>;
/**
 * Singular and plural display names for the feature in your user interface.
 */
type CreateFeatureDisplayRequestBody = {
    singular: string;
    plural: string;
};
type CreateFeatureCreditSchemaRequestBody = {
    meteredFeatureId: string;
    creditCost: number;
};
type CreateFeatureModelMarkupsRequest = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type CreateFeatureProviderMarkupsRequest = {
    markup: number;
};
type CreateFeatureParams = {
    /**
     * The name of the feature.
     */
    name: string;
    /**
     * The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system.
     */
    type: CreateFeatureTypeRequestBody;
    /**
     * Whether this feature is consumable. A consumable feature is one that periodically resets and is consumed rather than allocated (like credits, API requests, etc.). Applicable only for 'metered' features.
     */
    consumable?: boolean | undefined;
    /**
     * Singular and plural display names for the feature in your user interface.
     */
    display?: CreateFeatureDisplayRequestBody | undefined;
    /**
     * A schema that maps 'single_use' feature IDs to credit costs. For classic credit systems only — AI credit systems use model_markups instead.
     */
    creditSchema?: Array<CreateFeatureCreditSchemaRequestBody> | undefined;
    /**
     * Per-model markup overrides for AI credit systems. Maps model IDs to their markup configuration.
     */
    modelMarkups?: {
        [k: string]: CreateFeatureModelMarkupsRequest;
    } | null | undefined;
    /**
     * Default percentage markup for this AI credit system. Used when no model or provider markup applies. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems. Provider keys match the first segment of model_id.
     */
    providerMarkups?: {
        [k: string]: CreateFeatureProviderMarkupsRequest;
    } | null | undefined;
    eventNames?: Array<string> | undefined;
    /**
     * The ID of the feature to create.
     */
    featureId: string;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const CreateFeatureTypeResponse: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type CreateFeatureTypeResponse = OpenEnum<typeof CreateFeatureTypeResponse>;
type CreateFeatureCreditSchemaResponse = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type CreateFeatureModelMarkupsResponse = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type CreateFeatureProviderMarkupsResponse = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type CreateFeatureDisplayResponse = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * OK
 */
type CreateFeatureResponse = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: CreateFeatureTypeResponse;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<CreateFeatureCreditSchemaResponse> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: CreateFeatureModelMarkupsResponse;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: CreateFeatureProviderMarkupsResponse;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: CreateFeatureDisplayResponse | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
/** @internal */
declare const CreateFeatureTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreateFeatureTypeRequestBody>;
/** @internal */
type CreateFeatureDisplayRequestBody$Outbound = {
    singular: string;
    plural: string;
};
/** @internal */
declare const CreateFeatureDisplayRequestBody$outboundSchema: z$1.ZodMiniType<CreateFeatureDisplayRequestBody$Outbound, CreateFeatureDisplayRequestBody>;
declare function createFeatureDisplayRequestBodyToJSON(createFeatureDisplayRequestBody: CreateFeatureDisplayRequestBody): string;
/** @internal */
type CreateFeatureCreditSchemaRequestBody$Outbound = {
    metered_feature_id: string;
    credit_cost: number;
};
/** @internal */
declare const CreateFeatureCreditSchemaRequestBody$outboundSchema: z$1.ZodMiniType<CreateFeatureCreditSchemaRequestBody$Outbound, CreateFeatureCreditSchemaRequestBody>;
declare function createFeatureCreditSchemaRequestBodyToJSON(createFeatureCreditSchemaRequestBody: CreateFeatureCreditSchemaRequestBody): string;
/** @internal */
type CreateFeatureModelMarkupsRequest$Outbound = {
    markup?: number | undefined;
    input_cost?: number | undefined;
    output_cost?: number | undefined;
};
/** @internal */
declare const CreateFeatureModelMarkupsRequest$outboundSchema: z$1.ZodMiniType<CreateFeatureModelMarkupsRequest$Outbound, CreateFeatureModelMarkupsRequest>;
declare function createFeatureModelMarkupsRequestToJSON(createFeatureModelMarkupsRequest: CreateFeatureModelMarkupsRequest): string;
/** @internal */
type CreateFeatureProviderMarkupsRequest$Outbound = {
    markup: number;
};
/** @internal */
declare const CreateFeatureProviderMarkupsRequest$outboundSchema: z$1.ZodMiniType<CreateFeatureProviderMarkupsRequest$Outbound, CreateFeatureProviderMarkupsRequest>;
declare function createFeatureProviderMarkupsRequestToJSON(createFeatureProviderMarkupsRequest: CreateFeatureProviderMarkupsRequest): string;
/** @internal */
type CreateFeatureParams$Outbound = {
    name: string;
    type: string;
    consumable?: boolean | undefined;
    display?: CreateFeatureDisplayRequestBody$Outbound | undefined;
    credit_schema?: Array<CreateFeatureCreditSchemaRequestBody$Outbound> | undefined;
    model_markups?: {
        [k: string]: CreateFeatureModelMarkupsRequest$Outbound;
    } | null | undefined;
    default_markup?: number | undefined;
    provider_markups?: {
        [k: string]: CreateFeatureProviderMarkupsRequest$Outbound;
    } | null | undefined;
    event_names?: Array<string> | undefined;
    feature_id: string;
};
/** @internal */
declare const CreateFeatureParams$outboundSchema: z$1.ZodMiniType<CreateFeatureParams$Outbound, CreateFeatureParams>;
declare function createFeatureParamsToJSON(createFeatureParams: CreateFeatureParams): string;
/** @internal */
declare const CreateFeatureTypeResponse$inboundSchema: z$1.ZodMiniType<CreateFeatureTypeResponse, unknown>;
/** @internal */
declare const CreateFeatureCreditSchemaResponse$inboundSchema: z$1.ZodMiniType<CreateFeatureCreditSchemaResponse, unknown>;
declare function createFeatureCreditSchemaResponseFromJSON(jsonString: string): Result$1<CreateFeatureCreditSchemaResponse, SDKValidationError>;
/** @internal */
declare const CreateFeatureModelMarkupsResponse$inboundSchema: z$1.ZodMiniType<CreateFeatureModelMarkupsResponse, unknown>;
declare function createFeatureModelMarkupsResponseFromJSON(jsonString: string): Result$1<CreateFeatureModelMarkupsResponse, SDKValidationError>;
/** @internal */
declare const CreateFeatureProviderMarkupsResponse$inboundSchema: z$1.ZodMiniType<CreateFeatureProviderMarkupsResponse, unknown>;
declare function createFeatureProviderMarkupsResponseFromJSON(jsonString: string): Result$1<CreateFeatureProviderMarkupsResponse, SDKValidationError>;
/** @internal */
declare const CreateFeatureDisplayResponse$inboundSchema: z$1.ZodMiniType<CreateFeatureDisplayResponse, unknown>;
declare function createFeatureDisplayResponseFromJSON(jsonString: string): Result$1<CreateFeatureDisplayResponse, SDKValidationError>;
/** @internal */
declare const CreateFeatureResponse$inboundSchema: z$1.ZodMiniType<CreateFeatureResponse, unknown>;
declare function createFeatureResponseFromJSON(jsonString: string): Result$1<CreateFeatureResponse, SDKValidationError>;

type CreatePlanGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const CreatePlanPriceIntervalRequestBody: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type CreatePlanPriceIntervalRequestBody = ClosedEnum<typeof CreatePlanPriceIntervalRequestBody>;
/**
 * Base recurring price for the plan. Omit for free or usage-only plans.
 */
type CreatePlanPriceRequestBody = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: CreatePlanPriceIntervalRequestBody;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const CreatePlanResetIntervalRequestBody: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type CreatePlanResetIntervalRequestBody = ClosedEnum<typeof CreatePlanResetIntervalRequestBody>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type CreatePlanResetRequestBody = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: CreatePlanResetIntervalRequestBody;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type CreatePlanToRequestBody = number | string;
type CreatePlanTierRequestBody = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const CreatePlanTierBehaviorRequestBody: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type CreatePlanTierBehaviorRequestBody = ClosedEnum<typeof CreatePlanTierBehaviorRequestBody>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const CreatePlanItemPriceIntervalRequestBody: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type CreatePlanItemPriceIntervalRequestBody = ClosedEnum<typeof CreatePlanItemPriceIntervalRequestBody>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const CreatePlanBillingMethodRequestBody: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type CreatePlanBillingMethodRequestBody = ClosedEnum<typeof CreatePlanBillingMethodRequestBody>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type CreatePlanItemPriceRequestBody = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<CreatePlanTierRequestBody> | undefined;
    tierBehavior?: CreatePlanTierBehaviorRequestBody | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: CreatePlanItemPriceIntervalRequestBody;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: CreatePlanBillingMethodRequestBody;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const CreatePlanItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type CreatePlanItemOnIncrease = ClosedEnum<typeof CreatePlanItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const CreatePlanItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type CreatePlanItemOnDecrease = ClosedEnum<typeof CreatePlanItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type CreatePlanItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: CreatePlanItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: CreatePlanItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const CreatePlanExpiryDurationTypeRequestBody: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type CreatePlanExpiryDurationTypeRequestBody = ClosedEnum<typeof CreatePlanExpiryDurationTypeRequestBody>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type CreatePlanRolloverRequestBody = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: CreatePlanExpiryDurationTypeRequestBody;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type CreatePlanItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: CreatePlanResetRequestBody | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: CreatePlanItemPriceRequestBody | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: CreatePlanItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: CreatePlanRolloverRequestBody | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const CreatePlanDurationTypeRequest: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type CreatePlanDurationTypeRequest = ClosedEnum<typeof CreatePlanDurationTypeRequest>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const CreatePlanOnEndRequest: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type CreatePlanOnEndRequest = ClosedEnum<typeof CreatePlanOnEndRequest>;
/**
 * Free trial configuration. Customers can try this plan before being charged.
 */
type FreeTrialRequest = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: CreatePlanDurationTypeRequest | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: CreatePlanOnEndRequest | undefined;
};
/**
 * Miscellaneous plan-level configuration flags.
 */
type CreatePlanConfigRequest = {
    /**
     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
     */
    ignorePastDue?: boolean | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const CreatePlanPurchaseLimitIntervalRequestBody: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CreatePlanPurchaseLimitIntervalRequestBody = ClosedEnum<typeof CreatePlanPurchaseLimitIntervalRequestBody>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type CreatePlanPurchaseLimitRequest = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CreatePlanPurchaseLimitIntervalRequestBody;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type CreatePlanAutoTopupRequest = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: CreatePlanPurchaseLimitRequest | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CreatePlanLimitTypeRequestBody: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CreatePlanLimitTypeRequestBody = ClosedEnum<typeof CreatePlanLimitTypeRequestBody>;
type CreatePlanSpendLimitRequest = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CreatePlanLimitTypeRequestBody | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CreatePlanUsageLimitIntervalRequestBody: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CreatePlanUsageLimitIntervalRequestBody = ClosedEnum<typeof CreatePlanUsageLimitIntervalRequestBody>;
type CreatePlanProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CreatePlanFilterRequest = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type CreatePlanUsageLimitRequest = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CreatePlanUsageLimitIntervalRequestBody;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CreatePlanFilterRequest | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CreatePlanThresholdTypeRequestBody: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CreatePlanThresholdTypeRequestBody = ClosedEnum<typeof CreatePlanThresholdTypeRequestBody>;
type CreatePlanUsageAlertRequestBody = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CreatePlanThresholdTypeRequestBody;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CreatePlanOverageAllowedRequest = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Plan-level billing controls used as customer defaults.
 */
type CreatePlanBillingControlsRequest = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CreatePlanAutoTopupRequest> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CreatePlanSpendLimitRequest> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<CreatePlanUsageLimitRequest> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CreatePlanUsageAlertRequestBody> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CreatePlanOverageAllowedRequest> | undefined;
};
type CreatePlanParams = {
    /**
     * The ID of the plan to create.
     */
    planId: string;
    /**
     * Group identifier for organizing related plans. Plans in the same group are mutually exclusive.
     */
    group?: string | undefined;
    /**
     * Display name of the plan.
     */
    name: string;
    /**
     * Optional description of the plan.
     */
    description?: string | null | undefined;
    /**
     * If true, this plan can be attached alongside other plans. Otherwise, attaching replaces existing plans in the same group.
     */
    addOn?: boolean | undefined;
    /**
     * If true, plan is automatically attached when a customer is created. Use for free tiers.
     */
    autoEnable?: boolean | undefined;
    /**
     * Base recurring price for the plan. Omit for free or usage-only plans.
     */
    price?: CreatePlanPriceRequestBody | undefined;
    /**
     * Feature configurations for this plan. Each item defines included units, pricing, and reset behavior.
     */
    items?: Array<CreatePlanItemPlanItem> | undefined;
    /**
     * Free trial configuration. Customers can try this plan before being charged.
     */
    freeTrial?: FreeTrialRequest | undefined;
    /**
     * Miscellaneous plan-level configuration flags.
     */
    config?: CreatePlanConfigRequest | undefined;
    /**
     * Plan-level billing controls used as customer defaults.
     */
    billingControls?: CreatePlanBillingControlsRequest | undefined;
    /**
     * Arbitrary key-value metadata defined by you for your own use (e.g. UI copy, feature highlights). Values can be any JSON-serializable value. Shared across all versions of the plan.
     */
    metadata?: {
        [k: string]: any;
    } | undefined;
    createInStripe?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const CreatePlanPriceIntervalResponse: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type CreatePlanPriceIntervalResponse = OpenEnum<typeof CreatePlanPriceIntervalResponse>;
/**
 * Display text for showing this price in pricing pages.
 */
type CreatePlanPriceDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
type CreatePlanPriceResponse = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: CreatePlanPriceIntervalResponse;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Display text for showing this price in pricing pages.
     */
    display?: CreatePlanPriceDisplay | undefined;
};
/**
 * The type of the feature
 */
declare const CreatePlanType: {
    readonly Static: "static";
    readonly Boolean: "boolean";
    readonly SingleUse: "single_use";
    readonly ContinuousUse: "continuous_use";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * The type of the feature
 */
type CreatePlanType = OpenEnum<typeof CreatePlanType>;
type CreatePlanFeatureDisplay = {
    /**
     * The singular display name for the feature.
     */
    singular: string;
    /**
     * The plural display name for the feature.
     */
    plural: string;
};
type CreatePlanCreditSchema = {
    /**
     * The ID of the metered feature (should be a single_use feature).
     */
    meteredFeatureId: string;
    /**
     * The credit cost of the metered feature.
     */
    creditCost: number;
};
/**
 * The full feature object if expanded.
 */
type CreatePlanFeature = {
    /**
     * The ID of the feature, used to refer to it in other API calls like /track or /check.
     */
    id: string;
    /**
     * The name of the feature.
     */
    name?: string | null | undefined;
    /**
     * The type of the feature
     */
    type: CreatePlanType;
    /**
     * Singular and plural display names for the feature.
     */
    display?: CreatePlanFeatureDisplay | null | undefined;
    /**
     * Credit cost schema for credit system features.
     */
    creditSchema?: Array<CreatePlanCreditSchema> | null | undefined;
    /**
     * Whether or not the feature is archived.
     */
    archived?: boolean | null | undefined;
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
declare const CreatePlanResetItemIntervalResponse: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
type CreatePlanResetItemIntervalResponse = OpenEnum<typeof CreatePlanResetItemIntervalResponse>;
type CreatePlanItemResetResponse = {
    /**
     * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
     */
    interval: CreatePlanResetItemIntervalResponse;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type CreatePlanItemToResponse = number | string;
type CreatePlanItemTierResponse = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const CreatePlanItemTierBehaviorResponse: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type CreatePlanItemTierBehaviorResponse = OpenEnum<typeof CreatePlanItemTierBehaviorResponse>;
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
declare const CreatePlanPriceItemIntervalResponse: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
type CreatePlanPriceItemIntervalResponse = OpenEnum<typeof CreatePlanPriceItemIntervalResponse>;
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
declare const CreatePlanItemBillingMethodResponse: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
type CreatePlanItemBillingMethodResponse = OpenEnum<typeof CreatePlanItemBillingMethodResponse>;
type CreatePlanItemPriceResponse = {
    /**
     * Price per billing_units after included usage is consumed. Mutually exclusive with tiers.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing configuration. Each tier's 'to' INCLUDES the included amount. Either 'tiers' or 'amount' is required.
     */
    tiers?: Array<CreatePlanItemTierResponse> | undefined;
    tierBehavior?: CreatePlanItemTierBehaviorResponse | undefined;
    /**
     * Billing interval for this price. For consumable features, should match reset.interval.
     */
    interval: CreatePlanPriceItemIntervalResponse;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Number of units per price increment. Usage is rounded UP to the nearest billing_units when billed (e.g. billing_units=100 means 101 usage rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
     */
    billingMethod: CreatePlanItemBillingMethodResponse;
    /**
     * Maximum units a customer can purchase beyond included. E.g. if included=100 and max_purchase=300, customer can use up to 400 total before usage is capped. Null for no limit.
     */
    maxPurchase: number | null;
};
/**
 * Display text for showing this item in pricing pages.
 */
type CreatePlanItemDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
/**
 * When rolled over units expire.
 */
declare const CreatePlanItemExpiryDurationTypeResponse: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type CreatePlanItemExpiryDurationTypeResponse = OpenEnum<typeof CreatePlanItemExpiryDurationTypeResponse>;
/**
 * Rollover configuration for unused units. If set, unused included units roll over to the next period.
 */
type CreatePlanItemRolloverResponse = {
    /**
     * Maximum rollover units. Null for unlimited rollover.
     */
    max: number | null;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | null | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: CreatePlanItemExpiryDurationTypeResponse;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
type CreatePlanItem = {
    /**
     * The ID of the feature this item configures.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: CreatePlanFeature | undefined;
    /**
     * Number of free units included. For consumable features, balance resets to this number each interval.
     */
    included: number;
    /**
     * Whether the customer has unlimited access to this feature.
     */
    unlimited: boolean;
    /**
     * Reset configuration for consumable features. Null for non-consumable features like seats where usage persists across billing cycles.
     */
    reset: CreatePlanItemResetResponse | null;
    /**
     * Pricing configuration for usage beyond included units. Null if feature is entirely free.
     */
    price: CreatePlanItemPriceResponse | null;
    /**
     * Display text for showing this item in pricing pages.
     */
    display?: CreatePlanItemDisplay | undefined;
    /**
     * Rollover configuration for unused units. If set, unused included units roll over to the next period.
     */
    rollover?: CreatePlanItemRolloverResponse | undefined;
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
declare const CreatePlanDurationTypeResponse: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
type CreatePlanDurationTypeResponse = OpenEnum<typeof CreatePlanDurationTypeResponse>;
declare const CreatePlanOnEndResponse: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
type CreatePlanOnEndResponse = OpenEnum<typeof CreatePlanOnEndResponse>;
/**
 * Free trial configuration. If set, new customers can try this plan before being charged.
 */
type CreatePlanFreeTrialResponse = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial duration ('day', 'month', 'year').
     */
    durationType: CreatePlanDurationTypeResponse;
    /**
     * Whether a payment method is required to start the trial. If true, customer will be charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: CreatePlanOnEndResponse | null | undefined;
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
declare const CreatePlanEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
type CreatePlanEnv = OpenEnum<typeof CreatePlanEnv>;
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const CreatePlanPriceVariantDetailsInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type CreatePlanPriceVariantDetailsInterval = OpenEnum<typeof CreatePlanPriceVariantDetailsInterval>;
/**
 * Base price configuration for a plan.
 */
type CreatePlanBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: CreatePlanPriceVariantDetailsInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const CreatePlanAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type CreatePlanAddItemResetInterval = OpenEnum<typeof CreatePlanAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type CreatePlanVariantDetailsReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: CreatePlanAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type CreatePlanVariantDetailsTo = number | string;
type CreatePlanVariantDetailsTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const CreatePlanVariantDetailsTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type CreatePlanVariantDetailsTierBehavior = OpenEnum<typeof CreatePlanVariantDetailsTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const CreatePlanAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type CreatePlanAddItemPriceInterval = OpenEnum<typeof CreatePlanAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const CreatePlanAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type CreatePlanAddItemBillingMethod = OpenEnum<typeof CreatePlanAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type CreatePlanVariantDetailsPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<CreatePlanVariantDetailsTier> | undefined;
    tierBehavior?: CreatePlanVariantDetailsTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: CreatePlanAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount: number;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: CreatePlanAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const CreatePlanVariantDetailsOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type CreatePlanVariantDetailsOnIncrease = OpenEnum<typeof CreatePlanVariantDetailsOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const CreatePlanVariantDetailsOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type CreatePlanVariantDetailsOnDecrease = OpenEnum<typeof CreatePlanVariantDetailsOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type CreatePlanProrationResponse = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: CreatePlanVariantDetailsOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: CreatePlanVariantDetailsOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const CreatePlanVariantDetailsExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type CreatePlanVariantDetailsExpiryDurationType = OpenEnum<typeof CreatePlanVariantDetailsExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type CreatePlanVariantDetailsRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: CreatePlanVariantDetailsExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type CreatePlanPlanItemResponse = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: CreatePlanVariantDetailsReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: CreatePlanVariantDetailsPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: CreatePlanProrationResponse | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: CreatePlanVariantDetailsRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const CreatePlanRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type CreatePlanRemoveItemBillingMethod = OpenEnum<typeof CreatePlanRemoveItemBillingMethod>;
declare const CreatePlanIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type CreatePlanIntervalRemoveItemEnum2 = OpenEnum<typeof CreatePlanIntervalRemoveItemEnum2>;
declare const CreatePlanIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type CreatePlanIntervalRemoveItemEnum1 = OpenEnum<typeof CreatePlanIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type CreatePlanIntervalUnion = CreatePlanIntervalRemoveItemEnum1 | CreatePlanIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type CreatePlanPlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: CreatePlanRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: CreatePlanIntervalRemoveItemEnum1 | CreatePlanIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const CreatePlanVariantDetailsDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type CreatePlanVariantDetailsDurationType = OpenEnum<typeof CreatePlanVariantDetailsDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const CreatePlanVariantDetailsOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type CreatePlanVariantDetailsOnEnd = OpenEnum<typeof CreatePlanVariantDetailsOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type CreatePlanFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType: CreatePlanVariantDetailsDurationType;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: CreatePlanVariantDetailsOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const CreatePlanVariantDetailsPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CreatePlanVariantDetailsPurchaseLimitInterval = OpenEnum<typeof CreatePlanVariantDetailsPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type CreatePlanVariantDetailsPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CreatePlanVariantDetailsPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type CreatePlanVariantDetailsAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: CreatePlanVariantDetailsPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CreatePlanVariantDetailsLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CreatePlanVariantDetailsLimitType = OpenEnum<typeof CreatePlanVariantDetailsLimitType>;
type CreatePlanVariantDetailsSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CreatePlanVariantDetailsLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CreatePlanVariantDetailsUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CreatePlanVariantDetailsUsageLimitInterval = OpenEnum<typeof CreatePlanVariantDetailsUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CreatePlanVariantDetailsFilter = {
    properties: {
        [k: string]: any;
    };
};
type CreatePlanVariantDetailsUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CreatePlanVariantDetailsUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CreatePlanVariantDetailsFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CreatePlanVariantDetailsThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CreatePlanVariantDetailsThresholdType = OpenEnum<typeof CreatePlanVariantDetailsThresholdType>;
type CreatePlanVariantDetailsUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CreatePlanVariantDetailsThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CreatePlanVariantDetailsOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type CreatePlanVariantDetailsBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CreatePlanVariantDetailsAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CreatePlanVariantDetailsSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<CreatePlanVariantDetailsUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CreatePlanVariantDetailsUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CreatePlanVariantDetailsOverageAllowed> | undefined;
};
/**
 * The customization that transforms the base plan into this variant.
 */
type CreatePlanCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: CreatePlanBasePrice | null | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<CreatePlanPlanItemResponse> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<CreatePlanPlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: CreatePlanFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: CreatePlanVariantDetailsBillingControls | undefined;
};
/**
 * Details about how this variant relates to its latest base plan.
 */
type CreatePlanVariantDetails = {
    /**
     * The ID of the base plan this variant was derived from.
     */
    basePlanId: string;
    /**
     * The customization that transforms the base plan into this variant.
     */
    customize?: CreatePlanCustomize | undefined;
};
/**
 * Miscellaneous plan-level configuration flags.
 */
type CreatePlanConfigResponse = {
    /**
     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
     */
    ignorePastDue: boolean;
};
/**
 * The time interval for the purchase limit window.
 */
declare const CreatePlanPurchaseLimitIntervalResponse: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CreatePlanPurchaseLimitIntervalResponse = OpenEnum<typeof CreatePlanPurchaseLimitIntervalResponse>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type CreatePlanPurchaseLimitResponse = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CreatePlanPurchaseLimitIntervalResponse;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type CreatePlanAutoTopupResponse = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: CreatePlanPurchaseLimitResponse | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CreatePlanLimitTypeResponse: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CreatePlanLimitTypeResponse = OpenEnum<typeof CreatePlanLimitTypeResponse>;
type CreatePlanSpendLimitResponse = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CreatePlanLimitTypeResponse | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CreatePlanUsageLimitIntervalResponse: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CreatePlanUsageLimitIntervalResponse = OpenEnum<typeof CreatePlanUsageLimitIntervalResponse>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CreatePlanFilterResponse = {
    properties: {
        [k: string]: any;
    };
};
type CreatePlanUsageLimitResponse = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CreatePlanUsageLimitIntervalResponse;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CreatePlanFilterResponse | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CreatePlanThresholdTypeResponse: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CreatePlanThresholdTypeResponse = OpenEnum<typeof CreatePlanThresholdTypeResponse>;
type CreatePlanUsageAlertResponse = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CreatePlanThresholdTypeResponse;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CreatePlanOverageAllowedResponse = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Plan-level billing controls used as customer defaults.
 */
type CreatePlanBillingControlsResponse = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CreatePlanAutoTopupResponse> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CreatePlanSpendLimitResponse> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<CreatePlanUsageLimitResponse> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CreatePlanUsageAlertResponse> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CreatePlanOverageAllowedResponse> | undefined;
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
declare const CreatePlanStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
type CreatePlanStatus = OpenEnum<typeof CreatePlanStatus>;
/**
 * The action that would occur if this plan were attached to the customer.
 */
declare const CreatePlanAttachAction: {
    readonly Activate: "activate";
    readonly Upgrade: "upgrade";
    readonly Downgrade: "downgrade";
    readonly None: "none";
    readonly Purchase: "purchase";
};
/**
 * The action that would occur if this plan were attached to the customer.
 */
type CreatePlanAttachAction = OpenEnum<typeof CreatePlanAttachAction>;
type CreatePlanCustomerEligibility = {
    /**
     * Whether the trial on this plan is available to this customer. For example, if the customer used the trial in the past, this will be false.
     */
    trialAvailable?: boolean | undefined;
    /**
     * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
     */
    status?: CreatePlanStatus | undefined;
    /**
     * Whether the customer's active instance of this plan is set to cancel.
     */
    canceling?: boolean | undefined;
    /**
     * Whether the customer is currently on a free trial of this plan.
     */
    trialing?: boolean | undefined;
    /**
     * The action that would occur if this plan were attached to the customer.
     */
    attachAction: CreatePlanAttachAction;
};
/**
 * A plan defines a set of features, pricing, and entitlements that can be attached to customers.
 */
type CreatePlanResponse = {
    /**
     * Unique identifier for the plan.
     */
    id: string;
    /**
     * Display name of the plan.
     */
    name: string;
    /**
     * Optional description of the plan.
     */
    description: string | null;
    /**
     * Group identifier for organizing related plans. Plans in the same group are mutually exclusive.
     */
    group: string | null;
    /**
     * Version number of the plan. Incremented when plan configuration changes.
     */
    version: number;
    /**
     * Whether this is an add-on plan that can be attached alongside a main plan.
     */
    addOn: boolean;
    /**
     * If true, this plan is automatically attached when a customer is created. Used for free plans.
     */
    autoEnable: boolean;
    /**
     * Base recurring price for the plan. Null for free plans or usage-only plans.
     */
    price: CreatePlanPriceResponse | null;
    /**
     * Feature configurations included in this plan. Each item defines included units, pricing, and reset behavior for a feature.
     */
    items: Array<CreatePlanItem>;
    /**
     * Free trial configuration. If set, new customers can try this plan before being charged.
     */
    freeTrial?: CreatePlanFreeTrialResponse | undefined;
    /**
     * Unix timestamp (ms) when the plan was created.
     */
    createdAt: number;
    /**
     * Environment this plan belongs to ('sandbox' or 'live').
     */
    env: CreatePlanEnv;
    /**
     * Whether the plan is archived. Archived plans cannot be attached to new customers.
     */
    archived: boolean;
    /**
     * Deprecated. Use variant_details.base_plan_id instead. If this is a variant, the ID of the base plan it was created from.
     */
    baseVariantId: string | null;
    /**
     * Details about how this variant relates to its latest base plan.
     */
    variantDetails?: CreatePlanVariantDetails | undefined;
    /**
     * Miscellaneous plan-level configuration flags.
     */
    config: CreatePlanConfigResponse;
    /**
     * Plan-level billing controls used as customer defaults.
     */
    billingControls?: CreatePlanBillingControlsResponse | undefined;
    /**
     * Arbitrary key-value metadata defined by you for your own use. Shared across all versions of the plan.
     */
    metadata: {
        [k: string]: any;
    };
    customerEligibility?: CreatePlanCustomerEligibility | undefined;
};
/** @internal */
declare const CreatePlanPriceIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanPriceIntervalRequestBody>;
/** @internal */
type CreatePlanPriceRequestBody$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const CreatePlanPriceRequestBody$outboundSchema: z$1.ZodMiniType<CreatePlanPriceRequestBody$Outbound, CreatePlanPriceRequestBody>;
declare function createPlanPriceRequestBodyToJSON(createPlanPriceRequestBody: CreatePlanPriceRequestBody): string;
/** @internal */
declare const CreatePlanResetIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanResetIntervalRequestBody>;
/** @internal */
type CreatePlanResetRequestBody$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const CreatePlanResetRequestBody$outboundSchema: z$1.ZodMiniType<CreatePlanResetRequestBody$Outbound, CreatePlanResetRequestBody>;
declare function createPlanResetRequestBodyToJSON(createPlanResetRequestBody: CreatePlanResetRequestBody): string;
/** @internal */
type CreatePlanToRequestBody$Outbound = number | string;
/** @internal */
declare const CreatePlanToRequestBody$outboundSchema: z$1.ZodMiniType<CreatePlanToRequestBody$Outbound, CreatePlanToRequestBody>;
declare function createPlanToRequestBodyToJSON(createPlanToRequestBody: CreatePlanToRequestBody): string;
/** @internal */
type CreatePlanTierRequestBody$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const CreatePlanTierRequestBody$outboundSchema: z$1.ZodMiniType<CreatePlanTierRequestBody$Outbound, CreatePlanTierRequestBody>;
declare function createPlanTierRequestBodyToJSON(createPlanTierRequestBody: CreatePlanTierRequestBody): string;
/** @internal */
declare const CreatePlanTierBehaviorRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanTierBehaviorRequestBody>;
/** @internal */
declare const CreatePlanItemPriceIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanItemPriceIntervalRequestBody>;
/** @internal */
declare const CreatePlanBillingMethodRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanBillingMethodRequestBody>;
/** @internal */
type CreatePlanItemPriceRequestBody$Outbound = {
    amount?: number | undefined;
    tiers?: Array<CreatePlanTierRequestBody$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const CreatePlanItemPriceRequestBody$outboundSchema: z$1.ZodMiniType<CreatePlanItemPriceRequestBody$Outbound, CreatePlanItemPriceRequestBody>;
declare function createPlanItemPriceRequestBodyToJSON(createPlanItemPriceRequestBody: CreatePlanItemPriceRequestBody): string;
/** @internal */
declare const CreatePlanItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanItemOnIncrease>;
/** @internal */
declare const CreatePlanItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanItemOnDecrease>;
/** @internal */
type CreatePlanItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const CreatePlanItemProration$outboundSchema: z$1.ZodMiniType<CreatePlanItemProration$Outbound, CreatePlanItemProration>;
declare function createPlanItemProrationToJSON(createPlanItemProration: CreatePlanItemProration): string;
/** @internal */
declare const CreatePlanExpiryDurationTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanExpiryDurationTypeRequestBody>;
/** @internal */
type CreatePlanRolloverRequestBody$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const CreatePlanRolloverRequestBody$outboundSchema: z$1.ZodMiniType<CreatePlanRolloverRequestBody$Outbound, CreatePlanRolloverRequestBody>;
declare function createPlanRolloverRequestBodyToJSON(createPlanRolloverRequestBody: CreatePlanRolloverRequestBody): string;
/** @internal */
type CreatePlanItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: CreatePlanResetRequestBody$Outbound | undefined;
    price?: CreatePlanItemPriceRequestBody$Outbound | undefined;
    proration?: CreatePlanItemProration$Outbound | undefined;
    rollover?: CreatePlanRolloverRequestBody$Outbound | undefined;
};
/** @internal */
declare const CreatePlanItemPlanItem$outboundSchema: z$1.ZodMiniType<CreatePlanItemPlanItem$Outbound, CreatePlanItemPlanItem>;
declare function createPlanItemPlanItemToJSON(createPlanItemPlanItem: CreatePlanItemPlanItem): string;
/** @internal */
declare const CreatePlanDurationTypeRequest$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanDurationTypeRequest>;
/** @internal */
declare const CreatePlanOnEndRequest$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanOnEndRequest>;
/** @internal */
type FreeTrialRequest$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const FreeTrialRequest$outboundSchema: z$1.ZodMiniType<FreeTrialRequest$Outbound, FreeTrialRequest>;
declare function freeTrialRequestToJSON(freeTrialRequest: FreeTrialRequest): string;
/** @internal */
type CreatePlanConfigRequest$Outbound = {
    ignore_past_due: boolean;
};
/** @internal */
declare const CreatePlanConfigRequest$outboundSchema: z$1.ZodMiniType<CreatePlanConfigRequest$Outbound, CreatePlanConfigRequest>;
declare function createPlanConfigRequestToJSON(createPlanConfigRequest: CreatePlanConfigRequest): string;
/** @internal */
declare const CreatePlanPurchaseLimitIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanPurchaseLimitIntervalRequestBody>;
/** @internal */
type CreatePlanPurchaseLimitRequest$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const CreatePlanPurchaseLimitRequest$outboundSchema: z$1.ZodMiniType<CreatePlanPurchaseLimitRequest$Outbound, CreatePlanPurchaseLimitRequest>;
declare function createPlanPurchaseLimitRequestToJSON(createPlanPurchaseLimitRequest: CreatePlanPurchaseLimitRequest): string;
/** @internal */
type CreatePlanAutoTopupRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: CreatePlanPurchaseLimitRequest$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const CreatePlanAutoTopupRequest$outboundSchema: z$1.ZodMiniType<CreatePlanAutoTopupRequest$Outbound, CreatePlanAutoTopupRequest>;
declare function createPlanAutoTopupRequestToJSON(createPlanAutoTopupRequest: CreatePlanAutoTopupRequest): string;
/** @internal */
declare const CreatePlanLimitTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanLimitTypeRequestBody>;
/** @internal */
type CreatePlanSpendLimitRequest$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const CreatePlanSpendLimitRequest$outboundSchema: z$1.ZodMiniType<CreatePlanSpendLimitRequest$Outbound, CreatePlanSpendLimitRequest>;
declare function createPlanSpendLimitRequestToJSON(createPlanSpendLimitRequest: CreatePlanSpendLimitRequest): string;
/** @internal */
declare const CreatePlanUsageLimitIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanUsageLimitIntervalRequestBody>;
/** @internal */
type CreatePlanProperties$Outbound = string | number | boolean;
/** @internal */
declare const CreatePlanProperties$outboundSchema: z$1.ZodMiniType<CreatePlanProperties$Outbound, CreatePlanProperties>;
declare function createPlanPropertiesToJSON(createPlanProperties: CreatePlanProperties): string;
/** @internal */
type CreatePlanFilterRequest$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const CreatePlanFilterRequest$outboundSchema: z$1.ZodMiniType<CreatePlanFilterRequest$Outbound, CreatePlanFilterRequest>;
declare function createPlanFilterRequestToJSON(createPlanFilterRequest: CreatePlanFilterRequest): string;
/** @internal */
type CreatePlanUsageLimitRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: CreatePlanFilterRequest$Outbound | undefined;
};
/** @internal */
declare const CreatePlanUsageLimitRequest$outboundSchema: z$1.ZodMiniType<CreatePlanUsageLimitRequest$Outbound, CreatePlanUsageLimitRequest>;
declare function createPlanUsageLimitRequestToJSON(createPlanUsageLimitRequest: CreatePlanUsageLimitRequest): string;
/** @internal */
declare const CreatePlanThresholdTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof CreatePlanThresholdTypeRequestBody>;
/** @internal */
type CreatePlanUsageAlertRequestBody$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const CreatePlanUsageAlertRequestBody$outboundSchema: z$1.ZodMiniType<CreatePlanUsageAlertRequestBody$Outbound, CreatePlanUsageAlertRequestBody>;
declare function createPlanUsageAlertRequestBodyToJSON(createPlanUsageAlertRequestBody: CreatePlanUsageAlertRequestBody): string;
/** @internal */
type CreatePlanOverageAllowedRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const CreatePlanOverageAllowedRequest$outboundSchema: z$1.ZodMiniType<CreatePlanOverageAllowedRequest$Outbound, CreatePlanOverageAllowedRequest>;
declare function createPlanOverageAllowedRequestToJSON(createPlanOverageAllowedRequest: CreatePlanOverageAllowedRequest): string;
/** @internal */
type CreatePlanBillingControlsRequest$Outbound = {
    auto_topups?: Array<CreatePlanAutoTopupRequest$Outbound> | undefined;
    spend_limits?: Array<CreatePlanSpendLimitRequest$Outbound> | undefined;
    usage_limits?: Array<CreatePlanUsageLimitRequest$Outbound> | undefined;
    usage_alerts?: Array<CreatePlanUsageAlertRequestBody$Outbound> | undefined;
    overage_allowed?: Array<CreatePlanOverageAllowedRequest$Outbound> | undefined;
};
/** @internal */
declare const CreatePlanBillingControlsRequest$outboundSchema: z$1.ZodMiniType<CreatePlanBillingControlsRequest$Outbound, CreatePlanBillingControlsRequest>;
declare function createPlanBillingControlsRequestToJSON(createPlanBillingControlsRequest: CreatePlanBillingControlsRequest): string;
/** @internal */
type CreatePlanParams$Outbound = {
    plan_id: string;
    group: string;
    name: string;
    description?: string | null | undefined;
    add_on: boolean;
    auto_enable: boolean;
    price?: CreatePlanPriceRequestBody$Outbound | undefined;
    items?: Array<CreatePlanItemPlanItem$Outbound> | undefined;
    free_trial?: FreeTrialRequest$Outbound | undefined;
    config?: CreatePlanConfigRequest$Outbound | undefined;
    billing_controls?: CreatePlanBillingControlsRequest$Outbound | undefined;
    metadata?: {
        [k: string]: any;
    } | undefined;
    create_in_stripe: boolean;
};
/** @internal */
declare const CreatePlanParams$outboundSchema: z$1.ZodMiniType<CreatePlanParams$Outbound, CreatePlanParams>;
declare function createPlanParamsToJSON(createPlanParams: CreatePlanParams): string;
/** @internal */
declare const CreatePlanPriceIntervalResponse$inboundSchema: z$1.ZodMiniType<CreatePlanPriceIntervalResponse, unknown>;
/** @internal */
declare const CreatePlanPriceDisplay$inboundSchema: z$1.ZodMiniType<CreatePlanPriceDisplay, unknown>;
declare function createPlanPriceDisplayFromJSON(jsonString: string): Result$1<CreatePlanPriceDisplay, SDKValidationError>;
/** @internal */
declare const CreatePlanPriceResponse$inboundSchema: z$1.ZodMiniType<CreatePlanPriceResponse, unknown>;
declare function createPlanPriceResponseFromJSON(jsonString: string): Result$1<CreatePlanPriceResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanType$inboundSchema: z$1.ZodMiniType<CreatePlanType, unknown>;
/** @internal */
declare const CreatePlanFeatureDisplay$inboundSchema: z$1.ZodMiniType<CreatePlanFeatureDisplay, unknown>;
declare function createPlanFeatureDisplayFromJSON(jsonString: string): Result$1<CreatePlanFeatureDisplay, SDKValidationError>;
/** @internal */
declare const CreatePlanCreditSchema$inboundSchema: z$1.ZodMiniType<CreatePlanCreditSchema, unknown>;
declare function createPlanCreditSchemaFromJSON(jsonString: string): Result$1<CreatePlanCreditSchema, SDKValidationError>;
/** @internal */
declare const CreatePlanFeature$inboundSchema: z$1.ZodMiniType<CreatePlanFeature, unknown>;
declare function createPlanFeatureFromJSON(jsonString: string): Result$1<CreatePlanFeature, SDKValidationError>;
/** @internal */
declare const CreatePlanResetItemIntervalResponse$inboundSchema: z$1.ZodMiniType<CreatePlanResetItemIntervalResponse, unknown>;
/** @internal */
declare const CreatePlanItemResetResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemResetResponse, unknown>;
declare function createPlanItemResetResponseFromJSON(jsonString: string): Result$1<CreatePlanItemResetResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanItemToResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemToResponse, unknown>;
declare function createPlanItemToResponseFromJSON(jsonString: string): Result$1<CreatePlanItemToResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanItemTierResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemTierResponse, unknown>;
declare function createPlanItemTierResponseFromJSON(jsonString: string): Result$1<CreatePlanItemTierResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanItemTierBehaviorResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemTierBehaviorResponse, unknown>;
/** @internal */
declare const CreatePlanPriceItemIntervalResponse$inboundSchema: z$1.ZodMiniType<CreatePlanPriceItemIntervalResponse, unknown>;
/** @internal */
declare const CreatePlanItemBillingMethodResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemBillingMethodResponse, unknown>;
/** @internal */
declare const CreatePlanItemPriceResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemPriceResponse, unknown>;
declare function createPlanItemPriceResponseFromJSON(jsonString: string): Result$1<CreatePlanItemPriceResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanItemDisplay$inboundSchema: z$1.ZodMiniType<CreatePlanItemDisplay, unknown>;
declare function createPlanItemDisplayFromJSON(jsonString: string): Result$1<CreatePlanItemDisplay, SDKValidationError>;
/** @internal */
declare const CreatePlanItemExpiryDurationTypeResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemExpiryDurationTypeResponse, unknown>;
/** @internal */
declare const CreatePlanItemRolloverResponse$inboundSchema: z$1.ZodMiniType<CreatePlanItemRolloverResponse, unknown>;
declare function createPlanItemRolloverResponseFromJSON(jsonString: string): Result$1<CreatePlanItemRolloverResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanItem$inboundSchema: z$1.ZodMiniType<CreatePlanItem, unknown>;
declare function createPlanItemFromJSON(jsonString: string): Result$1<CreatePlanItem, SDKValidationError>;
/** @internal */
declare const CreatePlanDurationTypeResponse$inboundSchema: z$1.ZodMiniType<CreatePlanDurationTypeResponse, unknown>;
/** @internal */
declare const CreatePlanOnEndResponse$inboundSchema: z$1.ZodMiniType<CreatePlanOnEndResponse, unknown>;
/** @internal */
declare const CreatePlanFreeTrialResponse$inboundSchema: z$1.ZodMiniType<CreatePlanFreeTrialResponse, unknown>;
declare function createPlanFreeTrialResponseFromJSON(jsonString: string): Result$1<CreatePlanFreeTrialResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanEnv$inboundSchema: z$1.ZodMiniType<CreatePlanEnv, unknown>;
/** @internal */
declare const CreatePlanPriceVariantDetailsInterval$inboundSchema: z$1.ZodMiniType<CreatePlanPriceVariantDetailsInterval, unknown>;
/** @internal */
declare const CreatePlanBasePrice$inboundSchema: z$1.ZodMiniType<CreatePlanBasePrice, unknown>;
declare function createPlanBasePriceFromJSON(jsonString: string): Result$1<CreatePlanBasePrice, SDKValidationError>;
/** @internal */
declare const CreatePlanAddItemResetInterval$inboundSchema: z$1.ZodMiniType<CreatePlanAddItemResetInterval, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsReset$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsReset, unknown>;
declare function createPlanVariantDetailsResetFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsReset, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsTo$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsTo, unknown>;
declare function createPlanVariantDetailsToFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsTo, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsTier$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsTier, unknown>;
declare function createPlanVariantDetailsTierFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsTier, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsTierBehavior$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsTierBehavior, unknown>;
/** @internal */
declare const CreatePlanAddItemPriceInterval$inboundSchema: z$1.ZodMiniType<CreatePlanAddItemPriceInterval, unknown>;
/** @internal */
declare const CreatePlanAddItemBillingMethod$inboundSchema: z$1.ZodMiniType<CreatePlanAddItemBillingMethod, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsPrice$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsPrice, unknown>;
declare function createPlanVariantDetailsPriceFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsPrice, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsOnIncrease$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsOnIncrease, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsOnDecrease$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsOnDecrease, unknown>;
/** @internal */
declare const CreatePlanProrationResponse$inboundSchema: z$1.ZodMiniType<CreatePlanProrationResponse, unknown>;
declare function createPlanProrationResponseFromJSON(jsonString: string): Result$1<CreatePlanProrationResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsExpiryDurationType$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsExpiryDurationType, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsRollover$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsRollover, unknown>;
declare function createPlanVariantDetailsRolloverFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsRollover, SDKValidationError>;
/** @internal */
declare const CreatePlanPlanItemResponse$inboundSchema: z$1.ZodMiniType<CreatePlanPlanItemResponse, unknown>;
declare function createPlanPlanItemResponseFromJSON(jsonString: string): Result$1<CreatePlanPlanItemResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanRemoveItemBillingMethod$inboundSchema: z$1.ZodMiniType<CreatePlanRemoveItemBillingMethod, unknown>;
/** @internal */
declare const CreatePlanIntervalRemoveItemEnum2$inboundSchema: z$1.ZodMiniType<CreatePlanIntervalRemoveItemEnum2, unknown>;
/** @internal */
declare const CreatePlanIntervalRemoveItemEnum1$inboundSchema: z$1.ZodMiniType<CreatePlanIntervalRemoveItemEnum1, unknown>;
/** @internal */
declare const CreatePlanIntervalUnion$inboundSchema: z$1.ZodMiniType<CreatePlanIntervalUnion, unknown>;
declare function createPlanIntervalUnionFromJSON(jsonString: string): Result$1<CreatePlanIntervalUnion, SDKValidationError>;
/** @internal */
declare const CreatePlanPlanItemFilter$inboundSchema: z$1.ZodMiniType<CreatePlanPlanItemFilter, unknown>;
declare function createPlanPlanItemFilterFromJSON(jsonString: string): Result$1<CreatePlanPlanItemFilter, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsDurationType$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsDurationType, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsOnEnd$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsOnEnd, unknown>;
/** @internal */
declare const CreatePlanFreeTrialParams$inboundSchema: z$1.ZodMiniType<CreatePlanFreeTrialParams, unknown>;
declare function createPlanFreeTrialParamsFromJSON(jsonString: string): Result$1<CreatePlanFreeTrialParams, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsPurchaseLimitInterval, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsPurchaseLimit$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsPurchaseLimit, unknown>;
declare function createPlanVariantDetailsPurchaseLimitFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsPurchaseLimit, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsAutoTopup$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsAutoTopup, unknown>;
declare function createPlanVariantDetailsAutoTopupFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsAutoTopup, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsLimitType$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsLimitType, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsSpendLimit$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsSpendLimit, unknown>;
declare function createPlanVariantDetailsSpendLimitFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsSpendLimit, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsUsageLimitInterval$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsUsageLimitInterval, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsFilter$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsFilter, unknown>;
declare function createPlanVariantDetailsFilterFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsFilter, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsUsageLimit$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsUsageLimit, unknown>;
declare function createPlanVariantDetailsUsageLimitFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsUsageLimit, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsThresholdType$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsThresholdType, unknown>;
/** @internal */
declare const CreatePlanVariantDetailsUsageAlert$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsUsageAlert, unknown>;
declare function createPlanVariantDetailsUsageAlertFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsUsageAlert, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsOverageAllowed$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsOverageAllowed, unknown>;
declare function createPlanVariantDetailsOverageAllowedFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsOverageAllowed, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetailsBillingControls$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetailsBillingControls, unknown>;
declare function createPlanVariantDetailsBillingControlsFromJSON(jsonString: string): Result$1<CreatePlanVariantDetailsBillingControls, SDKValidationError>;
/** @internal */
declare const CreatePlanCustomize$inboundSchema: z$1.ZodMiniType<CreatePlanCustomize, unknown>;
declare function createPlanCustomizeFromJSON(jsonString: string): Result$1<CreatePlanCustomize, SDKValidationError>;
/** @internal */
declare const CreatePlanVariantDetails$inboundSchema: z$1.ZodMiniType<CreatePlanVariantDetails, unknown>;
declare function createPlanVariantDetailsFromJSON(jsonString: string): Result$1<CreatePlanVariantDetails, SDKValidationError>;
/** @internal */
declare const CreatePlanConfigResponse$inboundSchema: z$1.ZodMiniType<CreatePlanConfigResponse, unknown>;
declare function createPlanConfigResponseFromJSON(jsonString: string): Result$1<CreatePlanConfigResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanPurchaseLimitIntervalResponse$inboundSchema: z$1.ZodMiniType<CreatePlanPurchaseLimitIntervalResponse, unknown>;
/** @internal */
declare const CreatePlanPurchaseLimitResponse$inboundSchema: z$1.ZodMiniType<CreatePlanPurchaseLimitResponse, unknown>;
declare function createPlanPurchaseLimitResponseFromJSON(jsonString: string): Result$1<CreatePlanPurchaseLimitResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanAutoTopupResponse$inboundSchema: z$1.ZodMiniType<CreatePlanAutoTopupResponse, unknown>;
declare function createPlanAutoTopupResponseFromJSON(jsonString: string): Result$1<CreatePlanAutoTopupResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanLimitTypeResponse$inboundSchema: z$1.ZodMiniType<CreatePlanLimitTypeResponse, unknown>;
/** @internal */
declare const CreatePlanSpendLimitResponse$inboundSchema: z$1.ZodMiniType<CreatePlanSpendLimitResponse, unknown>;
declare function createPlanSpendLimitResponseFromJSON(jsonString: string): Result$1<CreatePlanSpendLimitResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanUsageLimitIntervalResponse$inboundSchema: z$1.ZodMiniType<CreatePlanUsageLimitIntervalResponse, unknown>;
/** @internal */
declare const CreatePlanFilterResponse$inboundSchema: z$1.ZodMiniType<CreatePlanFilterResponse, unknown>;
declare function createPlanFilterResponseFromJSON(jsonString: string): Result$1<CreatePlanFilterResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanUsageLimitResponse$inboundSchema: z$1.ZodMiniType<CreatePlanUsageLimitResponse, unknown>;
declare function createPlanUsageLimitResponseFromJSON(jsonString: string): Result$1<CreatePlanUsageLimitResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanThresholdTypeResponse$inboundSchema: z$1.ZodMiniType<CreatePlanThresholdTypeResponse, unknown>;
/** @internal */
declare const CreatePlanUsageAlertResponse$inboundSchema: z$1.ZodMiniType<CreatePlanUsageAlertResponse, unknown>;
declare function createPlanUsageAlertResponseFromJSON(jsonString: string): Result$1<CreatePlanUsageAlertResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanOverageAllowedResponse$inboundSchema: z$1.ZodMiniType<CreatePlanOverageAllowedResponse, unknown>;
declare function createPlanOverageAllowedResponseFromJSON(jsonString: string): Result$1<CreatePlanOverageAllowedResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanBillingControlsResponse$inboundSchema: z$1.ZodMiniType<CreatePlanBillingControlsResponse, unknown>;
declare function createPlanBillingControlsResponseFromJSON(jsonString: string): Result$1<CreatePlanBillingControlsResponse, SDKValidationError>;
/** @internal */
declare const CreatePlanStatus$inboundSchema: z$1.ZodMiniType<CreatePlanStatus, unknown>;
/** @internal */
declare const CreatePlanAttachAction$inboundSchema: z$1.ZodMiniType<CreatePlanAttachAction, unknown>;
/** @internal */
declare const CreatePlanCustomerEligibility$inboundSchema: z$1.ZodMiniType<CreatePlanCustomerEligibility, unknown>;
declare function createPlanCustomerEligibilityFromJSON(jsonString: string): Result$1<CreatePlanCustomerEligibility, SDKValidationError>;
/** @internal */
declare const CreatePlanResponse$inboundSchema: z$1.ZodMiniType<CreatePlanResponse, unknown>;
declare function createPlanResponseFromJSON(jsonString: string): Result$1<CreatePlanResponse, SDKValidationError>;

type CreateReferralCodeGlobals = {
    xApiVersion?: string | undefined;
};
type CreateReferralCodeParams = {
    /**
     * The unique identifier of the customer
     */
    customerId: string;
    /**
     * ID of your referral program
     */
    programId: string;
};
/**
 * OK
 */
type CreateReferralCodeResponse = {
    /**
     * The referral code that can be shared with customers
     */
    code: string;
    /**
     * Your unique identifier for the customer
     */
    customerId: string;
    /**
     * The timestamp of when the referral code was created
     */
    createdAt: number;
};
/** @internal */
type CreateReferralCodeParams$Outbound = {
    customer_id: string;
    program_id: string;
};
/** @internal */
declare const CreateReferralCodeParams$outboundSchema: z$1.ZodMiniType<CreateReferralCodeParams$Outbound, CreateReferralCodeParams>;
declare function createReferralCodeParamsToJSON(createReferralCodeParams: CreateReferralCodeParams): string;
/** @internal */
declare const CreateReferralCodeResponse$inboundSchema: z$1.ZodMiniType<CreateReferralCodeResponse, unknown>;
declare function createReferralCodeResponseFromJSON(jsonString: string): Result$1<CreateReferralCodeResponse, SDKValidationError>;

type CreateScheduleGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Invoice mode creates and sends an invoice instead of charging the customer's payment method immediately for the first phase.
 */
type CreateScheduleInvoiceMode = {
    /**
     * When true, creates an invoice and sends it to the customer instead of charging their card immediately. Uses Stripe's send_invoice collection method.
     */
    enabled: boolean;
    /**
     * If true, enables the plan immediately even though the invoice is not paid yet.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * If true, finalizes the invoice so it can be sent to the customer. If false, keeps it as a draft for manual review.
     */
    finalize?: boolean | undefined;
    /**
     * ID of an invoice template (configured in billing settings) whose footer (e.g. bank details) is applied to the invoice.
     */
    invoiceTemplateId?: string | undefined;
    /**
     * Number of days the customer has to pay the invoice before it is due (Stripe days_until_due).
     */
    netTermsDays?: number | undefined;
};
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type CreateScheduleAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
/**
 * Controls when to return a checkout URL for the immediate phase. 'always' forces a confirmation or checkout flow, 'if_required' only redirects when needed, and 'never' disables redirects.
 */
declare const CreateScheduleRedirectMode: {
    readonly Always: "always";
    readonly IfRequired: "if_required";
    readonly Never: "never";
};
/**
 * Controls when to return a checkout URL for the immediate phase. 'always' forces a confirmation or checkout flow, 'if_required' only redirects when needed, and 'never' disables redirects.
 */
type CreateScheduleRedirectMode = ClosedEnum<typeof CreateScheduleRedirectMode>;
/**
 * Whether to prorate the immediate phase. 'none' skips proration charges and credits.
 */
declare const CreateScheduleBillingBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * Whether to prorate the immediate phase. 'none' skips proration charges and credits.
 */
type CreateScheduleBillingBehavior = ClosedEnum<typeof CreateScheduleBillingBehavior>;
/**
 * When this phase should start, in epoch milliseconds, or 'now' for the immediate phase.
 */
type StartsAt2 = number | string;
/**
 * The duration unit to offset this phase from the prior phase.
 */
declare const CreateScheduleDurationType2: {
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * The duration unit to offset this phase from the prior phase.
 */
type CreateScheduleDurationType2 = ClosedEnum<typeof CreateScheduleDurationType2>;
/**
 * Relative start offset from the previous resolved schedule phase.
 */
type StartingAfter2 = {
    /**
     * The duration unit to offset this phase from the prior phase.
     */
    durationType: CreateScheduleDurationType2;
    /**
     * How many duration_type periods after the prior phase to start.
     */
    durationCount: number;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type CreateScheduleFeatureQuantity2 = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const CreateSchedulePriceInterval2: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type CreateSchedulePriceInterval2 = ClosedEnum<typeof CreateSchedulePriceInterval2>;
/**
 * Base price configuration for a plan.
 */
type CreateScheduleBasePrice2 = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: CreateSchedulePriceInterval2;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const CreateScheduleItemResetInterval2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type CreateScheduleItemResetInterval2 = ClosedEnum<typeof CreateScheduleItemResetInterval2>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type CreateScheduleItemReset2 = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: CreateScheduleItemResetInterval2;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type CreateScheduleItemTier2 = {
    to?: any | undefined;
    amount?: any | undefined;
    flatAmount?: any | undefined;
};
declare const CreateScheduleItemTierBehavior2: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type CreateScheduleItemTierBehavior2 = ClosedEnum<typeof CreateScheduleItemTierBehavior2>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const CreateScheduleItemPriceInterval2: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type CreateScheduleItemPriceInterval2 = ClosedEnum<typeof CreateScheduleItemPriceInterval2>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const CreateScheduleItemBillingMethod2: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type CreateScheduleItemBillingMethod2 = ClosedEnum<typeof CreateScheduleItemBillingMethod2>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type CreateScheduleItemPrice2 = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<CreateScheduleItemTier2> | undefined;
    tierBehavior?: CreateScheduleItemTierBehavior2 | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: CreateScheduleItemPriceInterval2;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: CreateScheduleItemBillingMethod2;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const CreateScheduleItemOnIncrease2: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type CreateScheduleItemOnIncrease2 = ClosedEnum<typeof CreateScheduleItemOnIncrease2>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const CreateScheduleItemOnDecrease2: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type CreateScheduleItemOnDecrease2 = ClosedEnum<typeof CreateScheduleItemOnDecrease2>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type CreateScheduleItemProration2 = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: CreateScheduleItemOnIncrease2;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: CreateScheduleItemOnDecrease2;
};
/**
 * When rolled over units expire.
 */
declare const CreateScheduleItemExpiryDurationType2: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type CreateScheduleItemExpiryDurationType2 = ClosedEnum<typeof CreateScheduleItemExpiryDurationType2>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type CreateScheduleItemRollover2 = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: CreateScheduleItemExpiryDurationType2;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type CreateScheduleItemPlanItem2 = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: CreateScheduleItemReset2 | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: CreateScheduleItemPrice2 | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: CreateScheduleItemProration2 | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: CreateScheduleItemRollover2 | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const CreateScheduleAddItemResetInterval2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type CreateScheduleAddItemResetInterval2 = ClosedEnum<typeof CreateScheduleAddItemResetInterval2>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type CreateScheduleAddItemReset2 = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: CreateScheduleAddItemResetInterval2;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type CreateScheduleAddItemTier2 = {
    to?: any | undefined;
    amount?: any | undefined;
    flatAmount?: any | undefined;
};
declare const CreateScheduleAddItemTierBehavior2: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type CreateScheduleAddItemTierBehavior2 = ClosedEnum<typeof CreateScheduleAddItemTierBehavior2>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const CreateScheduleAddItemPriceInterval2: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type CreateScheduleAddItemPriceInterval2 = ClosedEnum<typeof CreateScheduleAddItemPriceInterval2>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const CreateScheduleAddItemBillingMethod2: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type CreateScheduleAddItemBillingMethod2 = ClosedEnum<typeof CreateScheduleAddItemBillingMethod2>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type CreateScheduleAddItemPrice2 = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<CreateScheduleAddItemTier2> | undefined;
    tierBehavior?: CreateScheduleAddItemTierBehavior2 | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: CreateScheduleAddItemPriceInterval2;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: CreateScheduleAddItemBillingMethod2;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const CreateScheduleAddItemOnIncrease2: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type CreateScheduleAddItemOnIncrease2 = ClosedEnum<typeof CreateScheduleAddItemOnIncrease2>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const CreateScheduleAddItemOnDecrease2: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type CreateScheduleAddItemOnDecrease2 = ClosedEnum<typeof CreateScheduleAddItemOnDecrease2>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type CreateScheduleAddItemProration2 = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: CreateScheduleAddItemOnIncrease2;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: CreateScheduleAddItemOnDecrease2;
};
/**
 * When rolled over units expire.
 */
declare const CreateScheduleAddItemExpiryDurationType2: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type CreateScheduleAddItemExpiryDurationType2 = ClosedEnum<typeof CreateScheduleAddItemExpiryDurationType2>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type CreateScheduleAddItemRollover2 = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: CreateScheduleAddItemExpiryDurationType2;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type CreateScheduleAddItemPlanItem2 = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: CreateScheduleAddItemReset2 | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: CreateScheduleAddItemPrice2 | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: CreateScheduleAddItemProration2 | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: CreateScheduleAddItemRollover2 | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const CreateScheduleRemoveItemBillingMethod2: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type CreateScheduleRemoveItemBillingMethod2 = ClosedEnum<typeof CreateScheduleRemoveItemBillingMethod2>;
declare const CreateScheduleIntervalRemoveItemEnum4: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type CreateScheduleIntervalRemoveItemEnum4 = ClosedEnum<typeof CreateScheduleIntervalRemoveItemEnum4>;
declare const CreateScheduleIntervalRemoveItemEnum3: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type CreateScheduleIntervalRemoveItemEnum3 = ClosedEnum<typeof CreateScheduleIntervalRemoveItemEnum3>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type CreateScheduleIntervalUnion2 = CreateScheduleIntervalRemoveItemEnum3 | CreateScheduleIntervalRemoveItemEnum4;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type CreateSchedulePlanItemFilter2 = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: CreateScheduleRemoveItemBillingMethod2 | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: CreateScheduleIntervalRemoveItemEnum3 | CreateScheduleIntervalRemoveItemEnum4 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const CreateSchedulePurchaseLimitInterval2: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CreateSchedulePurchaseLimitInterval2 = ClosedEnum<typeof CreateSchedulePurchaseLimitInterval2>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type CreateSchedulePurchaseLimit2 = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CreateSchedulePurchaseLimitInterval2;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type CreateScheduleAutoTopup2 = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: CreateSchedulePurchaseLimit2 | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CreateScheduleLimitType2: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CreateScheduleLimitType2 = ClosedEnum<typeof CreateScheduleLimitType2>;
type CreateScheduleSpendLimit2 = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CreateScheduleLimitType2 | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CreateScheduleUsageLimitInterval2: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CreateScheduleUsageLimitInterval2 = ClosedEnum<typeof CreateScheduleUsageLimitInterval2>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CreateScheduleFilter2 = {
    properties: {
        [k: string]: any;
    };
};
type CreateScheduleUsageLimit2 = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CreateScheduleUsageLimitInterval2;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CreateScheduleFilter2 | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CreateScheduleThresholdType2: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CreateScheduleThresholdType2 = ClosedEnum<typeof CreateScheduleThresholdType2>;
type CreateScheduleUsageAlert2 = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CreateScheduleThresholdType2;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type CreateScheduleOverageAllowed2 = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type CreateScheduleBillingControls2 = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CreateScheduleAutoTopup2> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CreateScheduleSpendLimit2> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<CreateScheduleUsageLimit2> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CreateScheduleUsageAlert2> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CreateScheduleOverageAllowed2> | undefined;
};
/**
 * Customize the plan to schedule. Can override price, replace items, or patch items with add_items and remove_items.
 */
type CreateScheduleCustomize2 = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: CreateScheduleBasePrice2 | null | undefined;
    /**
     * Override the items in the plan (PUT-style — replaces all existing items). Mutually exclusive with add_items / remove_items / deprecated update_items.
     */
    items?: Array<CreateScheduleItemPlanItem2> | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<CreateScheduleAddItemPlanItem2> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<CreateSchedulePlanItemFilter2> | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: CreateScheduleBillingControls2 | undefined;
};
type CreateSchedulePlan2 = {
    /**
     * The ID of the plan to schedule in this phase.
     */
    planId: string;
    /**
     * Optional prepaid feature quantities for this phase's plan.
     */
    featureQuantities?: Array<CreateScheduleFeatureQuantity2> | undefined;
    /**
     * Optional explicit plan version to schedule.
     */
    version?: number | undefined;
    /**
     * Customize the plan to schedule. Can override price, replace items, or patch items with add_items and remove_items.
     */
    customize?: CreateScheduleCustomize2 | undefined;
    /**
     * A unique ID to identify this subscription. Useful when scheduling the same plan multiple times.
     */
    subscriptionId?: string | undefined;
};
/**
 * Pass 'phase_start' to reset the Stripe billing cycle anchor when this phase starts.
 */
declare const BillingCycleAnchor2: {
    readonly PhaseStart: "phase_start";
};
/**
 * Pass 'phase_start' to reset the Stripe billing cycle anchor when this phase starts.
 */
type BillingCycleAnchor2 = ClosedEnum<typeof BillingCycleAnchor2>;
type PhaseStart = {
    /**
     * When this phase should start, in epoch milliseconds, or 'now' for the immediate phase.
     */
    startsAt?: number | string | undefined;
    /**
     * Relative start offset from the previous resolved schedule phase.
     */
    startingAfter?: StartingAfter2 | undefined;
    /**
     * Plans to materialize for this phase.
     */
    plans: Array<CreateSchedulePlan2>;
    /**
     * Pass 'phase_start' to reset the Stripe billing cycle anchor when this phase starts.
     */
    billingCycleAnchor?: BillingCycleAnchor2 | undefined;
};
type PhaseStartUnion = PhaseStart;
type CreateScheduleParams = {
    /**
     * The ID of the customer to create the schedule for.
     */
    customerId: string;
    /**
     * Optional entity ID for an entity-scoped schedule.
     */
    entityId?: string | undefined;
    /**
     * Invoice mode creates and sends an invoice instead of charging the customer's payment method immediately for the first phase.
     */
    invoiceMode?: CreateScheduleInvoiceMode | undefined;
    /**
     * List of discounts to apply to the immediate phase. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<CreateScheduleAttachDiscount> | undefined;
    /**
     * URL to redirect to after successful checkout.
     */
    successUrl?: string | undefined;
    /**
     * Additional parameters to pass into the creation of the Stripe checkout session.
     */
    checkoutSessionParams?: {
        [k: string]: any;
    } | undefined;
    /**
     * Controls when to return a checkout URL for the immediate phase. 'always' forces a confirmation or checkout flow, 'if_required' only redirects when needed, and 'never' disables redirects.
     */
    redirectMode?: CreateScheduleRedirectMode | undefined;
    /**
     * Whether to prorate the immediate phase. 'none' skips proration charges and credits.
     */
    billingBehavior?: CreateScheduleBillingBehavior | undefined;
    /**
     * Pass 'now' to reset the billing cycle anchor of the immediate phase to the current time.
     */
    billingCycleAnchor?: "now" | undefined;
    /**
     * If true, the immediate-phase cusProducts are activated immediately (and scheduled-phase cusProducts pre-inserted) even when payment is pending via Stripe checkout. The Autumn schedule rows are persisted on checkout.session.completed.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * Ordered phase definitions for the schedule.
     */
    phases: Array<PhaseStart>;
};
/**
 * Whether the schedule is fully created or waiting for payment or confirmation to complete.
 */
declare const CreateScheduleStatus: {
    readonly Created: "created";
    readonly PendingPayment: "pending_payment";
};
/**
 * Whether the schedule is fully created or waiting for payment or confirmation to complete.
 */
type CreateScheduleStatus = OpenEnum<typeof CreateScheduleStatus>;
type PhaseResponse = {
    /**
     * The ID of the persisted phase row.
     */
    phaseId: string;
    /**
     * When this phase starts, in epoch milliseconds.
     */
    startsAt: number;
    /**
     * Customer products materialized for this phase.
     */
    customerProductIds: Array<string>;
};
/**
 * Invoice details if an invoice was created. Only present when a charge was made.
 */
type CreateScheduleInvoice = {
    /**
     * The status of the invoice (e.g., 'paid', 'open', 'draft').
     */
    status: string | null;
    /**
     * The Stripe invoice ID.
     */
    stripeId: string;
    /**
     * The total amount of the invoice in cents.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * URL to the hosted invoice page where the customer can view and pay the invoice.
     */
    hostedInvoiceUrl: string | null;
};
/**
 * The type of action required to complete the payment.
 */
declare const CreateScheduleCode: {
    readonly ThreedsRequired: "3ds_required";
    readonly PaymentMethodRequired: "payment_method_required";
    readonly PaymentFailed: "payment_failed";
    readonly PaymentProcessing: "payment_processing";
};
/**
 * The type of action required to complete the payment.
 */
type CreateScheduleCode = OpenEnum<typeof CreateScheduleCode>;
type CreateScheduleRequiredAction = {
    /**
     * The type of action required to complete the payment.
     */
    code: CreateScheduleCode;
    /**
     * A human-readable explanation of why this action is required.
     */
    reason: string;
};
/**
 * OK
 */
type CreateScheduleResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The entity ID for the schedule, or null when customer-level.
     */
    entityId: string | null;
    /**
     * Whether the schedule is fully created or waiting for payment or confirmation to complete.
     */
    status: CreateScheduleStatus;
    /**
     * The ID of the created schedule. Null when the schedule is waiting on Autumn checkout confirmation.
     */
    scheduleId: string | null;
    /**
     * Persisted phases in ascending starts_at order. Empty when waiting on Autumn checkout confirmation.
     */
    phases: Array<PhaseResponse>;
    /**
     * Invoice details if an invoice was created. Only present when a charge was made.
     */
    invoice?: CreateScheduleInvoice | undefined;
    /**
     * URL to redirect the customer to complete payment. Null if no payment action is required.
     */
    paymentUrl: string | null;
    requiredAction?: CreateScheduleRequiredAction | undefined;
};
/** @internal */
type CreateScheduleInvoiceMode$Outbound = {
    enabled: boolean;
    enable_plan_immediately: boolean;
    finalize: boolean;
    invoice_template_id?: string | undefined;
    net_terms_days?: number | undefined;
};
/** @internal */
declare const CreateScheduleInvoiceMode$outboundSchema: z$1.ZodMiniType<CreateScheduleInvoiceMode$Outbound, CreateScheduleInvoiceMode>;
declare function createScheduleInvoiceModeToJSON(createScheduleInvoiceMode: CreateScheduleInvoiceMode): string;
/** @internal */
type CreateScheduleAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const CreateScheduleAttachDiscount$outboundSchema: z$1.ZodMiniType<CreateScheduleAttachDiscount$Outbound, CreateScheduleAttachDiscount>;
declare function createScheduleAttachDiscountToJSON(createScheduleAttachDiscount: CreateScheduleAttachDiscount): string;
/** @internal */
declare const CreateScheduleRedirectMode$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleRedirectMode>;
/** @internal */
declare const CreateScheduleBillingBehavior$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleBillingBehavior>;
/** @internal */
type StartsAt2$Outbound = number | string;
/** @internal */
declare const StartsAt2$outboundSchema: z$1.ZodMiniType<StartsAt2$Outbound, StartsAt2>;
declare function startsAt2ToJSON(startsAt2: StartsAt2): string;
/** @internal */
declare const CreateScheduleDurationType2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleDurationType2>;
/** @internal */
type StartingAfter2$Outbound = {
    duration_type: string;
    duration_count: number;
};
/** @internal */
declare const StartingAfter2$outboundSchema: z$1.ZodMiniType<StartingAfter2$Outbound, StartingAfter2>;
declare function startingAfter2ToJSON(startingAfter2: StartingAfter2): string;
/** @internal */
type CreateScheduleFeatureQuantity2$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const CreateScheduleFeatureQuantity2$outboundSchema: z$1.ZodMiniType<CreateScheduleFeatureQuantity2$Outbound, CreateScheduleFeatureQuantity2>;
declare function createScheduleFeatureQuantity2ToJSON(createScheduleFeatureQuantity2: CreateScheduleFeatureQuantity2): string;
/** @internal */
declare const CreateSchedulePriceInterval2$outboundSchema: z$1.ZodMiniEnum<typeof CreateSchedulePriceInterval2>;
/** @internal */
type CreateScheduleBasePrice2$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const CreateScheduleBasePrice2$outboundSchema: z$1.ZodMiniType<CreateScheduleBasePrice2$Outbound, CreateScheduleBasePrice2>;
declare function createScheduleBasePrice2ToJSON(createScheduleBasePrice2: CreateScheduleBasePrice2): string;
/** @internal */
declare const CreateScheduleItemResetInterval2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleItemResetInterval2>;
/** @internal */
type CreateScheduleItemReset2$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const CreateScheduleItemReset2$outboundSchema: z$1.ZodMiniType<CreateScheduleItemReset2$Outbound, CreateScheduleItemReset2>;
declare function createScheduleItemReset2ToJSON(createScheduleItemReset2: CreateScheduleItemReset2): string;
/** @internal */
type CreateScheduleItemTier2$Outbound = {
    to?: any | undefined;
    amount?: any | undefined;
    flat_amount?: any | undefined;
};
/** @internal */
declare const CreateScheduleItemTier2$outboundSchema: z$1.ZodMiniType<CreateScheduleItemTier2$Outbound, CreateScheduleItemTier2>;
declare function createScheduleItemTier2ToJSON(createScheduleItemTier2: CreateScheduleItemTier2): string;
/** @internal */
declare const CreateScheduleItemTierBehavior2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleItemTierBehavior2>;
/** @internal */
declare const CreateScheduleItemPriceInterval2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleItemPriceInterval2>;
/** @internal */
declare const CreateScheduleItemBillingMethod2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleItemBillingMethod2>;
/** @internal */
type CreateScheduleItemPrice2$Outbound = {
    amount?: number | undefined;
    tiers?: Array<CreateScheduleItemTier2$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const CreateScheduleItemPrice2$outboundSchema: z$1.ZodMiniType<CreateScheduleItemPrice2$Outbound, CreateScheduleItemPrice2>;
declare function createScheduleItemPrice2ToJSON(createScheduleItemPrice2: CreateScheduleItemPrice2): string;
/** @internal */
declare const CreateScheduleItemOnIncrease2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleItemOnIncrease2>;
/** @internal */
declare const CreateScheduleItemOnDecrease2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleItemOnDecrease2>;
/** @internal */
type CreateScheduleItemProration2$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const CreateScheduleItemProration2$outboundSchema: z$1.ZodMiniType<CreateScheduleItemProration2$Outbound, CreateScheduleItemProration2>;
declare function createScheduleItemProration2ToJSON(createScheduleItemProration2: CreateScheduleItemProration2): string;
/** @internal */
declare const CreateScheduleItemExpiryDurationType2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleItemExpiryDurationType2>;
/** @internal */
type CreateScheduleItemRollover2$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const CreateScheduleItemRollover2$outboundSchema: z$1.ZodMiniType<CreateScheduleItemRollover2$Outbound, CreateScheduleItemRollover2>;
declare function createScheduleItemRollover2ToJSON(createScheduleItemRollover2: CreateScheduleItemRollover2): string;
/** @internal */
type CreateScheduleItemPlanItem2$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: CreateScheduleItemReset2$Outbound | undefined;
    price?: CreateScheduleItemPrice2$Outbound | undefined;
    proration?: CreateScheduleItemProration2$Outbound | undefined;
    rollover?: CreateScheduleItemRollover2$Outbound | undefined;
};
/** @internal */
declare const CreateScheduleItemPlanItem2$outboundSchema: z$1.ZodMiniType<CreateScheduleItemPlanItem2$Outbound, CreateScheduleItemPlanItem2>;
declare function createScheduleItemPlanItem2ToJSON(createScheduleItemPlanItem2: CreateScheduleItemPlanItem2): string;
/** @internal */
declare const CreateScheduleAddItemResetInterval2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleAddItemResetInterval2>;
/** @internal */
type CreateScheduleAddItemReset2$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const CreateScheduleAddItemReset2$outboundSchema: z$1.ZodMiniType<CreateScheduleAddItemReset2$Outbound, CreateScheduleAddItemReset2>;
declare function createScheduleAddItemReset2ToJSON(createScheduleAddItemReset2: CreateScheduleAddItemReset2): string;
/** @internal */
type CreateScheduleAddItemTier2$Outbound = {
    to?: any | undefined;
    amount?: any | undefined;
    flat_amount?: any | undefined;
};
/** @internal */
declare const CreateScheduleAddItemTier2$outboundSchema: z$1.ZodMiniType<CreateScheduleAddItemTier2$Outbound, CreateScheduleAddItemTier2>;
declare function createScheduleAddItemTier2ToJSON(createScheduleAddItemTier2: CreateScheduleAddItemTier2): string;
/** @internal */
declare const CreateScheduleAddItemTierBehavior2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleAddItemTierBehavior2>;
/** @internal */
declare const CreateScheduleAddItemPriceInterval2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleAddItemPriceInterval2>;
/** @internal */
declare const CreateScheduleAddItemBillingMethod2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleAddItemBillingMethod2>;
/** @internal */
type CreateScheduleAddItemPrice2$Outbound = {
    amount?: number | undefined;
    tiers?: Array<CreateScheduleAddItemTier2$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const CreateScheduleAddItemPrice2$outboundSchema: z$1.ZodMiniType<CreateScheduleAddItemPrice2$Outbound, CreateScheduleAddItemPrice2>;
declare function createScheduleAddItemPrice2ToJSON(createScheduleAddItemPrice2: CreateScheduleAddItemPrice2): string;
/** @internal */
declare const CreateScheduleAddItemOnIncrease2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleAddItemOnIncrease2>;
/** @internal */
declare const CreateScheduleAddItemOnDecrease2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleAddItemOnDecrease2>;
/** @internal */
type CreateScheduleAddItemProration2$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const CreateScheduleAddItemProration2$outboundSchema: z$1.ZodMiniType<CreateScheduleAddItemProration2$Outbound, CreateScheduleAddItemProration2>;
declare function createScheduleAddItemProration2ToJSON(createScheduleAddItemProration2: CreateScheduleAddItemProration2): string;
/** @internal */
declare const CreateScheduleAddItemExpiryDurationType2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleAddItemExpiryDurationType2>;
/** @internal */
type CreateScheduleAddItemRollover2$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const CreateScheduleAddItemRollover2$outboundSchema: z$1.ZodMiniType<CreateScheduleAddItemRollover2$Outbound, CreateScheduleAddItemRollover2>;
declare function createScheduleAddItemRollover2ToJSON(createScheduleAddItemRollover2: CreateScheduleAddItemRollover2): string;
/** @internal */
type CreateScheduleAddItemPlanItem2$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: CreateScheduleAddItemReset2$Outbound | undefined;
    price?: CreateScheduleAddItemPrice2$Outbound | undefined;
    proration?: CreateScheduleAddItemProration2$Outbound | undefined;
    rollover?: CreateScheduleAddItemRollover2$Outbound | undefined;
};
/** @internal */
declare const CreateScheduleAddItemPlanItem2$outboundSchema: z$1.ZodMiniType<CreateScheduleAddItemPlanItem2$Outbound, CreateScheduleAddItemPlanItem2>;
declare function createScheduleAddItemPlanItem2ToJSON(createScheduleAddItemPlanItem2: CreateScheduleAddItemPlanItem2): string;
/** @internal */
declare const CreateScheduleRemoveItemBillingMethod2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleRemoveItemBillingMethod2>;
/** @internal */
declare const CreateScheduleIntervalRemoveItemEnum4$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleIntervalRemoveItemEnum4>;
/** @internal */
declare const CreateScheduleIntervalRemoveItemEnum3$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleIntervalRemoveItemEnum3>;
/** @internal */
type CreateScheduleIntervalUnion2$Outbound = string | string;
/** @internal */
declare const CreateScheduleIntervalUnion2$outboundSchema: z$1.ZodMiniType<CreateScheduleIntervalUnion2$Outbound, CreateScheduleIntervalUnion2>;
declare function createScheduleIntervalUnion2ToJSON(createScheduleIntervalUnion2: CreateScheduleIntervalUnion2): string;
/** @internal */
type CreateSchedulePlanItemFilter2$Outbound = {
    feature_id?: string | undefined;
    billing_method?: string | undefined;
    interval?: string | string | undefined;
    interval_count?: number | undefined;
};
/** @internal */
declare const CreateSchedulePlanItemFilter2$outboundSchema: z$1.ZodMiniType<CreateSchedulePlanItemFilter2$Outbound, CreateSchedulePlanItemFilter2>;
declare function createSchedulePlanItemFilter2ToJSON(createSchedulePlanItemFilter2: CreateSchedulePlanItemFilter2): string;
/** @internal */
declare const CreateSchedulePurchaseLimitInterval2$outboundSchema: z$1.ZodMiniEnum<typeof CreateSchedulePurchaseLimitInterval2>;
/** @internal */
type CreateSchedulePurchaseLimit2$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const CreateSchedulePurchaseLimit2$outboundSchema: z$1.ZodMiniType<CreateSchedulePurchaseLimit2$Outbound, CreateSchedulePurchaseLimit2>;
declare function createSchedulePurchaseLimit2ToJSON(createSchedulePurchaseLimit2: CreateSchedulePurchaseLimit2): string;
/** @internal */
type CreateScheduleAutoTopup2$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: CreateSchedulePurchaseLimit2$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const CreateScheduleAutoTopup2$outboundSchema: z$1.ZodMiniType<CreateScheduleAutoTopup2$Outbound, CreateScheduleAutoTopup2>;
declare function createScheduleAutoTopup2ToJSON(createScheduleAutoTopup2: CreateScheduleAutoTopup2): string;
/** @internal */
declare const CreateScheduleLimitType2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleLimitType2>;
/** @internal */
type CreateScheduleSpendLimit2$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const CreateScheduleSpendLimit2$outboundSchema: z$1.ZodMiniType<CreateScheduleSpendLimit2$Outbound, CreateScheduleSpendLimit2>;
declare function createScheduleSpendLimit2ToJSON(createScheduleSpendLimit2: CreateScheduleSpendLimit2): string;
/** @internal */
declare const CreateScheduleUsageLimitInterval2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleUsageLimitInterval2>;
/** @internal */
type CreateScheduleFilter2$Outbound = {
    properties: {
        [k: string]: any;
    };
};
/** @internal */
declare const CreateScheduleFilter2$outboundSchema: z$1.ZodMiniType<CreateScheduleFilter2$Outbound, CreateScheduleFilter2>;
declare function createScheduleFilter2ToJSON(createScheduleFilter2: CreateScheduleFilter2): string;
/** @internal */
type CreateScheduleUsageLimit2$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: CreateScheduleFilter2$Outbound | undefined;
};
/** @internal */
declare const CreateScheduleUsageLimit2$outboundSchema: z$1.ZodMiniType<CreateScheduleUsageLimit2$Outbound, CreateScheduleUsageLimit2>;
declare function createScheduleUsageLimit2ToJSON(createScheduleUsageLimit2: CreateScheduleUsageLimit2): string;
/** @internal */
declare const CreateScheduleThresholdType2$outboundSchema: z$1.ZodMiniEnum<typeof CreateScheduleThresholdType2>;
/** @internal */
type CreateScheduleUsageAlert2$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const CreateScheduleUsageAlert2$outboundSchema: z$1.ZodMiniType<CreateScheduleUsageAlert2$Outbound, CreateScheduleUsageAlert2>;
declare function createScheduleUsageAlert2ToJSON(createScheduleUsageAlert2: CreateScheduleUsageAlert2): string;
/** @internal */
type CreateScheduleOverageAllowed2$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const CreateScheduleOverageAllowed2$outboundSchema: z$1.ZodMiniType<CreateScheduleOverageAllowed2$Outbound, CreateScheduleOverageAllowed2>;
declare function createScheduleOverageAllowed2ToJSON(createScheduleOverageAllowed2: CreateScheduleOverageAllowed2): string;
/** @internal */
type CreateScheduleBillingControls2$Outbound = {
    auto_topups?: Array<CreateScheduleAutoTopup2$Outbound> | undefined;
    spend_limits?: Array<CreateScheduleSpendLimit2$Outbound> | undefined;
    usage_limits?: Array<CreateScheduleUsageLimit2$Outbound> | undefined;
    usage_alerts?: Array<CreateScheduleUsageAlert2$Outbound> | undefined;
    overage_allowed?: Array<CreateScheduleOverageAllowed2$Outbound> | undefined;
};
/** @internal */
declare const CreateScheduleBillingControls2$outboundSchema: z$1.ZodMiniType<CreateScheduleBillingControls2$Outbound, CreateScheduleBillingControls2>;
declare function createScheduleBillingControls2ToJSON(createScheduleBillingControls2: CreateScheduleBillingControls2): string;
/** @internal */
type CreateScheduleCustomize2$Outbound = {
    price?: CreateScheduleBasePrice2$Outbound | null | undefined;
    items?: Array<CreateScheduleItemPlanItem2$Outbound> | undefined;
    add_items?: Array<CreateScheduleAddItemPlanItem2$Outbound> | undefined;
    remove_items?: Array<CreateSchedulePlanItemFilter2$Outbound> | undefined;
    billing_controls?: CreateScheduleBillingControls2$Outbound | undefined;
};
/** @internal */
declare const CreateScheduleCustomize2$outboundSchema: z$1.ZodMiniType<CreateScheduleCustomize2$Outbound, CreateScheduleCustomize2>;
declare function createScheduleCustomize2ToJSON(createScheduleCustomize2: CreateScheduleCustomize2): string;
/** @internal */
type CreateSchedulePlan2$Outbound = {
    plan_id: string;
    feature_quantities?: Array<CreateScheduleFeatureQuantity2$Outbound> | undefined;
    version?: number | undefined;
    customize?: CreateScheduleCustomize2$Outbound | undefined;
    subscription_id?: string | undefined;
};
/** @internal */
declare const CreateSchedulePlan2$outboundSchema: z$1.ZodMiniType<CreateSchedulePlan2$Outbound, CreateSchedulePlan2>;
declare function createSchedulePlan2ToJSON(createSchedulePlan2: CreateSchedulePlan2): string;
/** @internal */
declare const BillingCycleAnchor2$outboundSchema: z$1.ZodMiniEnum<typeof BillingCycleAnchor2>;
/** @internal */
type PhaseStart$Outbound = {
    starts_at?: number | string | undefined;
    starting_after?: StartingAfter2$Outbound | undefined;
    plans: Array<CreateSchedulePlan2$Outbound>;
    billing_cycle_anchor?: string | undefined;
};
/** @internal */
declare const PhaseStart$outboundSchema: z$1.ZodMiniType<PhaseStart$Outbound, PhaseStart>;
declare function phaseStartToJSON(phaseStart: PhaseStart): string;
/** @internal */
type PhaseStartUnion$Outbound = PhaseStart$Outbound;
/** @internal */
declare const PhaseStartUnion$outboundSchema: z$1.ZodMiniType<PhaseStartUnion$Outbound, PhaseStartUnion>;
declare function phaseStartUnionToJSON(phaseStartUnion: PhaseStartUnion): string;
/** @internal */
type CreateScheduleParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    invoice_mode?: CreateScheduleInvoiceMode$Outbound | undefined;
    discounts?: Array<CreateScheduleAttachDiscount$Outbound> | undefined;
    success_url?: string | undefined;
    checkout_session_params?: {
        [k: string]: any;
    } | undefined;
    redirect_mode: string;
    billing_behavior?: string | undefined;
    billing_cycle_anchor?: "now" | undefined;
    enable_plan_immediately?: boolean | undefined;
    phases: Array<PhaseStart$Outbound>;
};
/** @internal */
declare const CreateScheduleParams$outboundSchema: z$1.ZodMiniType<CreateScheduleParams$Outbound, CreateScheduleParams>;
declare function createScheduleParamsToJSON(createScheduleParams: CreateScheduleParams): string;
/** @internal */
declare const CreateScheduleStatus$inboundSchema: z$1.ZodMiniType<CreateScheduleStatus, unknown>;
/** @internal */
declare const PhaseResponse$inboundSchema: z$1.ZodMiniType<PhaseResponse, unknown>;
declare function phaseResponseFromJSON(jsonString: string): Result$1<PhaseResponse, SDKValidationError>;
/** @internal */
declare const CreateScheduleInvoice$inboundSchema: z$1.ZodMiniType<CreateScheduleInvoice, unknown>;
declare function createScheduleInvoiceFromJSON(jsonString: string): Result$1<CreateScheduleInvoice, SDKValidationError>;
/** @internal */
declare const CreateScheduleCode$inboundSchema: z$1.ZodMiniType<CreateScheduleCode, unknown>;
/** @internal */
declare const CreateScheduleRequiredAction$inboundSchema: z$1.ZodMiniType<CreateScheduleRequiredAction, unknown>;
declare function createScheduleRequiredActionFromJSON(jsonString: string): Result$1<CreateScheduleRequiredAction, SDKValidationError>;
/** @internal */
declare const CreateScheduleResponse$inboundSchema: z$1.ZodMiniType<CreateScheduleResponse, unknown>;
declare function createScheduleResponseFromJSON(jsonString: string): Result$1<CreateScheduleResponse, SDKValidationError>;

declare const CustomerExpand: {
    readonly Invoices: "invoices";
    readonly TrialsUsed: "trials_used";
    readonly Rewards: "rewards";
    readonly Entities: "entities";
    readonly Referrals: "referrals";
    readonly PaymentMethod: "payment_method";
    readonly SubscriptionsPlan: "subscriptions.plan";
    readonly PurchasesPlan: "purchases.plan";
    readonly BalancesFeature: "balances.feature";
    readonly FlagsFeature: "flags.feature";
    readonly BillingControlsAutoTopupsPurchaseLimit: "billing_controls.auto_topups.purchase_limit";
};
type CustomerExpand = ClosedEnum<typeof CustomerExpand>;
/** @internal */
declare const CustomerExpand$outboundSchema: z$1.ZodMiniEnum<typeof CustomerExpand>;

/**
 * The environment this customer was created in.
 */
declare const CustomerEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment this customer was created in.
 */
type CustomerEnv = OpenEnum<typeof CustomerEnv>;
/**
 * The time interval for the purchase limit window.
 */
declare const CustomerPurchaseLimitInterval2: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type CustomerPurchaseLimitInterval2 = OpenEnum<typeof CustomerPurchaseLimitInterval2>;
type CustomerPurchaseLimit2 = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: CustomerPurchaseLimitInterval2;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
declare const CustomerPurchaseLimitInterval1: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
type CustomerPurchaseLimitInterval1 = OpenEnum<typeof CustomerPurchaseLimitInterval1>;
type CustomerPurchaseLimit1 = {
    /**
     * The time interval for the purchase limit window. Null when no purchase limit is configured.
     */
    interval: CustomerPurchaseLimitInterval1 | null;
    /**
     * Number of intervals in the purchase limit window. Null when no purchase limit is configured.
     */
    intervalCount: number | null;
    /**
     * Maximum number of auto top-ups allowed within the interval. Null when no purchase limit is configured.
     */
    limit: number | null;
    /**
     * Number of auto top-ups already consumed in the current window.
     */
    count: number;
    /**
     * Unix ms timestamp when the current purchase window ends and the count resets.
     */
    nextResetAt: number;
};
/**
 * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
 */
type CustomerPurchaseLimitUnion = CustomerPurchaseLimit1 | CustomerPurchaseLimit2;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const AutoTopupSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type AutoTopupSource = OpenEnum<typeof AutoTopupSource>;
type CustomerAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
     */
    purchaseLimit?: CustomerPurchaseLimit1 | CustomerPurchaseLimit2 | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: AutoTopupSource | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const CustomerLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type CustomerLimitType = OpenEnum<typeof CustomerLimitType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const SpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type SpendLimitSource = OpenEnum<typeof SpendLimitSource>;
type CustomerSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: CustomerLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: SpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const CustomerUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type CustomerUsageLimitInterval = OpenEnum<typeof CustomerUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type CustomerFilter = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UsageLimitSource = OpenEnum<typeof UsageLimitSource>;
type CustomerUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: CustomerUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: CustomerFilter | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const CustomerThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type CustomerThresholdType = OpenEnum<typeof CustomerThresholdType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UsageAlertSource = OpenEnum<typeof UsageAlertSource>;
type CustomerUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: CustomerThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const OverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type OverageAllowedSource = OpenEnum<typeof OverageAllowedSource>;
type CustomerOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: OverageAllowedSource | undefined;
};
/**
 * Billing controls for the customer (auto top-ups, etc.)
 */
type CustomerBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<CustomerAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<CustomerSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature, with current interval usage.
     */
    usageLimits?: Array<CustomerUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<CustomerUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<CustomerOverageAllowed> | undefined;
};
/**
 * Current status of the subscription.
 */
declare const CustomerStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type CustomerStatus = OpenEnum<typeof CustomerStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const SubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type SubscriptionScope = OpenEnum<typeof SubscriptionScope>;
type Subscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: CustomerStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: SubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const PurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type PurchaseScope = OpenEnum<typeof PurchaseScope>;
type Purchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: PurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const CustomerFlagsType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type CustomerFlagsType = OpenEnum<typeof CustomerFlagsType>;
type CustomerCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type CustomerModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type CustomerProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type CustomerDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type CustomerFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: CustomerFlagsType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<CustomerCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: CustomerModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: CustomerProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: CustomerDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type Flags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: CustomerFeature | undefined;
};
/**
 * Configuration for the customer.
 */
type CustomerConfig = {
    /**
     * Whether to disable the shared customer-level pool for entities.
     */
    disablePooledBalance?: boolean | undefined;
    /**
     * Stops Autumn from posting usage-overage line items to Stripe for this customer. Check/track and balance resets still behave normally. When set, this overrides the organization-level disable_overage_billing setting.
     */
    disableOverageBilling?: boolean | undefined;
};
/**
 * Stripe processor connection for the customer.
 */
type Stripe = {
    /**
     * Stripe customer ID.
     */
    id: string;
};
/**
 * Vercel processor connection for the customer (public-safe subset).
 */
type Vercel = {
    /**
     * Vercel marketplace installation ID for this customer.
     */
    installationId: string;
    /**
     * Vercel account ID associated with the installation.
     */
    accountId: string;
};
/**
 * RevenueCat processor connection for the customer.
 */
type Revenuecat = {
    /**
     * Customer's external ID, used as the RevenueCat app user ID. Null if the customer has no external ID set.
     */
    id: string | null;
};
/**
 * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
 */
type Processors = {
    /**
     * Stripe processor connection for the customer.
     */
    stripe?: Stripe | undefined;
    /**
     * Vercel processor connection for the customer (public-safe subset).
     */
    vercel?: Vercel | undefined;
    /**
     * RevenueCat processor connection for the customer.
     */
    revenuecat?: Revenuecat | undefined;
};
/**
 * The billing processor that owns this invoice.
 */
declare const ProcessorType: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The billing processor that owns this invoice.
 */
type ProcessorType = OpenEnum<typeof ProcessorType>;
type Invoice = {
    /**
     * Array of plan IDs included in this invoice
     */
    planIds: Array<string>;
    /**
     * The Stripe invoice ID
     */
    stripeId: string;
    /**
     * The billing processor that owns this invoice.
     */
    processorType: ProcessorType;
    /**
     * The status of the invoice
     */
    status: string;
    /**
     * The total amount of the invoice
     */
    total: number;
    /**
     * The currency code for the invoice
     */
    currency: string;
    /**
     * Timestamp when the invoice was created
     */
    createdAt: number;
    /**
     * URL to the Stripe-hosted invoice page
     */
    hostedInvoiceUrl?: string | null | undefined;
};
/**
 * The environment (sandbox/live)
 */
declare const CustomerEntityEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment (sandbox/live)
 */
type CustomerEntityEnv = OpenEnum<typeof CustomerEntityEnv>;
type Entity = {
    /**
     * The unique identifier of the entity
     */
    id: string | null;
    /**
     * The name of the entity
     */
    name: string | null;
    /**
     * The customer ID this entity belongs to
     */
    customerId?: string | null | undefined;
    /**
     * The feature ID this entity belongs to
     */
    featureId?: string | null | undefined;
    /**
     * Unix timestamp when the entity was created
     */
    createdAt: number;
    /**
     * The environment (sandbox/live)
     */
    env: CustomerEntityEnv;
};
type TrialsUsed = {
    planId: string;
    customerId: string;
    fingerprint?: string | null | undefined;
};
/**
 * The type of reward
 */
declare const CustomerDiscountType: {
    readonly PercentageDiscount: "percentage_discount";
    readonly FixedDiscount: "fixed_discount";
    readonly FreeProduct: "free_product";
    readonly InvoiceCredits: "invoice_credits";
    readonly FeatureGrant: "feature_grant";
};
/**
 * The type of reward
 */
type CustomerDiscountType = OpenEnum<typeof CustomerDiscountType>;
/**
 * How long the discount lasts
 */
declare const CustomerDurationType: {
    readonly OneOff: "one_off";
    readonly Months: "months";
    readonly Forever: "forever";
};
/**
 * How long the discount lasts
 */
type CustomerDurationType = OpenEnum<typeof CustomerDurationType>;
type Discount = {
    /**
     * The unique identifier for this discount
     */
    id: string;
    /**
     * The name of the discount or coupon
     */
    name: string;
    /**
     * The type of reward
     */
    type: CustomerDiscountType;
    /**
     * The discount value (percentage or fixed amount)
     */
    discountValue: number;
    /**
     * How long the discount lasts
     */
    durationType: CustomerDurationType;
    /**
     * Number of billing periods the discount applies for repeating durations
     */
    durationValue?: number | null | undefined;
    /**
     * The currency code for fixed amount discounts
     */
    currency?: string | null | undefined;
    /**
     * Timestamp when the discount becomes active
     */
    start?: number | null | undefined;
    /**
     * Timestamp when the discount expires
     */
    end?: number | null | undefined;
    /**
     * The Stripe subscription ID this discount is applied to
     */
    subscriptionId?: string | null | undefined;
    /**
     * Total amount saved from this discount
     */
    totalDiscountAmount?: number | null | undefined;
};
type Rewards$1 = {
    /**
     * Array of active discounts applied to the customer
     */
    discounts: Array<Discount>;
};
type ReferralCustomer = {
    id: string;
    name?: string | null | undefined;
    email?: string | null | undefined;
};
type Referral = {
    programId: string;
    customer: ReferralCustomer;
    rewardApplied: boolean;
    createdAt: number;
};
type Customer = {
    /**
     * Your unique identifier for the customer.
     */
    id: string | null;
    /**
     * The name of the customer.
     */
    name: string | null;
    /**
     * The email address of the customer.
     */
    email: string | null;
    /**
     * Timestamp of customer creation in milliseconds since epoch.
     */
    createdAt: number;
    /**
     * A unique identifier (eg. serial number) to de-duplicate customers across devices or browsers. For example: apple device ID.
     */
    fingerprint: string | null;
    /**
     * Stripe customer ID.
     */
    stripeId: string | null;
    /**
     * The environment this customer was created in.
     */
    env: CustomerEnv;
    /**
     * The metadata for the customer.
     */
    metadata: {
        [k: string]: any;
    };
    /**
     * Whether to send email receipts to the customer.
     */
    sendEmailReceipts: boolean;
    /**
     * Billing controls for the customer (auto top-ups, etc.)
     */
    billingControls: CustomerBillingControls;
    /**
     * Active and scheduled recurring plans that this customer has attached.
     */
    subscriptions: Array<Subscription>;
    /**
     * One-time purchases made by the customer.
     */
    purchases: Array<Purchase>;
    /**
     * Feature balances keyed by feature ID, showing usage limits and remaining amounts.
     */
    balances: {
        [k: string]: Balance;
    };
    /**
     * Boolean feature flags keyed by feature ID, showing enabled access for on/off features.
     */
    flags: {
        [k: string]: Flags;
    };
    /**
     * Configuration for the customer.
     */
    config?: CustomerConfig | undefined;
    /**
     * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
     */
    processors?: Processors | undefined;
    /**
     * Invoices for this customer.
     */
    invoices?: Array<Invoice> | undefined;
    /**
     * Entities associated with this customer.
     */
    entities?: Array<Entity> | undefined;
    /**
     * Trial usage history for this customer.
     */
    trialsUsed?: Array<TrialsUsed> | undefined;
    /**
     * Rewards earned or applied for this customer.
     */
    rewards?: Rewards$1 | null | undefined;
    /**
     * Referral records for this customer.
     */
    referrals?: Array<Referral> | undefined;
    /**
     * The customer's default payment method.
     */
    paymentMethod?: any | null | undefined;
};
/** @internal */
declare const CustomerEnv$inboundSchema: z$1.ZodMiniType<CustomerEnv, unknown>;
/** @internal */
declare const CustomerPurchaseLimitInterval2$inboundSchema: z$1.ZodMiniType<CustomerPurchaseLimitInterval2, unknown>;
/** @internal */
declare const CustomerPurchaseLimit2$inboundSchema: z$1.ZodMiniType<CustomerPurchaseLimit2, unknown>;
declare function customerPurchaseLimit2FromJSON(jsonString: string): Result$1<CustomerPurchaseLimit2, SDKValidationError>;
/** @internal */
declare const CustomerPurchaseLimitInterval1$inboundSchema: z$1.ZodMiniType<CustomerPurchaseLimitInterval1, unknown>;
/** @internal */
declare const CustomerPurchaseLimit1$inboundSchema: z$1.ZodMiniType<CustomerPurchaseLimit1, unknown>;
declare function customerPurchaseLimit1FromJSON(jsonString: string): Result$1<CustomerPurchaseLimit1, SDKValidationError>;
/** @internal */
declare const CustomerPurchaseLimitUnion$inboundSchema: z$1.ZodMiniType<CustomerPurchaseLimitUnion, unknown>;
declare function customerPurchaseLimitUnionFromJSON(jsonString: string): Result$1<CustomerPurchaseLimitUnion, SDKValidationError>;
/** @internal */
declare const AutoTopupSource$inboundSchema: z$1.ZodMiniType<AutoTopupSource, unknown>;
/** @internal */
declare const CustomerAutoTopup$inboundSchema: z$1.ZodMiniType<CustomerAutoTopup, unknown>;
declare function customerAutoTopupFromJSON(jsonString: string): Result$1<CustomerAutoTopup, SDKValidationError>;
/** @internal */
declare const CustomerLimitType$inboundSchema: z$1.ZodMiniType<CustomerLimitType, unknown>;
/** @internal */
declare const SpendLimitSource$inboundSchema: z$1.ZodMiniType<SpendLimitSource, unknown>;
/** @internal */
declare const CustomerSpendLimit$inboundSchema: z$1.ZodMiniType<CustomerSpendLimit, unknown>;
declare function customerSpendLimitFromJSON(jsonString: string): Result$1<CustomerSpendLimit, SDKValidationError>;
/** @internal */
declare const CustomerUsageLimitInterval$inboundSchema: z$1.ZodMiniType<CustomerUsageLimitInterval, unknown>;
/** @internal */
declare const CustomerFilter$inboundSchema: z$1.ZodMiniType<CustomerFilter, unknown>;
declare function customerFilterFromJSON(jsonString: string): Result$1<CustomerFilter, SDKValidationError>;
/** @internal */
declare const UsageLimitSource$inboundSchema: z$1.ZodMiniType<UsageLimitSource, unknown>;
/** @internal */
declare const CustomerUsageLimit$inboundSchema: z$1.ZodMiniType<CustomerUsageLimit, unknown>;
declare function customerUsageLimitFromJSON(jsonString: string): Result$1<CustomerUsageLimit, SDKValidationError>;
/** @internal */
declare const CustomerThresholdType$inboundSchema: z$1.ZodMiniType<CustomerThresholdType, unknown>;
/** @internal */
declare const UsageAlertSource$inboundSchema: z$1.ZodMiniType<UsageAlertSource, unknown>;
/** @internal */
declare const CustomerUsageAlert$inboundSchema: z$1.ZodMiniType<CustomerUsageAlert, unknown>;
declare function customerUsageAlertFromJSON(jsonString: string): Result$1<CustomerUsageAlert, SDKValidationError>;
/** @internal */
declare const OverageAllowedSource$inboundSchema: z$1.ZodMiniType<OverageAllowedSource, unknown>;
/** @internal */
declare const CustomerOverageAllowed$inboundSchema: z$1.ZodMiniType<CustomerOverageAllowed, unknown>;
declare function customerOverageAllowedFromJSON(jsonString: string): Result$1<CustomerOverageAllowed, SDKValidationError>;
/** @internal */
declare const CustomerBillingControls$inboundSchema: z$1.ZodMiniType<CustomerBillingControls, unknown>;
declare function customerBillingControlsFromJSON(jsonString: string): Result$1<CustomerBillingControls, SDKValidationError>;
/** @internal */
declare const CustomerStatus$inboundSchema: z$1.ZodMiniType<CustomerStatus, unknown>;
/** @internal */
declare const SubscriptionScope$inboundSchema: z$1.ZodMiniType<SubscriptionScope, unknown>;
/** @internal */
declare const Subscription$inboundSchema: z$1.ZodMiniType<Subscription, unknown>;
declare function subscriptionFromJSON(jsonString: string): Result$1<Subscription, SDKValidationError>;
/** @internal */
declare const PurchaseScope$inboundSchema: z$1.ZodMiniType<PurchaseScope, unknown>;
/** @internal */
declare const Purchase$inboundSchema: z$1.ZodMiniType<Purchase, unknown>;
declare function purchaseFromJSON(jsonString: string): Result$1<Purchase, SDKValidationError>;
/** @internal */
declare const CustomerFlagsType$inboundSchema: z$1.ZodMiniType<CustomerFlagsType, unknown>;
/** @internal */
declare const CustomerCreditSchema$inboundSchema: z$1.ZodMiniType<CustomerCreditSchema, unknown>;
declare function customerCreditSchemaFromJSON(jsonString: string): Result$1<CustomerCreditSchema, SDKValidationError>;
/** @internal */
declare const CustomerModelMarkups$inboundSchema: z$1.ZodMiniType<CustomerModelMarkups, unknown>;
declare function customerModelMarkupsFromJSON(jsonString: string): Result$1<CustomerModelMarkups, SDKValidationError>;
/** @internal */
declare const CustomerProviderMarkups$inboundSchema: z$1.ZodMiniType<CustomerProviderMarkups, unknown>;
declare function customerProviderMarkupsFromJSON(jsonString: string): Result$1<CustomerProviderMarkups, SDKValidationError>;
/** @internal */
declare const CustomerDisplay$inboundSchema: z$1.ZodMiniType<CustomerDisplay, unknown>;
declare function customerDisplayFromJSON(jsonString: string): Result$1<CustomerDisplay, SDKValidationError>;
/** @internal */
declare const CustomerFeature$inboundSchema: z$1.ZodMiniType<CustomerFeature, unknown>;
declare function customerFeatureFromJSON(jsonString: string): Result$1<CustomerFeature, SDKValidationError>;
/** @internal */
declare const Flags$inboundSchema: z$1.ZodMiniType<Flags, unknown>;
declare function flagsFromJSON(jsonString: string): Result$1<Flags, SDKValidationError>;
/** @internal */
declare const CustomerConfig$inboundSchema: z$1.ZodMiniType<CustomerConfig, unknown>;
declare function customerConfigFromJSON(jsonString: string): Result$1<CustomerConfig, SDKValidationError>;
/** @internal */
declare const Stripe$inboundSchema: z$1.ZodMiniType<Stripe, unknown>;
declare function stripeFromJSON(jsonString: string): Result$1<Stripe, SDKValidationError>;
/** @internal */
declare const Vercel$inboundSchema: z$1.ZodMiniType<Vercel, unknown>;
declare function vercelFromJSON(jsonString: string): Result$1<Vercel, SDKValidationError>;
/** @internal */
declare const Revenuecat$inboundSchema: z$1.ZodMiniType<Revenuecat, unknown>;
declare function revenuecatFromJSON(jsonString: string): Result$1<Revenuecat, SDKValidationError>;
/** @internal */
declare const Processors$inboundSchema: z$1.ZodMiniType<Processors, unknown>;
declare function processorsFromJSON(jsonString: string): Result$1<Processors, SDKValidationError>;
/** @internal */
declare const ProcessorType$inboundSchema: z$1.ZodMiniType<ProcessorType, unknown>;
/** @internal */
declare const Invoice$inboundSchema: z$1.ZodMiniType<Invoice, unknown>;
declare function invoiceFromJSON(jsonString: string): Result$1<Invoice, SDKValidationError>;
/** @internal */
declare const CustomerEntityEnv$inboundSchema: z$1.ZodMiniType<CustomerEntityEnv, unknown>;
/** @internal */
declare const Entity$inboundSchema: z$1.ZodMiniType<Entity, unknown>;
declare function entityFromJSON(jsonString: string): Result$1<Entity, SDKValidationError>;
/** @internal */
declare const TrialsUsed$inboundSchema: z$1.ZodMiniType<TrialsUsed, unknown>;
declare function trialsUsedFromJSON(jsonString: string): Result$1<TrialsUsed, SDKValidationError>;
/** @internal */
declare const CustomerDiscountType$inboundSchema: z$1.ZodMiniType<CustomerDiscountType, unknown>;
/** @internal */
declare const CustomerDurationType$inboundSchema: z$1.ZodMiniType<CustomerDurationType, unknown>;
/** @internal */
declare const Discount$inboundSchema: z$1.ZodMiniType<Discount, unknown>;
declare function discountFromJSON(jsonString: string): Result$1<Discount, SDKValidationError>;
/** @internal */
declare const Rewards$inboundSchema: z$1.ZodMiniType<Rewards$1, unknown>;
declare function rewardsFromJSON(jsonString: string): Result$1<Rewards$1, SDKValidationError>;
/** @internal */
declare const ReferralCustomer$inboundSchema: z$1.ZodMiniType<ReferralCustomer, unknown>;
declare function referralCustomerFromJSON(jsonString: string): Result$1<ReferralCustomer, SDKValidationError>;
/** @internal */
declare const Referral$inboundSchema: z$1.ZodMiniType<Referral, unknown>;
declare function referralFromJSON(jsonString: string): Result$1<Referral, SDKValidationError>;
/** @internal */
declare const Customer$inboundSchema: z$1.ZodMiniType<Customer, unknown>;
declare function customerFromJSON(jsonString: string): Result$1<Customer, SDKValidationError>;

type DeleteBalanceGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Target a specific balance by its reset interval. Use when the customer has multiple balances for the same feature with different reset intervals.
 */
declare const DeleteBalanceInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Target a specific balance by its reset interval. Use when the customer has multiple balances for the same feature with different reset intervals.
 */
type DeleteBalanceInterval = ClosedEnum<typeof DeleteBalanceInterval>;
type DeleteBalanceParams = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the entity.
     */
    entityId?: string | undefined;
    /**
     * The ID of the feature.
     */
    featureId?: string | undefined;
    /**
     * The ID of the balance to delete.
     */
    balanceId?: string | undefined;
    /**
     * If true, deduct the deleted balance's remaining amount from the customer's other balances for the same feature after deletion.
     */
    recalculateBalances?: boolean | undefined;
    /**
     * Target a specific balance by its reset interval. Use when the customer has multiple balances for the same feature with different reset intervals.
     */
    interval?: DeleteBalanceInterval | undefined;
};
/**
 * OK
 */
type DeleteBalanceResponse = {
    success: boolean;
};
/** @internal */
declare const DeleteBalanceInterval$outboundSchema: z$1.ZodMiniEnum<typeof DeleteBalanceInterval>;
/** @internal */
type DeleteBalanceParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    feature_id?: string | undefined;
    balance_id?: string | undefined;
    recalculate_balances?: boolean | undefined;
    interval?: string | undefined;
};
/** @internal */
declare const DeleteBalanceParams$outboundSchema: z$1.ZodMiniType<DeleteBalanceParams$Outbound, DeleteBalanceParams>;
declare function deleteBalanceParamsToJSON(deleteBalanceParams: DeleteBalanceParams): string;
/** @internal */
declare const DeleteBalanceResponse$inboundSchema: z$1.ZodMiniType<DeleteBalanceResponse, unknown>;
declare function deleteBalanceResponseFromJSON(jsonString: string): Result$1<DeleteBalanceResponse, SDKValidationError>;

type DeleteCustomerGlobals = {
    xApiVersion?: string | undefined;
};
type DeleteCustomerParams = {
    /**
     * ID of the customer to delete
     */
    customerId: string;
    /**
     * Whether to also delete the customer in Stripe
     */
    deleteInStripe?: boolean | undefined;
};
/**
 * OK
 */
type DeleteCustomerResponse = {
    success: boolean;
};
/** @internal */
type DeleteCustomerParams$Outbound = {
    customer_id: string;
    delete_in_stripe: boolean;
};
/** @internal */
declare const DeleteCustomerParams$outboundSchema: z$1.ZodMiniType<DeleteCustomerParams$Outbound, DeleteCustomerParams>;
declare function deleteCustomerParamsToJSON(deleteCustomerParams: DeleteCustomerParams): string;
/** @internal */
declare const DeleteCustomerResponse$inboundSchema: z$1.ZodMiniType<DeleteCustomerResponse, unknown>;
declare function deleteCustomerResponseFromJSON(jsonString: string): Result$1<DeleteCustomerResponse, SDKValidationError>;

type DeleteEntityGlobals = {
    xApiVersion?: string | undefined;
};
type DeleteEntityParams = {
    /**
     * The ID of the customer.
     */
    customerId?: string | undefined;
    /**
     * The ID of the entity.
     */
    entityId: string;
};
/**
 * OK
 */
type DeleteEntityResponse = {
    success: boolean;
};
/** @internal */
type DeleteEntityParams$Outbound = {
    customer_id?: string | undefined;
    entity_id: string;
};
/** @internal */
declare const DeleteEntityParams$outboundSchema: z$1.ZodMiniType<DeleteEntityParams$Outbound, DeleteEntityParams>;
declare function deleteEntityParamsToJSON(deleteEntityParams: DeleteEntityParams): string;
/** @internal */
declare const DeleteEntityResponse$inboundSchema: z$1.ZodMiniType<DeleteEntityResponse, unknown>;
declare function deleteEntityResponseFromJSON(jsonString: string): Result$1<DeleteEntityResponse, SDKValidationError>;

type DeleteFeatureGlobals = {
    xApiVersion?: string | undefined;
};
type DeleteFeatureParams = {
    /**
     * The ID of the feature to delete.
     */
    featureId: string;
};
/**
 * OK
 */
type DeleteFeatureResponse = {
    success: boolean;
};
/** @internal */
type DeleteFeatureParams$Outbound = {
    feature_id: string;
};
/** @internal */
declare const DeleteFeatureParams$outboundSchema: z$1.ZodMiniType<DeleteFeatureParams$Outbound, DeleteFeatureParams>;
declare function deleteFeatureParamsToJSON(deleteFeatureParams: DeleteFeatureParams): string;
/** @internal */
declare const DeleteFeatureResponse$inboundSchema: z$1.ZodMiniType<DeleteFeatureResponse, unknown>;
declare function deleteFeatureResponseFromJSON(jsonString: string): Result$1<DeleteFeatureResponse, SDKValidationError>;

type DeletePlanGlobals = {
    xApiVersion?: string | undefined;
};
type DeletePlanParams = {
    /**
     * The ID of the plan to delete.
     */
    planId: string;
    /**
     * If true, deletes all versions of the plan. Otherwise, only deletes the latest version.
     */
    allVersions?: boolean | undefined;
};
/**
 * OK
 */
type DeletePlanResponse = {
    success: boolean;
};
/** @internal */
type DeletePlanParams$Outbound = {
    plan_id: string;
    all_versions: boolean;
};
/** @internal */
declare const DeletePlanParams$outboundSchema: z$1.ZodMiniType<DeletePlanParams$Outbound, DeletePlanParams>;
declare function deletePlanParamsToJSON(deletePlanParams: DeletePlanParams): string;
/** @internal */
declare const DeletePlanResponse$inboundSchema: z$1.ZodMiniType<DeletePlanResponse, unknown>;
declare function deletePlanResponseFromJSON(jsonString: string): Result$1<DeletePlanResponse, SDKValidationError>;

type FinalizeLockGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Use 'confirm' to commit the deduction, or 'release' to return the held balance.
 */
declare const FinalizeLockAction: {
    readonly Confirm: "confirm";
    readonly Release: "release";
};
/**
 * Use 'confirm' to commit the deduction, or 'release' to return the held balance.
 */
type FinalizeLockAction = ClosedEnum<typeof FinalizeLockAction>;
type FinalizeBalanceParams = {
    /**
     * The lock ID that was passed into the previous check call.
     */
    lockId: string;
    /**
     * Use 'confirm' to commit the deduction, or 'release' to return the held balance.
     */
    action: FinalizeLockAction;
    /**
     * Additional properties to attach to this finalize lock event.
     */
    overrideValue?: number | undefined;
    /**
     * Additional properties to attach to this finalize lock event.
     */
    properties?: {
        [k: string]: any;
    } | undefined;
};
/**
 * Accepted. Autumn is experiencing degraded service from a downstream provider, so the finalize request was allowed fail-open.
 */
type FinalizeLockResponseBody2 = {
    success: boolean;
};
/**
 * OK
 */
type FinalizeLockResponseBody1 = {
    success: boolean;
};
type FinalizeLockResponse = FinalizeLockResponseBody1 | FinalizeLockResponseBody2;
/** @internal */
declare const FinalizeLockAction$outboundSchema: z$1.ZodMiniEnum<typeof FinalizeLockAction>;
/** @internal */
type FinalizeBalanceParams$Outbound = {
    lock_id: string;
    action: string;
    override_value?: number | undefined;
    properties?: {
        [k: string]: any;
    } | undefined;
};
/** @internal */
declare const FinalizeBalanceParams$outboundSchema: z$1.ZodMiniType<FinalizeBalanceParams$Outbound, FinalizeBalanceParams>;
declare function finalizeBalanceParamsToJSON(finalizeBalanceParams: FinalizeBalanceParams): string;
/** @internal */
declare const FinalizeLockResponseBody2$inboundSchema: z$1.ZodMiniType<FinalizeLockResponseBody2, unknown>;
declare function finalizeLockResponseBody2FromJSON(jsonString: string): Result$1<FinalizeLockResponseBody2, SDKValidationError>;
/** @internal */
declare const FinalizeLockResponseBody1$inboundSchema: z$1.ZodMiniType<FinalizeLockResponseBody1, unknown>;
declare function finalizeLockResponseBody1FromJSON(jsonString: string): Result$1<FinalizeLockResponseBody1, SDKValidationError>;
/** @internal */
declare const FinalizeLockResponse$inboundSchema: z$1.ZodMiniType<FinalizeLockResponse, unknown>;
declare function finalizeLockResponseFromJSON(jsonString: string): Result$1<FinalizeLockResponse, SDKValidationError>;

type GetCustomerGlobals = {
    xApiVersion?: string | undefined;
};
type GetCustomerParams = {
    /**
     * ID of the customer to fetch
     */
    customerId: string;
    /**
     * Expand related customer data like invoices or entities, or expand nested objects like balances.feature, flags.feature, subscriptions.plan, and purchases.plan.
     */
    expand?: Array<CustomerExpand> | undefined;
};
/**
 * The environment this customer was created in.
 */
declare const GetCustomerEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment this customer was created in.
 */
type GetCustomerEnv = OpenEnum<typeof GetCustomerEnv>;
/**
 * The time interval for the purchase limit window.
 */
declare const GetCustomerPurchaseLimitInterval2: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type GetCustomerPurchaseLimitInterval2 = OpenEnum<typeof GetCustomerPurchaseLimitInterval2>;
type GetCustomerPurchaseLimit2 = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: GetCustomerPurchaseLimitInterval2;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
declare const GetCustomerPurchaseLimitInterval1: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
type GetCustomerPurchaseLimitInterval1 = OpenEnum<typeof GetCustomerPurchaseLimitInterval1>;
type GetCustomerPurchaseLimit1 = {
    /**
     * The time interval for the purchase limit window. Null when no purchase limit is configured.
     */
    interval: GetCustomerPurchaseLimitInterval1 | null;
    /**
     * Number of intervals in the purchase limit window. Null when no purchase limit is configured.
     */
    intervalCount: number | null;
    /**
     * Maximum number of auto top-ups allowed within the interval. Null when no purchase limit is configured.
     */
    limit: number | null;
    /**
     * Number of auto top-ups already consumed in the current window.
     */
    count: number;
    /**
     * Unix ms timestamp when the current purchase window ends and the count resets.
     */
    nextResetAt: number;
};
/**
 * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
 */
type GetCustomerPurchaseLimitUnion = GetCustomerPurchaseLimit1 | GetCustomerPurchaseLimit2;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetCustomerAutoTopupSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetCustomerAutoTopupSource = OpenEnum<typeof GetCustomerAutoTopupSource>;
type GetCustomerAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
     */
    purchaseLimit?: GetCustomerPurchaseLimit1 | GetCustomerPurchaseLimit2 | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetCustomerAutoTopupSource | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const GetCustomerLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type GetCustomerLimitType = OpenEnum<typeof GetCustomerLimitType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetCustomerSpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetCustomerSpendLimitSource = OpenEnum<typeof GetCustomerSpendLimitSource>;
type GetCustomerSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: GetCustomerLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetCustomerSpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const GetCustomerUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type GetCustomerUsageLimitInterval = OpenEnum<typeof GetCustomerUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type GetCustomerFilter = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetCustomerUsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetCustomerUsageLimitSource = OpenEnum<typeof GetCustomerUsageLimitSource>;
type GetCustomerUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: GetCustomerUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: GetCustomerFilter | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetCustomerUsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const GetCustomerThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type GetCustomerThresholdType = OpenEnum<typeof GetCustomerThresholdType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetCustomerUsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetCustomerUsageAlertSource = OpenEnum<typeof GetCustomerUsageAlertSource>;
type GetCustomerUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: GetCustomerThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetCustomerUsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetCustomerOverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetCustomerOverageAllowedSource = OpenEnum<typeof GetCustomerOverageAllowedSource>;
type GetCustomerOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetCustomerOverageAllowedSource | undefined;
};
/**
 * Billing controls for the customer (auto top-ups, etc.)
 */
type GetCustomerBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<GetCustomerAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<GetCustomerSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature, with current interval usage.
     */
    usageLimits?: Array<GetCustomerUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<GetCustomerUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<GetCustomerOverageAllowed> | undefined;
};
/**
 * Current status of the subscription.
 */
declare const GetCustomerStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type GetCustomerStatus = OpenEnum<typeof GetCustomerStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const GetCustomerSubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type GetCustomerSubscriptionScope = OpenEnum<typeof GetCustomerSubscriptionScope>;
type GetCustomerSubscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: GetCustomerStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: GetCustomerSubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const GetCustomerPurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type GetCustomerPurchaseScope = OpenEnum<typeof GetCustomerPurchaseScope>;
type GetCustomerPurchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: GetCustomerPurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const GetCustomerFlagsType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type GetCustomerFlagsType = OpenEnum<typeof GetCustomerFlagsType>;
type GetCustomerCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type GetCustomerModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type GetCustomerProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type GetCustomerDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type GetCustomerFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: GetCustomerFlagsType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<GetCustomerCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: GetCustomerModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: GetCustomerProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: GetCustomerDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type GetCustomerFlags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: GetCustomerFeature | undefined;
};
/**
 * Configuration for the customer.
 */
type GetCustomerConfig = {
    /**
     * Whether to disable the shared customer-level pool for entities.
     */
    disablePooledBalance?: boolean | undefined;
    /**
     * Stops Autumn from posting usage-overage line items to Stripe for this customer. Check/track and balance resets still behave normally. When set, this overrides the organization-level disable_overage_billing setting.
     */
    disableOverageBilling?: boolean | undefined;
};
/**
 * Stripe processor connection for the customer.
 */
type GetCustomerStripe = {
    /**
     * Stripe customer ID.
     */
    id: string;
};
/**
 * Vercel processor connection for the customer (public-safe subset).
 */
type GetCustomerVercel = {
    /**
     * Vercel marketplace installation ID for this customer.
     */
    installationId: string;
    /**
     * Vercel account ID associated with the installation.
     */
    accountId: string;
};
/**
 * RevenueCat processor connection for the customer.
 */
type GetCustomerRevenuecat = {
    /**
     * Customer's external ID, used as the RevenueCat app user ID. Null if the customer has no external ID set.
     */
    id: string | null;
};
/**
 * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
 */
type GetCustomerProcessors = {
    /**
     * Stripe processor connection for the customer.
     */
    stripe?: GetCustomerStripe | undefined;
    /**
     * Vercel processor connection for the customer (public-safe subset).
     */
    vercel?: GetCustomerVercel | undefined;
    /**
     * RevenueCat processor connection for the customer.
     */
    revenuecat?: GetCustomerRevenuecat | undefined;
};
/**
 * The billing processor that owns this invoice.
 */
declare const GetCustomerProcessorType: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The billing processor that owns this invoice.
 */
type GetCustomerProcessorType = OpenEnum<typeof GetCustomerProcessorType>;
type GetCustomerInvoice = {
    /**
     * Array of plan IDs included in this invoice
     */
    planIds: Array<string>;
    /**
     * The Stripe invoice ID
     */
    stripeId: string;
    /**
     * The billing processor that owns this invoice.
     */
    processorType: GetCustomerProcessorType;
    /**
     * The status of the invoice
     */
    status: string;
    /**
     * The total amount of the invoice
     */
    total: number;
    /**
     * The currency code for the invoice
     */
    currency: string;
    /**
     * Timestamp when the invoice was created
     */
    createdAt: number;
    /**
     * URL to the Stripe-hosted invoice page
     */
    hostedInvoiceUrl?: string | null | undefined;
};
/**
 * The environment (sandbox/live)
 */
declare const GetCustomerEntityEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment (sandbox/live)
 */
type GetCustomerEntityEnv = OpenEnum<typeof GetCustomerEntityEnv>;
type GetCustomerEntity = {
    /**
     * The unique identifier of the entity
     */
    id: string | null;
    /**
     * The name of the entity
     */
    name: string | null;
    /**
     * The customer ID this entity belongs to
     */
    customerId?: string | null | undefined;
    /**
     * The feature ID this entity belongs to
     */
    featureId?: string | null | undefined;
    /**
     * Unix timestamp when the entity was created
     */
    createdAt: number;
    /**
     * The environment (sandbox/live)
     */
    env: GetCustomerEntityEnv;
};
type GetCustomerTrialsUsed = {
    planId: string;
    customerId: string;
    fingerprint?: string | null | undefined;
};
/**
 * The type of reward
 */
declare const GetCustomerDiscountType: {
    readonly PercentageDiscount: "percentage_discount";
    readonly FixedDiscount: "fixed_discount";
    readonly FreeProduct: "free_product";
    readonly InvoiceCredits: "invoice_credits";
    readonly FeatureGrant: "feature_grant";
};
/**
 * The type of reward
 */
type GetCustomerDiscountType = OpenEnum<typeof GetCustomerDiscountType>;
/**
 * How long the discount lasts
 */
declare const GetCustomerDurationType: {
    readonly OneOff: "one_off";
    readonly Months: "months";
    readonly Forever: "forever";
};
/**
 * How long the discount lasts
 */
type GetCustomerDurationType = OpenEnum<typeof GetCustomerDurationType>;
type GetCustomerDiscount = {
    /**
     * The unique identifier for this discount
     */
    id: string;
    /**
     * The name of the discount or coupon
     */
    name: string;
    /**
     * The type of reward
     */
    type: GetCustomerDiscountType;
    /**
     * The discount value (percentage or fixed amount)
     */
    discountValue: number;
    /**
     * How long the discount lasts
     */
    durationType: GetCustomerDurationType;
    /**
     * Number of billing periods the discount applies for repeating durations
     */
    durationValue?: number | null | undefined;
    /**
     * The currency code for fixed amount discounts
     */
    currency?: string | null | undefined;
    /**
     * Timestamp when the discount becomes active
     */
    start?: number | null | undefined;
    /**
     * Timestamp when the discount expires
     */
    end?: number | null | undefined;
    /**
     * The Stripe subscription ID this discount is applied to
     */
    subscriptionId?: string | null | undefined;
    /**
     * Total amount saved from this discount
     */
    totalDiscountAmount?: number | null | undefined;
};
type GetCustomerRewards = {
    /**
     * Array of active discounts applied to the customer
     */
    discounts: Array<GetCustomerDiscount>;
};
type GetCustomerCustomer = {
    id: string;
    name?: string | null | undefined;
    email?: string | null | undefined;
};
type GetCustomerReferral = {
    programId: string;
    customer: GetCustomerCustomer;
    rewardApplied: boolean;
    createdAt: number;
};
/**
 * OK
 */
type GetCustomerResponse = {
    /**
     * Your unique identifier for the customer.
     */
    id: string | null;
    /**
     * The name of the customer.
     */
    name: string | null;
    /**
     * The email address of the customer.
     */
    email: string | null;
    /**
     * Timestamp of customer creation in milliseconds since epoch.
     */
    createdAt: number;
    /**
     * A unique identifier (eg. serial number) to de-duplicate customers across devices or browsers. For example: apple device ID.
     */
    fingerprint: string | null;
    /**
     * Stripe customer ID.
     */
    stripeId: string | null;
    /**
     * The environment this customer was created in.
     */
    env: GetCustomerEnv;
    /**
     * The metadata for the customer.
     */
    metadata: {
        [k: string]: any;
    };
    /**
     * Whether to send email receipts to the customer.
     */
    sendEmailReceipts: boolean;
    /**
     * Billing controls for the customer (auto top-ups, etc.)
     */
    billingControls: GetCustomerBillingControls;
    /**
     * Active and scheduled recurring plans that this customer has attached.
     */
    subscriptions: Array<GetCustomerSubscription>;
    /**
     * One-time purchases made by the customer.
     */
    purchases: Array<GetCustomerPurchase>;
    /**
     * Feature balances keyed by feature ID, showing usage limits and remaining amounts.
     */
    balances: {
        [k: string]: Balance;
    };
    /**
     * Boolean feature flags keyed by feature ID, showing enabled access for on/off features.
     */
    flags: {
        [k: string]: GetCustomerFlags;
    };
    /**
     * Configuration for the customer.
     */
    config?: GetCustomerConfig | undefined;
    /**
     * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
     */
    processors?: GetCustomerProcessors | undefined;
    /**
     * Invoices for this customer.
     */
    invoices?: Array<GetCustomerInvoice> | undefined;
    /**
     * Entities associated with this customer.
     */
    entities?: Array<GetCustomerEntity> | undefined;
    /**
     * Trial usage history for this customer.
     */
    trialsUsed?: Array<GetCustomerTrialsUsed> | undefined;
    /**
     * Rewards earned or applied for this customer.
     */
    rewards?: GetCustomerRewards | null | undefined;
    /**
     * Referral records for this customer.
     */
    referrals?: Array<GetCustomerReferral> | undefined;
    /**
     * The customer's default payment method.
     */
    paymentMethod?: any | null | undefined;
};
/** @internal */
type GetCustomerParams$Outbound = {
    customer_id: string;
    expand?: Array<string> | undefined;
};
/** @internal */
declare const GetCustomerParams$outboundSchema: z$1.ZodMiniType<GetCustomerParams$Outbound, GetCustomerParams>;
declare function getCustomerParamsToJSON(getCustomerParams: GetCustomerParams): string;
/** @internal */
declare const GetCustomerEnv$inboundSchema: z$1.ZodMiniType<GetCustomerEnv, unknown>;
/** @internal */
declare const GetCustomerPurchaseLimitInterval2$inboundSchema: z$1.ZodMiniType<GetCustomerPurchaseLimitInterval2, unknown>;
/** @internal */
declare const GetCustomerPurchaseLimit2$inboundSchema: z$1.ZodMiniType<GetCustomerPurchaseLimit2, unknown>;
declare function getCustomerPurchaseLimit2FromJSON(jsonString: string): Result$1<GetCustomerPurchaseLimit2, SDKValidationError>;
/** @internal */
declare const GetCustomerPurchaseLimitInterval1$inboundSchema: z$1.ZodMiniType<GetCustomerPurchaseLimitInterval1, unknown>;
/** @internal */
declare const GetCustomerPurchaseLimit1$inboundSchema: z$1.ZodMiniType<GetCustomerPurchaseLimit1, unknown>;
declare function getCustomerPurchaseLimit1FromJSON(jsonString: string): Result$1<GetCustomerPurchaseLimit1, SDKValidationError>;
/** @internal */
declare const GetCustomerPurchaseLimitUnion$inboundSchema: z$1.ZodMiniType<GetCustomerPurchaseLimitUnion, unknown>;
declare function getCustomerPurchaseLimitUnionFromJSON(jsonString: string): Result$1<GetCustomerPurchaseLimitUnion, SDKValidationError>;
/** @internal */
declare const GetCustomerAutoTopupSource$inboundSchema: z$1.ZodMiniType<GetCustomerAutoTopupSource, unknown>;
/** @internal */
declare const GetCustomerAutoTopup$inboundSchema: z$1.ZodMiniType<GetCustomerAutoTopup, unknown>;
declare function getCustomerAutoTopupFromJSON(jsonString: string): Result$1<GetCustomerAutoTopup, SDKValidationError>;
/** @internal */
declare const GetCustomerLimitType$inboundSchema: z$1.ZodMiniType<GetCustomerLimitType, unknown>;
/** @internal */
declare const GetCustomerSpendLimitSource$inboundSchema: z$1.ZodMiniType<GetCustomerSpendLimitSource, unknown>;
/** @internal */
declare const GetCustomerSpendLimit$inboundSchema: z$1.ZodMiniType<GetCustomerSpendLimit, unknown>;
declare function getCustomerSpendLimitFromJSON(jsonString: string): Result$1<GetCustomerSpendLimit, SDKValidationError>;
/** @internal */
declare const GetCustomerUsageLimitInterval$inboundSchema: z$1.ZodMiniType<GetCustomerUsageLimitInterval, unknown>;
/** @internal */
declare const GetCustomerFilter$inboundSchema: z$1.ZodMiniType<GetCustomerFilter, unknown>;
declare function getCustomerFilterFromJSON(jsonString: string): Result$1<GetCustomerFilter, SDKValidationError>;
/** @internal */
declare const GetCustomerUsageLimitSource$inboundSchema: z$1.ZodMiniType<GetCustomerUsageLimitSource, unknown>;
/** @internal */
declare const GetCustomerUsageLimit$inboundSchema: z$1.ZodMiniType<GetCustomerUsageLimit, unknown>;
declare function getCustomerUsageLimitFromJSON(jsonString: string): Result$1<GetCustomerUsageLimit, SDKValidationError>;
/** @internal */
declare const GetCustomerThresholdType$inboundSchema: z$1.ZodMiniType<GetCustomerThresholdType, unknown>;
/** @internal */
declare const GetCustomerUsageAlertSource$inboundSchema: z$1.ZodMiniType<GetCustomerUsageAlertSource, unknown>;
/** @internal */
declare const GetCustomerUsageAlert$inboundSchema: z$1.ZodMiniType<GetCustomerUsageAlert, unknown>;
declare function getCustomerUsageAlertFromJSON(jsonString: string): Result$1<GetCustomerUsageAlert, SDKValidationError>;
/** @internal */
declare const GetCustomerOverageAllowedSource$inboundSchema: z$1.ZodMiniType<GetCustomerOverageAllowedSource, unknown>;
/** @internal */
declare const GetCustomerOverageAllowed$inboundSchema: z$1.ZodMiniType<GetCustomerOverageAllowed, unknown>;
declare function getCustomerOverageAllowedFromJSON(jsonString: string): Result$1<GetCustomerOverageAllowed, SDKValidationError>;
/** @internal */
declare const GetCustomerBillingControls$inboundSchema: z$1.ZodMiniType<GetCustomerBillingControls, unknown>;
declare function getCustomerBillingControlsFromJSON(jsonString: string): Result$1<GetCustomerBillingControls, SDKValidationError>;
/** @internal */
declare const GetCustomerStatus$inboundSchema: z$1.ZodMiniType<GetCustomerStatus, unknown>;
/** @internal */
declare const GetCustomerSubscriptionScope$inboundSchema: z$1.ZodMiniType<GetCustomerSubscriptionScope, unknown>;
/** @internal */
declare const GetCustomerSubscription$inboundSchema: z$1.ZodMiniType<GetCustomerSubscription, unknown>;
declare function getCustomerSubscriptionFromJSON(jsonString: string): Result$1<GetCustomerSubscription, SDKValidationError>;
/** @internal */
declare const GetCustomerPurchaseScope$inboundSchema: z$1.ZodMiniType<GetCustomerPurchaseScope, unknown>;
/** @internal */
declare const GetCustomerPurchase$inboundSchema: z$1.ZodMiniType<GetCustomerPurchase, unknown>;
declare function getCustomerPurchaseFromJSON(jsonString: string): Result$1<GetCustomerPurchase, SDKValidationError>;
/** @internal */
declare const GetCustomerFlagsType$inboundSchema: z$1.ZodMiniType<GetCustomerFlagsType, unknown>;
/** @internal */
declare const GetCustomerCreditSchema$inboundSchema: z$1.ZodMiniType<GetCustomerCreditSchema, unknown>;
declare function getCustomerCreditSchemaFromJSON(jsonString: string): Result$1<GetCustomerCreditSchema, SDKValidationError>;
/** @internal */
declare const GetCustomerModelMarkups$inboundSchema: z$1.ZodMiniType<GetCustomerModelMarkups, unknown>;
declare function getCustomerModelMarkupsFromJSON(jsonString: string): Result$1<GetCustomerModelMarkups, SDKValidationError>;
/** @internal */
declare const GetCustomerProviderMarkups$inboundSchema: z$1.ZodMiniType<GetCustomerProviderMarkups, unknown>;
declare function getCustomerProviderMarkupsFromJSON(jsonString: string): Result$1<GetCustomerProviderMarkups, SDKValidationError>;
/** @internal */
declare const GetCustomerDisplay$inboundSchema: z$1.ZodMiniType<GetCustomerDisplay, unknown>;
declare function getCustomerDisplayFromJSON(jsonString: string): Result$1<GetCustomerDisplay, SDKValidationError>;
/** @internal */
declare const GetCustomerFeature$inboundSchema: z$1.ZodMiniType<GetCustomerFeature, unknown>;
declare function getCustomerFeatureFromJSON(jsonString: string): Result$1<GetCustomerFeature, SDKValidationError>;
/** @internal */
declare const GetCustomerFlags$inboundSchema: z$1.ZodMiniType<GetCustomerFlags, unknown>;
declare function getCustomerFlagsFromJSON(jsonString: string): Result$1<GetCustomerFlags, SDKValidationError>;
/** @internal */
declare const GetCustomerConfig$inboundSchema: z$1.ZodMiniType<GetCustomerConfig, unknown>;
declare function getCustomerConfigFromJSON(jsonString: string): Result$1<GetCustomerConfig, SDKValidationError>;
/** @internal */
declare const GetCustomerStripe$inboundSchema: z$1.ZodMiniType<GetCustomerStripe, unknown>;
declare function getCustomerStripeFromJSON(jsonString: string): Result$1<GetCustomerStripe, SDKValidationError>;
/** @internal */
declare const GetCustomerVercel$inboundSchema: z$1.ZodMiniType<GetCustomerVercel, unknown>;
declare function getCustomerVercelFromJSON(jsonString: string): Result$1<GetCustomerVercel, SDKValidationError>;
/** @internal */
declare const GetCustomerRevenuecat$inboundSchema: z$1.ZodMiniType<GetCustomerRevenuecat, unknown>;
declare function getCustomerRevenuecatFromJSON(jsonString: string): Result$1<GetCustomerRevenuecat, SDKValidationError>;
/** @internal */
declare const GetCustomerProcessors$inboundSchema: z$1.ZodMiniType<GetCustomerProcessors, unknown>;
declare function getCustomerProcessorsFromJSON(jsonString: string): Result$1<GetCustomerProcessors, SDKValidationError>;
/** @internal */
declare const GetCustomerProcessorType$inboundSchema: z$1.ZodMiniType<GetCustomerProcessorType, unknown>;
/** @internal */
declare const GetCustomerInvoice$inboundSchema: z$1.ZodMiniType<GetCustomerInvoice, unknown>;
declare function getCustomerInvoiceFromJSON(jsonString: string): Result$1<GetCustomerInvoice, SDKValidationError>;
/** @internal */
declare const GetCustomerEntityEnv$inboundSchema: z$1.ZodMiniType<GetCustomerEntityEnv, unknown>;
/** @internal */
declare const GetCustomerEntity$inboundSchema: z$1.ZodMiniType<GetCustomerEntity, unknown>;
declare function getCustomerEntityFromJSON(jsonString: string): Result$1<GetCustomerEntity, SDKValidationError>;
/** @internal */
declare const GetCustomerTrialsUsed$inboundSchema: z$1.ZodMiniType<GetCustomerTrialsUsed, unknown>;
declare function getCustomerTrialsUsedFromJSON(jsonString: string): Result$1<GetCustomerTrialsUsed, SDKValidationError>;
/** @internal */
declare const GetCustomerDiscountType$inboundSchema: z$1.ZodMiniType<GetCustomerDiscountType, unknown>;
/** @internal */
declare const GetCustomerDurationType$inboundSchema: z$1.ZodMiniType<GetCustomerDurationType, unknown>;
/** @internal */
declare const GetCustomerDiscount$inboundSchema: z$1.ZodMiniType<GetCustomerDiscount, unknown>;
declare function getCustomerDiscountFromJSON(jsonString: string): Result$1<GetCustomerDiscount, SDKValidationError>;
/** @internal */
declare const GetCustomerRewards$inboundSchema: z$1.ZodMiniType<GetCustomerRewards, unknown>;
declare function getCustomerRewardsFromJSON(jsonString: string): Result$1<GetCustomerRewards, SDKValidationError>;
/** @internal */
declare const GetCustomerCustomer$inboundSchema: z$1.ZodMiniType<GetCustomerCustomer, unknown>;
declare function getCustomerCustomerFromJSON(jsonString: string): Result$1<GetCustomerCustomer, SDKValidationError>;
/** @internal */
declare const GetCustomerReferral$inboundSchema: z$1.ZodMiniType<GetCustomerReferral, unknown>;
declare function getCustomerReferralFromJSON(jsonString: string): Result$1<GetCustomerReferral, SDKValidationError>;
/** @internal */
declare const GetCustomerResponse$inboundSchema: z$1.ZodMiniType<GetCustomerResponse, unknown>;
declare function getCustomerResponseFromJSON(jsonString: string): Result$1<GetCustomerResponse, SDKValidationError>;

type GetEntityGlobals = {
    xApiVersion?: string | undefined;
};
type GetEntityParams = {
    /**
     * The ID of the customer to create the entity for.
     */
    customerId?: string | undefined;
    /**
     * The ID of the entity.
     */
    entityId: string;
};
/**
 * The environment (sandbox/live)
 */
declare const GetEntityEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment (sandbox/live)
 */
type GetEntityEnv = OpenEnum<typeof GetEntityEnv>;
/**
 * Current status of the subscription.
 */
declare const GetEntityStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type GetEntityStatus = OpenEnum<typeof GetEntityStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const GetEntitySubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type GetEntitySubscriptionScope = OpenEnum<typeof GetEntitySubscriptionScope>;
type GetEntitySubscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: GetEntityStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: GetEntitySubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const GetEntityPurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type GetEntityPurchaseScope = OpenEnum<typeof GetEntityPurchaseScope>;
type GetEntityPurchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: GetEntityPurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const GetEntityType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type GetEntityType = OpenEnum<typeof GetEntityType>;
type GetEntityCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type GetEntityModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type GetEntityProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type GetEntityDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type GetEntityFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: GetEntityType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<GetEntityCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: GetEntityModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: GetEntityProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: GetEntityDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type GetEntityFlags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: GetEntityFeature | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const GetEntityLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type GetEntityLimitType = OpenEnum<typeof GetEntityLimitType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetEntitySpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetEntitySpendLimitSource = OpenEnum<typeof GetEntitySpendLimitSource>;
type GetEntitySpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: GetEntityLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetEntitySpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const GetEntityInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type GetEntityInterval = OpenEnum<typeof GetEntityInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type GetEntityFilter = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetEntityUsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetEntityUsageLimitSource = OpenEnum<typeof GetEntityUsageLimitSource>;
type GetEntityUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: GetEntityInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: GetEntityFilter | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetEntityUsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const GetEntityThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type GetEntityThresholdType = OpenEnum<typeof GetEntityThresholdType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetEntityUsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetEntityUsageAlertSource = OpenEnum<typeof GetEntityUsageAlertSource>;
type GetEntityUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: GetEntityThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetEntityUsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const GetEntityOverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type GetEntityOverageAllowedSource = OpenEnum<typeof GetEntityOverageAllowedSource>;
type GetEntityOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: GetEntityOverageAllowedSource | undefined;
};
/**
 * Billing controls for the entity.
 */
type GetEntityBillingControls = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<GetEntitySpendLimit> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<GetEntityUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<GetEntityUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<GetEntityOverageAllowed> | undefined;
};
/**
 * The billing processor that owns this invoice.
 */
declare const GetEntityProcessorType: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The billing processor that owns this invoice.
 */
type GetEntityProcessorType = OpenEnum<typeof GetEntityProcessorType>;
type GetEntityInvoice = {
    /**
     * Array of plan IDs included in this invoice
     */
    planIds: Array<string>;
    /**
     * The Stripe invoice ID
     */
    stripeId: string;
    /**
     * The billing processor that owns this invoice.
     */
    processorType: GetEntityProcessorType;
    /**
     * The status of the invoice
     */
    status: string;
    /**
     * The total amount of the invoice
     */
    total: number;
    /**
     * The currency code for the invoice
     */
    currency: string;
    /**
     * Timestamp when the invoice was created
     */
    createdAt: number;
    /**
     * URL to the Stripe-hosted invoice page
     */
    hostedInvoiceUrl?: string | null | undefined;
};
/**
 * OK
 */
type GetEntityResponse = {
    /**
     * The unique identifier of the entity
     */
    id: string | null;
    /**
     * The name of the entity
     */
    name: string | null;
    /**
     * The customer ID this entity belongs to
     */
    customerId?: string | null | undefined;
    /**
     * The feature ID this entity belongs to
     */
    featureId?: string | null | undefined;
    /**
     * Unix timestamp when the entity was created
     */
    createdAt: number;
    /**
     * The environment (sandbox/live)
     */
    env: GetEntityEnv;
    subscriptions: Array<GetEntitySubscription>;
    purchases: Array<GetEntityPurchase>;
    balances: {
        [k: string]: Balance;
    };
    flags: {
        [k: string]: GetEntityFlags;
    };
    /**
     * Billing controls for the entity.
     */
    billingControls?: GetEntityBillingControls | undefined;
    /**
     * Invoices for this entity (only included when expand=invoices)
     */
    invoices?: Array<GetEntityInvoice> | undefined;
};
/** @internal */
type GetEntityParams$Outbound = {
    customer_id?: string | undefined;
    entity_id: string;
};
/** @internal */
declare const GetEntityParams$outboundSchema: z$1.ZodMiniType<GetEntityParams$Outbound, GetEntityParams>;
declare function getEntityParamsToJSON(getEntityParams: GetEntityParams): string;
/** @internal */
declare const GetEntityEnv$inboundSchema: z$1.ZodMiniType<GetEntityEnv, unknown>;
/** @internal */
declare const GetEntityStatus$inboundSchema: z$1.ZodMiniType<GetEntityStatus, unknown>;
/** @internal */
declare const GetEntitySubscriptionScope$inboundSchema: z$1.ZodMiniType<GetEntitySubscriptionScope, unknown>;
/** @internal */
declare const GetEntitySubscription$inboundSchema: z$1.ZodMiniType<GetEntitySubscription, unknown>;
declare function getEntitySubscriptionFromJSON(jsonString: string): Result$1<GetEntitySubscription, SDKValidationError>;
/** @internal */
declare const GetEntityPurchaseScope$inboundSchema: z$1.ZodMiniType<GetEntityPurchaseScope, unknown>;
/** @internal */
declare const GetEntityPurchase$inboundSchema: z$1.ZodMiniType<GetEntityPurchase, unknown>;
declare function getEntityPurchaseFromJSON(jsonString: string): Result$1<GetEntityPurchase, SDKValidationError>;
/** @internal */
declare const GetEntityType$inboundSchema: z$1.ZodMiniType<GetEntityType, unknown>;
/** @internal */
declare const GetEntityCreditSchema$inboundSchema: z$1.ZodMiniType<GetEntityCreditSchema, unknown>;
declare function getEntityCreditSchemaFromJSON(jsonString: string): Result$1<GetEntityCreditSchema, SDKValidationError>;
/** @internal */
declare const GetEntityModelMarkups$inboundSchema: z$1.ZodMiniType<GetEntityModelMarkups, unknown>;
declare function getEntityModelMarkupsFromJSON(jsonString: string): Result$1<GetEntityModelMarkups, SDKValidationError>;
/** @internal */
declare const GetEntityProviderMarkups$inboundSchema: z$1.ZodMiniType<GetEntityProviderMarkups, unknown>;
declare function getEntityProviderMarkupsFromJSON(jsonString: string): Result$1<GetEntityProviderMarkups, SDKValidationError>;
/** @internal */
declare const GetEntityDisplay$inboundSchema: z$1.ZodMiniType<GetEntityDisplay, unknown>;
declare function getEntityDisplayFromJSON(jsonString: string): Result$1<GetEntityDisplay, SDKValidationError>;
/** @internal */
declare const GetEntityFeature$inboundSchema: z$1.ZodMiniType<GetEntityFeature, unknown>;
declare function getEntityFeatureFromJSON(jsonString: string): Result$1<GetEntityFeature, SDKValidationError>;
/** @internal */
declare const GetEntityFlags$inboundSchema: z$1.ZodMiniType<GetEntityFlags, unknown>;
declare function getEntityFlagsFromJSON(jsonString: string): Result$1<GetEntityFlags, SDKValidationError>;
/** @internal */
declare const GetEntityLimitType$inboundSchema: z$1.ZodMiniType<GetEntityLimitType, unknown>;
/** @internal */
declare const GetEntitySpendLimitSource$inboundSchema: z$1.ZodMiniType<GetEntitySpendLimitSource, unknown>;
/** @internal */
declare const GetEntitySpendLimit$inboundSchema: z$1.ZodMiniType<GetEntitySpendLimit, unknown>;
declare function getEntitySpendLimitFromJSON(jsonString: string): Result$1<GetEntitySpendLimit, SDKValidationError>;
/** @internal */
declare const GetEntityInterval$inboundSchema: z$1.ZodMiniType<GetEntityInterval, unknown>;
/** @internal */
declare const GetEntityFilter$inboundSchema: z$1.ZodMiniType<GetEntityFilter, unknown>;
declare function getEntityFilterFromJSON(jsonString: string): Result$1<GetEntityFilter, SDKValidationError>;
/** @internal */
declare const GetEntityUsageLimitSource$inboundSchema: z$1.ZodMiniType<GetEntityUsageLimitSource, unknown>;
/** @internal */
declare const GetEntityUsageLimit$inboundSchema: z$1.ZodMiniType<GetEntityUsageLimit, unknown>;
declare function getEntityUsageLimitFromJSON(jsonString: string): Result$1<GetEntityUsageLimit, SDKValidationError>;
/** @internal */
declare const GetEntityThresholdType$inboundSchema: z$1.ZodMiniType<GetEntityThresholdType, unknown>;
/** @internal */
declare const GetEntityUsageAlertSource$inboundSchema: z$1.ZodMiniType<GetEntityUsageAlertSource, unknown>;
/** @internal */
declare const GetEntityUsageAlert$inboundSchema: z$1.ZodMiniType<GetEntityUsageAlert, unknown>;
declare function getEntityUsageAlertFromJSON(jsonString: string): Result$1<GetEntityUsageAlert, SDKValidationError>;
/** @internal */
declare const GetEntityOverageAllowedSource$inboundSchema: z$1.ZodMiniType<GetEntityOverageAllowedSource, unknown>;
/** @internal */
declare const GetEntityOverageAllowed$inboundSchema: z$1.ZodMiniType<GetEntityOverageAllowed, unknown>;
declare function getEntityOverageAllowedFromJSON(jsonString: string): Result$1<GetEntityOverageAllowed, SDKValidationError>;
/** @internal */
declare const GetEntityBillingControls$inboundSchema: z$1.ZodMiniType<GetEntityBillingControls, unknown>;
declare function getEntityBillingControlsFromJSON(jsonString: string): Result$1<GetEntityBillingControls, SDKValidationError>;
/** @internal */
declare const GetEntityProcessorType$inboundSchema: z$1.ZodMiniType<GetEntityProcessorType, unknown>;
/** @internal */
declare const GetEntityInvoice$inboundSchema: z$1.ZodMiniType<GetEntityInvoice, unknown>;
declare function getEntityInvoiceFromJSON(jsonString: string): Result$1<GetEntityInvoice, SDKValidationError>;
/** @internal */
declare const GetEntityResponse$inboundSchema: z$1.ZodMiniType<GetEntityResponse, unknown>;
declare function getEntityResponseFromJSON(jsonString: string): Result$1<GetEntityResponse, SDKValidationError>;

type GetFeatureGlobals = {
    xApiVersion?: string | undefined;
};
type GetFeatureParams = {
    /**
     * The ID of the feature.
     */
    featureId: string;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const GetFeatureType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type GetFeatureType = OpenEnum<typeof GetFeatureType>;
type GetFeatureCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type GetFeatureModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type GetFeatureProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type GetFeatureDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * OK
 */
type GetFeatureResponse = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: GetFeatureType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<GetFeatureCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: GetFeatureModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: GetFeatureProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: GetFeatureDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
/** @internal */
type GetFeatureParams$Outbound = {
    feature_id: string;
};
/** @internal */
declare const GetFeatureParams$outboundSchema: z$1.ZodMiniType<GetFeatureParams$Outbound, GetFeatureParams>;
declare function getFeatureParamsToJSON(getFeatureParams: GetFeatureParams): string;
/** @internal */
declare const GetFeatureType$inboundSchema: z$1.ZodMiniType<GetFeatureType, unknown>;
/** @internal */
declare const GetFeatureCreditSchema$inboundSchema: z$1.ZodMiniType<GetFeatureCreditSchema, unknown>;
declare function getFeatureCreditSchemaFromJSON(jsonString: string): Result$1<GetFeatureCreditSchema, SDKValidationError>;
/** @internal */
declare const GetFeatureModelMarkups$inboundSchema: z$1.ZodMiniType<GetFeatureModelMarkups, unknown>;
declare function getFeatureModelMarkupsFromJSON(jsonString: string): Result$1<GetFeatureModelMarkups, SDKValidationError>;
/** @internal */
declare const GetFeatureProviderMarkups$inboundSchema: z$1.ZodMiniType<GetFeatureProviderMarkups, unknown>;
declare function getFeatureProviderMarkupsFromJSON(jsonString: string): Result$1<GetFeatureProviderMarkups, SDKValidationError>;
/** @internal */
declare const GetFeatureDisplay$inboundSchema: z$1.ZodMiniType<GetFeatureDisplay, unknown>;
declare function getFeatureDisplayFromJSON(jsonString: string): Result$1<GetFeatureDisplay, SDKValidationError>;
/** @internal */
declare const GetFeatureResponse$inboundSchema: z$1.ZodMiniType<GetFeatureResponse, unknown>;
declare function getFeatureResponseFromJSON(jsonString: string): Result$1<GetFeatureResponse, SDKValidationError>;

type GetOrCreateCustomerGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const GetOrCreateCustomerPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type GetOrCreateCustomerPurchaseLimitInterval = ClosedEnum<typeof GetOrCreateCustomerPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type GetOrCreateCustomerPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: GetOrCreateCustomerPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type GetOrCreateCustomerAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: GetOrCreateCustomerPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const GetOrCreateCustomerLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type GetOrCreateCustomerLimitType = ClosedEnum<typeof GetOrCreateCustomerLimitType>;
type GetOrCreateCustomerSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: GetOrCreateCustomerLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const GetOrCreateCustomerUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type GetOrCreateCustomerUsageLimitInterval = ClosedEnum<typeof GetOrCreateCustomerUsageLimitInterval>;
type GetOrCreateCustomerProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type GetOrCreateCustomerFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type GetOrCreateCustomerUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: GetOrCreateCustomerUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: GetOrCreateCustomerFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const GetOrCreateCustomerThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type GetOrCreateCustomerThresholdType = ClosedEnum<typeof GetOrCreateCustomerThresholdType>;
type GetOrCreateCustomerUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: GetOrCreateCustomerThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type GetOrCreateCustomerOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Billing controls for the customer (auto top-ups, etc.)
 */
type GetOrCreateCustomerBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<GetOrCreateCustomerAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<GetOrCreateCustomerSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<GetOrCreateCustomerUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<GetOrCreateCustomerUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<GetOrCreateCustomerOverageAllowed> | undefined;
};
/**
 * Miscellaneous configurations for the customer.
 */
type GetOrCreateCustomerConfig = {
    /**
     * Whether to disable the shared customer-level pool for entities.
     */
    disablePooledBalance?: boolean | undefined;
    /**
     * Stops Autumn from posting usage-overage line items to Stripe for this customer. Check/track and balance resets still behave normally. When set, this overrides the organization-level disable_overage_billing setting.
     */
    disableOverageBilling?: boolean | undefined;
};
type GetOrCreateCustomerParams = {
    customerId: string | null;
    /**
     * Customer's name
     */
    name?: string | null | undefined;
    /**
     * Customer's email address
     */
    email?: string | null | undefined;
    /**
     * Unique identifier (eg, serial number) to detect duplicate customers and prevent free trial abuse
     */
    fingerprint?: string | null | undefined;
    /**
     * Additional metadata for the customer
     */
    metadata?: {
        [k: string]: any;
    } | null | undefined;
    /**
     * Stripe customer ID if you already have one
     */
    stripeId?: string | null | undefined;
    /**
     * Whether to create the customer in Stripe
     */
    createInStripe?: boolean | undefined;
    /**
     * The ID of the free plan to auto-enable for the customer
     */
    autoEnablePlanId?: string | undefined;
    /**
     * Whether to send email receipts to this customer
     */
    sendEmailReceipts?: boolean | undefined;
    /**
     * Billing controls for the customer (auto top-ups, etc.)
     */
    billingControls?: GetOrCreateCustomerBillingControls | undefined;
    /**
     * Miscellaneous configurations for the customer.
     */
    config?: GetOrCreateCustomerConfig | undefined;
    /**
     * Fields to expand in the returned customer response, such as subscriptions.plan, purchases.plan, balances.feature, or flags.feature.
     */
    expand?: Array<CustomerExpand> | undefined;
};
/** @internal */
declare const GetOrCreateCustomerPurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof GetOrCreateCustomerPurchaseLimitInterval>;
/** @internal */
type GetOrCreateCustomerPurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const GetOrCreateCustomerPurchaseLimit$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerPurchaseLimit$Outbound, GetOrCreateCustomerPurchaseLimit>;
declare function getOrCreateCustomerPurchaseLimitToJSON(getOrCreateCustomerPurchaseLimit: GetOrCreateCustomerPurchaseLimit): string;
/** @internal */
type GetOrCreateCustomerAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: GetOrCreateCustomerPurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const GetOrCreateCustomerAutoTopup$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerAutoTopup$Outbound, GetOrCreateCustomerAutoTopup>;
declare function getOrCreateCustomerAutoTopupToJSON(getOrCreateCustomerAutoTopup: GetOrCreateCustomerAutoTopup): string;
/** @internal */
declare const GetOrCreateCustomerLimitType$outboundSchema: z$1.ZodMiniEnum<typeof GetOrCreateCustomerLimitType>;
/** @internal */
type GetOrCreateCustomerSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const GetOrCreateCustomerSpendLimit$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerSpendLimit$Outbound, GetOrCreateCustomerSpendLimit>;
declare function getOrCreateCustomerSpendLimitToJSON(getOrCreateCustomerSpendLimit: GetOrCreateCustomerSpendLimit): string;
/** @internal */
declare const GetOrCreateCustomerUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof GetOrCreateCustomerUsageLimitInterval>;
/** @internal */
type GetOrCreateCustomerProperties$Outbound = string | number | boolean;
/** @internal */
declare const GetOrCreateCustomerProperties$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerProperties$Outbound, GetOrCreateCustomerProperties>;
declare function getOrCreateCustomerPropertiesToJSON(getOrCreateCustomerProperties: GetOrCreateCustomerProperties): string;
/** @internal */
type GetOrCreateCustomerFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const GetOrCreateCustomerFilter$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerFilter$Outbound, GetOrCreateCustomerFilter>;
declare function getOrCreateCustomerFilterToJSON(getOrCreateCustomerFilter: GetOrCreateCustomerFilter): string;
/** @internal */
type GetOrCreateCustomerUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: GetOrCreateCustomerFilter$Outbound | undefined;
};
/** @internal */
declare const GetOrCreateCustomerUsageLimit$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerUsageLimit$Outbound, GetOrCreateCustomerUsageLimit>;
declare function getOrCreateCustomerUsageLimitToJSON(getOrCreateCustomerUsageLimit: GetOrCreateCustomerUsageLimit): string;
/** @internal */
declare const GetOrCreateCustomerThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof GetOrCreateCustomerThresholdType>;
/** @internal */
type GetOrCreateCustomerUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const GetOrCreateCustomerUsageAlert$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerUsageAlert$Outbound, GetOrCreateCustomerUsageAlert>;
declare function getOrCreateCustomerUsageAlertToJSON(getOrCreateCustomerUsageAlert: GetOrCreateCustomerUsageAlert): string;
/** @internal */
type GetOrCreateCustomerOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const GetOrCreateCustomerOverageAllowed$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerOverageAllowed$Outbound, GetOrCreateCustomerOverageAllowed>;
declare function getOrCreateCustomerOverageAllowedToJSON(getOrCreateCustomerOverageAllowed: GetOrCreateCustomerOverageAllowed): string;
/** @internal */
type GetOrCreateCustomerBillingControls$Outbound = {
    auto_topups?: Array<GetOrCreateCustomerAutoTopup$Outbound> | undefined;
    spend_limits?: Array<GetOrCreateCustomerSpendLimit$Outbound> | undefined;
    usage_limits?: Array<GetOrCreateCustomerUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<GetOrCreateCustomerUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<GetOrCreateCustomerOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const GetOrCreateCustomerBillingControls$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerBillingControls$Outbound, GetOrCreateCustomerBillingControls>;
declare function getOrCreateCustomerBillingControlsToJSON(getOrCreateCustomerBillingControls: GetOrCreateCustomerBillingControls): string;
/** @internal */
type GetOrCreateCustomerConfig$Outbound = {
    disable_pooled_balance?: boolean | undefined;
    disable_overage_billing?: boolean | undefined;
};
/** @internal */
declare const GetOrCreateCustomerConfig$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerConfig$Outbound, GetOrCreateCustomerConfig>;
declare function getOrCreateCustomerConfigToJSON(getOrCreateCustomerConfig: GetOrCreateCustomerConfig): string;
/** @internal */
type GetOrCreateCustomerParams$Outbound = {
    customer_id: string | null;
    name?: string | null | undefined;
    email?: string | null | undefined;
    fingerprint?: string | null | undefined;
    metadata?: {
        [k: string]: any;
    } | null | undefined;
    stripe_id?: string | null | undefined;
    create_in_stripe?: boolean | undefined;
    auto_enable_plan_id?: string | undefined;
    send_email_receipts?: boolean | undefined;
    billing_controls?: GetOrCreateCustomerBillingControls$Outbound | undefined;
    config?: GetOrCreateCustomerConfig$Outbound | undefined;
    expand?: Array<string> | undefined;
};
/** @internal */
declare const GetOrCreateCustomerParams$outboundSchema: z$1.ZodMiniType<GetOrCreateCustomerParams$Outbound, GetOrCreateCustomerParams>;
declare function getOrCreateCustomerParamsToJSON(getOrCreateCustomerParams: GetOrCreateCustomerParams): string;

type GetPlanGlobals = {
    xApiVersion?: string | undefined;
};
type GetPlanParams = {
    /**
     * The ID of the plan to retrieve.
     */
    planId: string;
    /**
     * The version of the plan to get. Defaults to the latest version.
     */
    version?: number | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const GetPlanPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type GetPlanPriceInterval = OpenEnum<typeof GetPlanPriceInterval>;
/**
 * Display text for showing this price in pricing pages.
 */
type GetPlanPriceDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
type GetPlanPrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: GetPlanPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Display text for showing this price in pricing pages.
     */
    display?: GetPlanPriceDisplay | undefined;
};
/**
 * The type of the feature
 */
declare const GetPlanType: {
    readonly Static: "static";
    readonly Boolean: "boolean";
    readonly SingleUse: "single_use";
    readonly ContinuousUse: "continuous_use";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * The type of the feature
 */
type GetPlanType = OpenEnum<typeof GetPlanType>;
type GetPlanFeatureDisplay = {
    /**
     * The singular display name for the feature.
     */
    singular: string;
    /**
     * The plural display name for the feature.
     */
    plural: string;
};
type GetPlanCreditSchema = {
    /**
     * The ID of the metered feature (should be a single_use feature).
     */
    meteredFeatureId: string;
    /**
     * The credit cost of the metered feature.
     */
    creditCost: number;
};
/**
 * The full feature object if expanded.
 */
type GetPlanFeature = {
    /**
     * The ID of the feature, used to refer to it in other API calls like /track or /check.
     */
    id: string;
    /**
     * The name of the feature.
     */
    name?: string | null | undefined;
    /**
     * The type of the feature
     */
    type: GetPlanType;
    /**
     * Singular and plural display names for the feature.
     */
    display?: GetPlanFeatureDisplay | null | undefined;
    /**
     * Credit cost schema for credit system features.
     */
    creditSchema?: Array<GetPlanCreditSchema> | null | undefined;
    /**
     * Whether or not the feature is archived.
     */
    archived?: boolean | null | undefined;
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
declare const GetPlanResetItemInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
type GetPlanResetItemInterval = OpenEnum<typeof GetPlanResetItemInterval>;
type GetPlanItemReset = {
    /**
     * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
     */
    interval: GetPlanResetItemInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type GetPlanItemTo = number | string;
type GetPlanItemTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const GetPlanItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type GetPlanItemTierBehavior = OpenEnum<typeof GetPlanItemTierBehavior>;
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
declare const GetPlanPriceItemInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
type GetPlanPriceItemInterval = OpenEnum<typeof GetPlanPriceItemInterval>;
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
declare const GetPlanItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
type GetPlanItemBillingMethod = OpenEnum<typeof GetPlanItemBillingMethod>;
type GetPlanItemPrice = {
    /**
     * Price per billing_units after included usage is consumed. Mutually exclusive with tiers.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing configuration. Each tier's 'to' INCLUDES the included amount. Either 'tiers' or 'amount' is required.
     */
    tiers?: Array<GetPlanItemTier> | undefined;
    tierBehavior?: GetPlanItemTierBehavior | undefined;
    /**
     * Billing interval for this price. For consumable features, should match reset.interval.
     */
    interval: GetPlanPriceItemInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Number of units per price increment. Usage is rounded UP to the nearest billing_units when billed (e.g. billing_units=100 means 101 usage rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
     */
    billingMethod: GetPlanItemBillingMethod;
    /**
     * Maximum units a customer can purchase beyond included. E.g. if included=100 and max_purchase=300, customer can use up to 400 total before usage is capped. Null for no limit.
     */
    maxPurchase: number | null;
};
/**
 * Display text for showing this item in pricing pages.
 */
type GetPlanItemDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
/**
 * When rolled over units expire.
 */
declare const GetPlanItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type GetPlanItemExpiryDurationType = OpenEnum<typeof GetPlanItemExpiryDurationType>;
/**
 * Rollover configuration for unused units. If set, unused included units roll over to the next period.
 */
type GetPlanItemRollover = {
    /**
     * Maximum rollover units. Null for unlimited rollover.
     */
    max: number | null;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | null | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: GetPlanItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
type GetPlanItem = {
    /**
     * The ID of the feature this item configures.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: GetPlanFeature | undefined;
    /**
     * Number of free units included. For consumable features, balance resets to this number each interval.
     */
    included: number;
    /**
     * Whether the customer has unlimited access to this feature.
     */
    unlimited: boolean;
    /**
     * Reset configuration for consumable features. Null for non-consumable features like seats where usage persists across billing cycles.
     */
    reset: GetPlanItemReset | null;
    /**
     * Pricing configuration for usage beyond included units. Null if feature is entirely free.
     */
    price: GetPlanItemPrice | null;
    /**
     * Display text for showing this item in pricing pages.
     */
    display?: GetPlanItemDisplay | undefined;
    /**
     * Rollover configuration for unused units. If set, unused included units roll over to the next period.
     */
    rollover?: GetPlanItemRollover | undefined;
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
declare const GetPlanDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
type GetPlanDurationType = OpenEnum<typeof GetPlanDurationType>;
declare const GetPlanOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
type GetPlanOnEnd = OpenEnum<typeof GetPlanOnEnd>;
/**
 * Free trial configuration. If set, new customers can try this plan before being charged.
 */
type GetPlanFreeTrial = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial duration ('day', 'month', 'year').
     */
    durationType: GetPlanDurationType;
    /**
     * Whether a payment method is required to start the trial. If true, customer will be charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: GetPlanOnEnd | null | undefined;
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
declare const GetPlanEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
type GetPlanEnv = OpenEnum<typeof GetPlanEnv>;
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const GetPlanPriceVariantDetailsInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type GetPlanPriceVariantDetailsInterval = OpenEnum<typeof GetPlanPriceVariantDetailsInterval>;
/**
 * Base price configuration for a plan.
 */
type GetPlanBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: GetPlanPriceVariantDetailsInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const GetPlanAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type GetPlanAddItemResetInterval = OpenEnum<typeof GetPlanAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type GetPlanVariantDetailsReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: GetPlanAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type GetPlanVariantDetailsTo = number | string;
type GetPlanVariantDetailsTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const GetPlanVariantDetailsTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type GetPlanVariantDetailsTierBehavior = OpenEnum<typeof GetPlanVariantDetailsTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const GetPlanAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type GetPlanAddItemPriceInterval = OpenEnum<typeof GetPlanAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const GetPlanAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type GetPlanAddItemBillingMethod = OpenEnum<typeof GetPlanAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type GetPlanVariantDetailsPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<GetPlanVariantDetailsTier> | undefined;
    tierBehavior?: GetPlanVariantDetailsTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: GetPlanAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount: number;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: GetPlanAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const GetPlanOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type GetPlanOnIncrease = OpenEnum<typeof GetPlanOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const GetPlanOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type GetPlanOnDecrease = OpenEnum<typeof GetPlanOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type GetPlanProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: GetPlanOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: GetPlanOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const GetPlanVariantDetailsExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type GetPlanVariantDetailsExpiryDurationType = OpenEnum<typeof GetPlanVariantDetailsExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type GetPlanVariantDetailsRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: GetPlanVariantDetailsExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type GetPlanPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: GetPlanVariantDetailsReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: GetPlanVariantDetailsPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: GetPlanProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: GetPlanVariantDetailsRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const GetPlanRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type GetPlanRemoveItemBillingMethod = OpenEnum<typeof GetPlanRemoveItemBillingMethod>;
declare const GetPlanIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type GetPlanIntervalRemoveItemEnum2 = OpenEnum<typeof GetPlanIntervalRemoveItemEnum2>;
declare const GetPlanIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type GetPlanIntervalRemoveItemEnum1 = OpenEnum<typeof GetPlanIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type GetPlanIntervalUnion = GetPlanIntervalRemoveItemEnum1 | GetPlanIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type GetPlanPlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: GetPlanRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: GetPlanIntervalRemoveItemEnum1 | GetPlanIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const GetPlanVariantDetailsDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type GetPlanVariantDetailsDurationType = OpenEnum<typeof GetPlanVariantDetailsDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const GetPlanVariantDetailsOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type GetPlanVariantDetailsOnEnd = OpenEnum<typeof GetPlanVariantDetailsOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type GetPlanFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType: GetPlanVariantDetailsDurationType;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: GetPlanVariantDetailsOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const GetPlanVariantDetailsPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type GetPlanVariantDetailsPurchaseLimitInterval = OpenEnum<typeof GetPlanVariantDetailsPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type GetPlanVariantDetailsPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: GetPlanVariantDetailsPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type GetPlanVariantDetailsAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: GetPlanVariantDetailsPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const GetPlanVariantDetailsLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type GetPlanVariantDetailsLimitType = OpenEnum<typeof GetPlanVariantDetailsLimitType>;
type GetPlanVariantDetailsSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: GetPlanVariantDetailsLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const GetPlanVariantDetailsUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type GetPlanVariantDetailsUsageLimitInterval = OpenEnum<typeof GetPlanVariantDetailsUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type GetPlanVariantDetailsFilter = {
    properties: {
        [k: string]: any;
    };
};
type GetPlanVariantDetailsUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: GetPlanVariantDetailsUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: GetPlanVariantDetailsFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const GetPlanVariantDetailsThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type GetPlanVariantDetailsThresholdType = OpenEnum<typeof GetPlanVariantDetailsThresholdType>;
type GetPlanVariantDetailsUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: GetPlanVariantDetailsThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type GetPlanVariantDetailsOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type GetPlanVariantDetailsBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<GetPlanVariantDetailsAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<GetPlanVariantDetailsSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<GetPlanVariantDetailsUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<GetPlanVariantDetailsUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<GetPlanVariantDetailsOverageAllowed> | undefined;
};
/**
 * The customization that transforms the base plan into this variant.
 */
type GetPlanCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: GetPlanBasePrice | null | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<GetPlanPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<GetPlanPlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: GetPlanFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: GetPlanVariantDetailsBillingControls | undefined;
};
/**
 * Details about how this variant relates to its latest base plan.
 */
type GetPlanVariantDetails = {
    /**
     * The ID of the base plan this variant was derived from.
     */
    basePlanId: string;
    /**
     * The customization that transforms the base plan into this variant.
     */
    customize?: GetPlanCustomize | undefined;
};
/**
 * Miscellaneous plan-level configuration flags.
 */
type GetPlanConfig = {
    /**
     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
     */
    ignorePastDue: boolean;
};
/**
 * The time interval for the purchase limit window.
 */
declare const GetPlanPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type GetPlanPurchaseLimitInterval = OpenEnum<typeof GetPlanPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type GetPlanPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: GetPlanPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type GetPlanAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: GetPlanPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const GetPlanLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type GetPlanLimitType = OpenEnum<typeof GetPlanLimitType>;
type GetPlanSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: GetPlanLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const GetPlanUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type GetPlanUsageLimitInterval = OpenEnum<typeof GetPlanUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type GetPlanFilter = {
    properties: {
        [k: string]: any;
    };
};
type GetPlanUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: GetPlanUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: GetPlanFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const GetPlanThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type GetPlanThresholdType = OpenEnum<typeof GetPlanThresholdType>;
type GetPlanUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: GetPlanThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type GetPlanOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Plan-level billing controls used as customer defaults.
 */
type GetPlanBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<GetPlanAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<GetPlanSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<GetPlanUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<GetPlanUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<GetPlanOverageAllowed> | undefined;
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
declare const GetPlanStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
type GetPlanStatus = OpenEnum<typeof GetPlanStatus>;
/**
 * The action that would occur if this plan were attached to the customer.
 */
declare const GetPlanAttachAction: {
    readonly Activate: "activate";
    readonly Upgrade: "upgrade";
    readonly Downgrade: "downgrade";
    readonly None: "none";
    readonly Purchase: "purchase";
};
/**
 * The action that would occur if this plan were attached to the customer.
 */
type GetPlanAttachAction = OpenEnum<typeof GetPlanAttachAction>;
type GetPlanCustomerEligibility = {
    /**
     * Whether the trial on this plan is available to this customer. For example, if the customer used the trial in the past, this will be false.
     */
    trialAvailable?: boolean | undefined;
    /**
     * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
     */
    status?: GetPlanStatus | undefined;
    /**
     * Whether the customer's active instance of this plan is set to cancel.
     */
    canceling?: boolean | undefined;
    /**
     * Whether the customer is currently on a free trial of this plan.
     */
    trialing?: boolean | undefined;
    /**
     * The action that would occur if this plan were attached to the customer.
     */
    attachAction: GetPlanAttachAction;
};
/**
 * A plan defines a set of features, pricing, and entitlements that can be attached to customers.
 */
type GetPlanResponse = {
    /**
     * Unique identifier for the plan.
     */
    id: string;
    /**
     * Display name of the plan.
     */
    name: string;
    /**
     * Optional description of the plan.
     */
    description: string | null;
    /**
     * Group identifier for organizing related plans. Plans in the same group are mutually exclusive.
     */
    group: string | null;
    /**
     * Version number of the plan. Incremented when plan configuration changes.
     */
    version: number;
    /**
     * Whether this is an add-on plan that can be attached alongside a main plan.
     */
    addOn: boolean;
    /**
     * If true, this plan is automatically attached when a customer is created. Used for free plans.
     */
    autoEnable: boolean;
    /**
     * Base recurring price for the plan. Null for free plans or usage-only plans.
     */
    price: GetPlanPrice | null;
    /**
     * Feature configurations included in this plan. Each item defines included units, pricing, and reset behavior for a feature.
     */
    items: Array<GetPlanItem>;
    /**
     * Free trial configuration. If set, new customers can try this plan before being charged.
     */
    freeTrial?: GetPlanFreeTrial | undefined;
    /**
     * Unix timestamp (ms) when the plan was created.
     */
    createdAt: number;
    /**
     * Environment this plan belongs to ('sandbox' or 'live').
     */
    env: GetPlanEnv;
    /**
     * Whether the plan is archived. Archived plans cannot be attached to new customers.
     */
    archived: boolean;
    /**
     * Deprecated. Use variant_details.base_plan_id instead. If this is a variant, the ID of the base plan it was created from.
     */
    baseVariantId: string | null;
    /**
     * Details about how this variant relates to its latest base plan.
     */
    variantDetails?: GetPlanVariantDetails | undefined;
    /**
     * Miscellaneous plan-level configuration flags.
     */
    config: GetPlanConfig;
    /**
     * Plan-level billing controls used as customer defaults.
     */
    billingControls?: GetPlanBillingControls | undefined;
    /**
     * Arbitrary key-value metadata defined by you for your own use. Shared across all versions of the plan.
     */
    metadata: {
        [k: string]: any;
    };
    customerEligibility?: GetPlanCustomerEligibility | undefined;
};
/** @internal */
type GetPlanParams$Outbound = {
    plan_id: string;
    version?: number | undefined;
};
/** @internal */
declare const GetPlanParams$outboundSchema: z$1.ZodMiniType<GetPlanParams$Outbound, GetPlanParams>;
declare function getPlanParamsToJSON(getPlanParams: GetPlanParams): string;
/** @internal */
declare const GetPlanPriceInterval$inboundSchema: z$1.ZodMiniType<GetPlanPriceInterval, unknown>;
/** @internal */
declare const GetPlanPriceDisplay$inboundSchema: z$1.ZodMiniType<GetPlanPriceDisplay, unknown>;
declare function getPlanPriceDisplayFromJSON(jsonString: string): Result$1<GetPlanPriceDisplay, SDKValidationError>;
/** @internal */
declare const GetPlanPrice$inboundSchema: z$1.ZodMiniType<GetPlanPrice, unknown>;
declare function getPlanPriceFromJSON(jsonString: string): Result$1<GetPlanPrice, SDKValidationError>;
/** @internal */
declare const GetPlanType$inboundSchema: z$1.ZodMiniType<GetPlanType, unknown>;
/** @internal */
declare const GetPlanFeatureDisplay$inboundSchema: z$1.ZodMiniType<GetPlanFeatureDisplay, unknown>;
declare function getPlanFeatureDisplayFromJSON(jsonString: string): Result$1<GetPlanFeatureDisplay, SDKValidationError>;
/** @internal */
declare const GetPlanCreditSchema$inboundSchema: z$1.ZodMiniType<GetPlanCreditSchema, unknown>;
declare function getPlanCreditSchemaFromJSON(jsonString: string): Result$1<GetPlanCreditSchema, SDKValidationError>;
/** @internal */
declare const GetPlanFeature$inboundSchema: z$1.ZodMiniType<GetPlanFeature, unknown>;
declare function getPlanFeatureFromJSON(jsonString: string): Result$1<GetPlanFeature, SDKValidationError>;
/** @internal */
declare const GetPlanResetItemInterval$inboundSchema: z$1.ZodMiniType<GetPlanResetItemInterval, unknown>;
/** @internal */
declare const GetPlanItemReset$inboundSchema: z$1.ZodMiniType<GetPlanItemReset, unknown>;
declare function getPlanItemResetFromJSON(jsonString: string): Result$1<GetPlanItemReset, SDKValidationError>;
/** @internal */
declare const GetPlanItemTo$inboundSchema: z$1.ZodMiniType<GetPlanItemTo, unknown>;
declare function getPlanItemToFromJSON(jsonString: string): Result$1<GetPlanItemTo, SDKValidationError>;
/** @internal */
declare const GetPlanItemTier$inboundSchema: z$1.ZodMiniType<GetPlanItemTier, unknown>;
declare function getPlanItemTierFromJSON(jsonString: string): Result$1<GetPlanItemTier, SDKValidationError>;
/** @internal */
declare const GetPlanItemTierBehavior$inboundSchema: z$1.ZodMiniType<GetPlanItemTierBehavior, unknown>;
/** @internal */
declare const GetPlanPriceItemInterval$inboundSchema: z$1.ZodMiniType<GetPlanPriceItemInterval, unknown>;
/** @internal */
declare const GetPlanItemBillingMethod$inboundSchema: z$1.ZodMiniType<GetPlanItemBillingMethod, unknown>;
/** @internal */
declare const GetPlanItemPrice$inboundSchema: z$1.ZodMiniType<GetPlanItemPrice, unknown>;
declare function getPlanItemPriceFromJSON(jsonString: string): Result$1<GetPlanItemPrice, SDKValidationError>;
/** @internal */
declare const GetPlanItemDisplay$inboundSchema: z$1.ZodMiniType<GetPlanItemDisplay, unknown>;
declare function getPlanItemDisplayFromJSON(jsonString: string): Result$1<GetPlanItemDisplay, SDKValidationError>;
/** @internal */
declare const GetPlanItemExpiryDurationType$inboundSchema: z$1.ZodMiniType<GetPlanItemExpiryDurationType, unknown>;
/** @internal */
declare const GetPlanItemRollover$inboundSchema: z$1.ZodMiniType<GetPlanItemRollover, unknown>;
declare function getPlanItemRolloverFromJSON(jsonString: string): Result$1<GetPlanItemRollover, SDKValidationError>;
/** @internal */
declare const GetPlanItem$inboundSchema: z$1.ZodMiniType<GetPlanItem, unknown>;
declare function getPlanItemFromJSON(jsonString: string): Result$1<GetPlanItem, SDKValidationError>;
/** @internal */
declare const GetPlanDurationType$inboundSchema: z$1.ZodMiniType<GetPlanDurationType, unknown>;
/** @internal */
declare const GetPlanOnEnd$inboundSchema: z$1.ZodMiniType<GetPlanOnEnd, unknown>;
/** @internal */
declare const GetPlanFreeTrial$inboundSchema: z$1.ZodMiniType<GetPlanFreeTrial, unknown>;
declare function getPlanFreeTrialFromJSON(jsonString: string): Result$1<GetPlanFreeTrial, SDKValidationError>;
/** @internal */
declare const GetPlanEnv$inboundSchema: z$1.ZodMiniType<GetPlanEnv, unknown>;
/** @internal */
declare const GetPlanPriceVariantDetailsInterval$inboundSchema: z$1.ZodMiniType<GetPlanPriceVariantDetailsInterval, unknown>;
/** @internal */
declare const GetPlanBasePrice$inboundSchema: z$1.ZodMiniType<GetPlanBasePrice, unknown>;
declare function getPlanBasePriceFromJSON(jsonString: string): Result$1<GetPlanBasePrice, SDKValidationError>;
/** @internal */
declare const GetPlanAddItemResetInterval$inboundSchema: z$1.ZodMiniType<GetPlanAddItemResetInterval, unknown>;
/** @internal */
declare const GetPlanVariantDetailsReset$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsReset, unknown>;
declare function getPlanVariantDetailsResetFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsReset, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsTo$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsTo, unknown>;
declare function getPlanVariantDetailsToFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsTo, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsTier$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsTier, unknown>;
declare function getPlanVariantDetailsTierFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsTier, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsTierBehavior$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsTierBehavior, unknown>;
/** @internal */
declare const GetPlanAddItemPriceInterval$inboundSchema: z$1.ZodMiniType<GetPlanAddItemPriceInterval, unknown>;
/** @internal */
declare const GetPlanAddItemBillingMethod$inboundSchema: z$1.ZodMiniType<GetPlanAddItemBillingMethod, unknown>;
/** @internal */
declare const GetPlanVariantDetailsPrice$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsPrice, unknown>;
declare function getPlanVariantDetailsPriceFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsPrice, SDKValidationError>;
/** @internal */
declare const GetPlanOnIncrease$inboundSchema: z$1.ZodMiniType<GetPlanOnIncrease, unknown>;
/** @internal */
declare const GetPlanOnDecrease$inboundSchema: z$1.ZodMiniType<GetPlanOnDecrease, unknown>;
/** @internal */
declare const GetPlanProration$inboundSchema: z$1.ZodMiniType<GetPlanProration, unknown>;
declare function getPlanProrationFromJSON(jsonString: string): Result$1<GetPlanProration, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsExpiryDurationType$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsExpiryDurationType, unknown>;
/** @internal */
declare const GetPlanVariantDetailsRollover$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsRollover, unknown>;
declare function getPlanVariantDetailsRolloverFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsRollover, SDKValidationError>;
/** @internal */
declare const GetPlanPlanItem$inboundSchema: z$1.ZodMiniType<GetPlanPlanItem, unknown>;
declare function getPlanPlanItemFromJSON(jsonString: string): Result$1<GetPlanPlanItem, SDKValidationError>;
/** @internal */
declare const GetPlanRemoveItemBillingMethod$inboundSchema: z$1.ZodMiniType<GetPlanRemoveItemBillingMethod, unknown>;
/** @internal */
declare const GetPlanIntervalRemoveItemEnum2$inboundSchema: z$1.ZodMiniType<GetPlanIntervalRemoveItemEnum2, unknown>;
/** @internal */
declare const GetPlanIntervalRemoveItemEnum1$inboundSchema: z$1.ZodMiniType<GetPlanIntervalRemoveItemEnum1, unknown>;
/** @internal */
declare const GetPlanIntervalUnion$inboundSchema: z$1.ZodMiniType<GetPlanIntervalUnion, unknown>;
declare function getPlanIntervalUnionFromJSON(jsonString: string): Result$1<GetPlanIntervalUnion, SDKValidationError>;
/** @internal */
declare const GetPlanPlanItemFilter$inboundSchema: z$1.ZodMiniType<GetPlanPlanItemFilter, unknown>;
declare function getPlanPlanItemFilterFromJSON(jsonString: string): Result$1<GetPlanPlanItemFilter, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsDurationType$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsDurationType, unknown>;
/** @internal */
declare const GetPlanVariantDetailsOnEnd$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsOnEnd, unknown>;
/** @internal */
declare const GetPlanFreeTrialParams$inboundSchema: z$1.ZodMiniType<GetPlanFreeTrialParams, unknown>;
declare function getPlanFreeTrialParamsFromJSON(jsonString: string): Result$1<GetPlanFreeTrialParams, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsPurchaseLimitInterval, unknown>;
/** @internal */
declare const GetPlanVariantDetailsPurchaseLimit$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsPurchaseLimit, unknown>;
declare function getPlanVariantDetailsPurchaseLimitFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsPurchaseLimit, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsAutoTopup$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsAutoTopup, unknown>;
declare function getPlanVariantDetailsAutoTopupFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsAutoTopup, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsLimitType$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsLimitType, unknown>;
/** @internal */
declare const GetPlanVariantDetailsSpendLimit$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsSpendLimit, unknown>;
declare function getPlanVariantDetailsSpendLimitFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsSpendLimit, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsUsageLimitInterval$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsUsageLimitInterval, unknown>;
/** @internal */
declare const GetPlanVariantDetailsFilter$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsFilter, unknown>;
declare function getPlanVariantDetailsFilterFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsFilter, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsUsageLimit$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsUsageLimit, unknown>;
declare function getPlanVariantDetailsUsageLimitFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsUsageLimit, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsThresholdType$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsThresholdType, unknown>;
/** @internal */
declare const GetPlanVariantDetailsUsageAlert$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsUsageAlert, unknown>;
declare function getPlanVariantDetailsUsageAlertFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsUsageAlert, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsOverageAllowed$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsOverageAllowed, unknown>;
declare function getPlanVariantDetailsOverageAllowedFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsOverageAllowed, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetailsBillingControls$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetailsBillingControls, unknown>;
declare function getPlanVariantDetailsBillingControlsFromJSON(jsonString: string): Result$1<GetPlanVariantDetailsBillingControls, SDKValidationError>;
/** @internal */
declare const GetPlanCustomize$inboundSchema: z$1.ZodMiniType<GetPlanCustomize, unknown>;
declare function getPlanCustomizeFromJSON(jsonString: string): Result$1<GetPlanCustomize, SDKValidationError>;
/** @internal */
declare const GetPlanVariantDetails$inboundSchema: z$1.ZodMiniType<GetPlanVariantDetails, unknown>;
declare function getPlanVariantDetailsFromJSON(jsonString: string): Result$1<GetPlanVariantDetails, SDKValidationError>;
/** @internal */
declare const GetPlanConfig$inboundSchema: z$1.ZodMiniType<GetPlanConfig, unknown>;
declare function getPlanConfigFromJSON(jsonString: string): Result$1<GetPlanConfig, SDKValidationError>;
/** @internal */
declare const GetPlanPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<GetPlanPurchaseLimitInterval, unknown>;
/** @internal */
declare const GetPlanPurchaseLimit$inboundSchema: z$1.ZodMiniType<GetPlanPurchaseLimit, unknown>;
declare function getPlanPurchaseLimitFromJSON(jsonString: string): Result$1<GetPlanPurchaseLimit, SDKValidationError>;
/** @internal */
declare const GetPlanAutoTopup$inboundSchema: z$1.ZodMiniType<GetPlanAutoTopup, unknown>;
declare function getPlanAutoTopupFromJSON(jsonString: string): Result$1<GetPlanAutoTopup, SDKValidationError>;
/** @internal */
declare const GetPlanLimitType$inboundSchema: z$1.ZodMiniType<GetPlanLimitType, unknown>;
/** @internal */
declare const GetPlanSpendLimit$inboundSchema: z$1.ZodMiniType<GetPlanSpendLimit, unknown>;
declare function getPlanSpendLimitFromJSON(jsonString: string): Result$1<GetPlanSpendLimit, SDKValidationError>;
/** @internal */
declare const GetPlanUsageLimitInterval$inboundSchema: z$1.ZodMiniType<GetPlanUsageLimitInterval, unknown>;
/** @internal */
declare const GetPlanFilter$inboundSchema: z$1.ZodMiniType<GetPlanFilter, unknown>;
declare function getPlanFilterFromJSON(jsonString: string): Result$1<GetPlanFilter, SDKValidationError>;
/** @internal */
declare const GetPlanUsageLimit$inboundSchema: z$1.ZodMiniType<GetPlanUsageLimit, unknown>;
declare function getPlanUsageLimitFromJSON(jsonString: string): Result$1<GetPlanUsageLimit, SDKValidationError>;
/** @internal */
declare const GetPlanThresholdType$inboundSchema: z$1.ZodMiniType<GetPlanThresholdType, unknown>;
/** @internal */
declare const GetPlanUsageAlert$inboundSchema: z$1.ZodMiniType<GetPlanUsageAlert, unknown>;
declare function getPlanUsageAlertFromJSON(jsonString: string): Result$1<GetPlanUsageAlert, SDKValidationError>;
/** @internal */
declare const GetPlanOverageAllowed$inboundSchema: z$1.ZodMiniType<GetPlanOverageAllowed, unknown>;
declare function getPlanOverageAllowedFromJSON(jsonString: string): Result$1<GetPlanOverageAllowed, SDKValidationError>;
/** @internal */
declare const GetPlanBillingControls$inboundSchema: z$1.ZodMiniType<GetPlanBillingControls, unknown>;
declare function getPlanBillingControlsFromJSON(jsonString: string): Result$1<GetPlanBillingControls, SDKValidationError>;
/** @internal */
declare const GetPlanStatus$inboundSchema: z$1.ZodMiniType<GetPlanStatus, unknown>;
/** @internal */
declare const GetPlanAttachAction$inboundSchema: z$1.ZodMiniType<GetPlanAttachAction, unknown>;
/** @internal */
declare const GetPlanCustomerEligibility$inboundSchema: z$1.ZodMiniType<GetPlanCustomerEligibility, unknown>;
declare function getPlanCustomerEligibilityFromJSON(jsonString: string): Result$1<GetPlanCustomerEligibility, SDKValidationError>;
/** @internal */
declare const GetPlanResponse$inboundSchema: z$1.ZodMiniType<GetPlanResponse, unknown>;
declare function getPlanResponseFromJSON(jsonString: string): Result$1<GetPlanResponse, SDKValidationError>;

type GetRevenueCatKeysGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * "test" and "sandbox" both target the sandbox environment
 */
declare const GetRevenueCatKeysEnv: {
    readonly Test: "test";
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * "test" and "sandbox" both target the sandbox environment
 */
type GetRevenueCatKeysEnv = ClosedEnum<typeof GetRevenueCatKeysEnv>;
type GetRevenueCatKeysParams = {
    organizationSlug: string;
    /**
     * "test" and "sandbox" both target the sandbox environment
     */
    env: GetRevenueCatKeysEnv;
};
type ApiKey = {
    id: string;
    /**
     * The public SDK API key value
     */
    key: string;
    /**
     * e.g. "production" / "sandbox"
     */
    environment?: string | null | undefined;
    appId?: string | null | undefined;
    createdAt?: number | undefined;
    [additionalProperties: string]: unknown;
};
type GetRevenueCatKeysApp = {
    appId: string;
    /**
     * RevenueCat store type, e.g. test_store / app_store / play_store
     */
    appType: string;
    name: string;
    apiKeys: Array<ApiKey>;
};
/**
 * OK
 */
type GetRevenueCatKeysResponse = {
    apps: Array<GetRevenueCatKeysApp>;
    /**
     * Freshly-refreshed RevenueCat OAuth access token for the org (null for api-key orgs). The refresh token is never exposed — call this endpoint again for a new access token.
     */
    oauthAccessToken: string | null;
};
/** @internal */
declare const GetRevenueCatKeysEnv$outboundSchema: z$1.ZodMiniEnum<typeof GetRevenueCatKeysEnv>;
/** @internal */
type GetRevenueCatKeysParams$Outbound = {
    organization_slug: string;
    env: string;
};
/** @internal */
declare const GetRevenueCatKeysParams$outboundSchema: z$1.ZodMiniType<GetRevenueCatKeysParams$Outbound, GetRevenueCatKeysParams>;
declare function getRevenueCatKeysParamsToJSON(getRevenueCatKeysParams: GetRevenueCatKeysParams): string;
/** @internal */
declare const ApiKey$inboundSchema: z$1.ZodMiniType<ApiKey, unknown>;
declare function apiKeyFromJSON(jsonString: string): Result$1<ApiKey, SDKValidationError>;
/** @internal */
declare const GetRevenueCatKeysApp$inboundSchema: z$1.ZodMiniType<GetRevenueCatKeysApp, unknown>;
declare function getRevenueCatKeysAppFromJSON(jsonString: string): Result$1<GetRevenueCatKeysApp, SDKValidationError>;
/** @internal */
declare const GetRevenueCatKeysResponse$inboundSchema: z$1.ZodMiniType<GetRevenueCatKeysResponse, unknown>;
declare function getRevenueCatKeysResponseFromJSON(jsonString: string): Result$1<GetRevenueCatKeysResponse, SDKValidationError>;

/**
 * Base class for all HTTP errors.
 */
declare class HTTPClientError extends Error {
    /** The underlying cause of the error. */
    readonly cause: unknown;
    name: string;
    constructor(message: string, opts?: {
        cause?: unknown;
    });
}
/**
 * An error to capture unrecognised or unexpected errors when making HTTP calls.
 */
declare class UnexpectedClientError extends HTTPClientError {
    name: string;
}
/**
 * An error that is raised when any inputs used to create a request are invalid.
 */
declare class InvalidRequestError extends HTTPClientError {
    name: string;
}
/**
 * An error that is raised when a HTTP request was aborted by the client error.
 */
declare class RequestAbortedError extends HTTPClientError {
    readonly name = "RequestAbortedError";
}
/**
 * An error that is raised when a HTTP request timed out due to an AbortSignal
 * signal timeout.
 */
declare class RequestTimeoutError extends HTTPClientError {
    readonly name = "RequestTimeoutError";
}
/**
 * An error that is raised when a HTTP client is unable to make a request to
 * a server.
 */
declare class ConnectionError extends HTTPClientError {
    readonly name = "ConnectionError";
}

type ImportGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Optional identity fields upserted onto the customer (applied to existing customers too).
 */
type ImportCustomerData = {
    /**
     * Display name for the customer.
     */
    name?: string | undefined;
    /**
     * Email address for the customer.
     */
    email?: string | undefined;
    /**
     * Anti-fraud fingerprint for the customer.
     */
    fingerprint?: string | undefined;
};
/**
 * The processor this identity belongs to.
 */
declare const ImportType: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The processor this identity belongs to.
 */
type ImportType = ClosedEnum<typeof ImportType>;
type ImportProcessor = {
    /**
     * The processor this identity belongs to.
     */
    type: ImportType;
    /**
     * The customer's id in that processor (Stripe customer id, or RevenueCat app_user_id).
     */
    id: string;
};
/**
 * The processor that owns this billable (stripe or revenuecat). Omit for plans with no processor, e.g. a free plan.
 */
declare const BillableProcessor: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The processor that owns this billable (stripe or revenuecat). Omit for plans with no processor, e.g. a free plan.
 */
type BillableProcessor = ClosedEnum<typeof BillableProcessor>;
/**
 * Existing processor billing object this billable is adopted from; omit for paid one-offs.
 */
type Link = {
    /**
     * Existing processor subscription id this billable is adopted from.
     */
    subscriptionId?: string | undefined;
    /**
     * Existing processor subscription-schedule id this billable is adopted from.
     */
    scheduleId?: string | undefined;
};
/**
 * Set the status of the plan to be flashed. Active if undefined.
 */
declare const ImportStatus: {
    readonly Active: "active";
    readonly Trialing: "trialing";
    readonly PastDue: "past_due";
    readonly Canceled: "canceled";
    readonly Expired: "expired";
};
/**
 * Set the status of the plan to be flashed. Active if undefined.
 */
type ImportStatus = ClosedEnum<typeof ImportStatus>;
type ImportFeatureQuantity = {
    /**
     * The prepaid feature being quantified.
     */
    featureId: string;
    /**
     * Purchased quantity for this prepaid feature.
     */
    quantity: number;
};
declare const ImportInterval: {
    readonly Lifetime: "lifetime";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type ImportInterval = ClosedEnum<typeof ImportInterval>;
/**
 * Selects the included vs prepaid vs usage-based (pay-per-use) entitlement line when a feature has several.
 */
declare const ImportBillingBehavior: {
    readonly Included: "included";
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Selects the included vs prepaid vs usage-based (pay-per-use) entitlement line when a feature has several.
 */
type ImportBillingBehavior = ClosedEnum<typeof ImportBillingBehavior>;
/**
 * Disambiguates which entitlement line to target when the feature has multiple.
 */
type ImportFilter = {
    /**
     * Reset interval selecting which entitlement line to target when a feature has several ('lifetime' or null = the non-resetting one-off line).
     */
    interval?: ImportInterval | null | undefined;
    /**
     * Selects the included vs prepaid vs usage-based (pay-per-use) entitlement line when a feature has several.
     */
    billingBehavior?: ImportBillingBehavior | undefined;
};
type ImportBalance = {
    /**
     * The feature whose balance is being set.
     */
    featureId: string;
    /**
     * Disambiguates which entitlement line to target when the feature has multiple.
     */
    filter?: ImportFilter | undefined;
    /**
     * Units already consumed; remaining balance is derived from the plan allowance minus this.
     */
    usage?: number | undefined;
    /**
     * Explicit remaining balance override (mutually exclusive with usage).
     */
    balance?: number | undefined;
    /**
     * Unix ms timestamp of this line's next reset.
     */
    nextResetAt?: number | undefined;
};
/**
 * The single plan on this billable (provide either plan or phases, not both).
 */
type ImportPlan = {
    /**
     * The Autumn plan to attach to the customer.
     */
    planId: string;
    /**
     * Specific plan version to attach; defaults to the latest.
     */
    version?: number | undefined;
    /**
     * Set the status of the plan to be flashed. Active if undefined.
     */
    status?: ImportStatus | undefined;
    /**
     * When the plan started (Unix ms). Defaults to the linked subscription's start, else the import time. Set this for one-off purchases to record the real purchase date.
     */
    startedAt?: number | undefined;
    /**
     * Seat/unit quantity for the plan.
     */
    quantity?: number | undefined;
    /**
     * Purchased prepaid quantities per feature.
     */
    featureQuantities?: Array<ImportFeatureQuantity> | undefined;
    /**
     * Per-feature balances to image onto the plan.
     */
    balances?: Array<ImportBalance> | undefined;
};
type Billable = {
    /**
     * The processor that owns this billable (stripe or revenuecat). Omit for plans with no processor, e.g. a free plan.
     */
    processor?: BillableProcessor | undefined;
    /**
     * Existing processor billing object this billable is adopted from; omit for paid one-offs.
     */
    link?: Link | undefined;
    /**
     * Unix ms billing anchor shared by co-billed plans on this billable.
     */
    billingCycleAnchor?: number | undefined;
    /**
     * The single plan on this billable (provide either plan or phases, not both).
     */
    plan?: ImportPlan | undefined;
};
type DfuFlashParams = {
    /**
     * Autumn customer to image into.
     */
    customerId: string;
    /**
     * Optional identity fields upserted onto the customer (applied to existing customers too).
     */
    customerData?: ImportCustomerData | undefined;
    /**
     * The customer's processor identities (e.g. Stripe customer id, RevenueCat app_user_id). Omit for customers with no processor, e.g. those only ever on a free plan.
     */
    processors?: Array<ImportProcessor> | undefined;
    /**
     * The billing objects (subscriptions, one-offs) to image, each carrying its plan.
     */
    billables: Array<Billable>;
    /**
     * If true, validate and compute without persisting; returns what would be flashed.
     */
    dryRun?: boolean | undefined;
};
type Flashed = {
    /**
     * The plan that was imaged.
     */
    planId: string;
    /**
     * The processor that owns the imaged plan.
     */
    processor: string;
    /**
     * The created (or existing) customer product id, if any.
     */
    customerProductId: string | null;
    /**
     * The resulting status of the imaged plan.
     */
    status: string;
    /**
     * True if an active plan already existed and this one was left untouched.
     */
    skipped: boolean;
    /**
     * True if this was an existing active plan expired because it was absent from the imaged desired state.
     */
    expired?: boolean | undefined;
    /**
     * True when the imaged state may be wrong — e.g. a resetting plan with no resolvable billing anchor, or a paid recurring plan with no linked subscription for Autumn to manage. The plan is still imaged; see `reason` and fix by supplying started_at or a subscription_id.
     */
    mismatch?: boolean | undefined;
    /**
     * Why the plan was skipped, expired, or flagged as a mismatch, when applicable.
     */
    reason?: string | undefined;
};
/**
 * OK
 */
type DfuFlashResult = {
    /**
     * The imaged customer's id.
     */
    customerId: string;
    /**
     * Per-plan outcome of the flash.
     */
    flashed: Array<Flashed>;
    /**
     * The freshly-read imaged customer; null for dry_run.
     */
    customer: Customer | null;
};
/** @internal */
type ImportCustomerData$Outbound = {
    name?: string | undefined;
    email?: string | undefined;
    fingerprint?: string | undefined;
};
/** @internal */
declare const ImportCustomerData$outboundSchema: z$1.ZodMiniType<ImportCustomerData$Outbound, ImportCustomerData>;
declare function importCustomerDataToJSON(importCustomerData: ImportCustomerData): string;
/** @internal */
declare const ImportType$outboundSchema: z$1.ZodMiniEnum<typeof ImportType>;
/** @internal */
type ImportProcessor$Outbound = {
    type: string;
    id: string;
};
/** @internal */
declare const ImportProcessor$outboundSchema: z$1.ZodMiniType<ImportProcessor$Outbound, ImportProcessor>;
declare function importProcessorToJSON(importProcessor: ImportProcessor): string;
/** @internal */
declare const BillableProcessor$outboundSchema: z$1.ZodMiniEnum<typeof BillableProcessor>;
/** @internal */
type Link$Outbound = {
    subscription_id?: string | undefined;
    schedule_id?: string | undefined;
};
/** @internal */
declare const Link$outboundSchema: z$1.ZodMiniType<Link$Outbound, Link>;
declare function linkToJSON(link: Link): string;
/** @internal */
declare const ImportStatus$outboundSchema: z$1.ZodMiniEnum<typeof ImportStatus>;
/** @internal */
type ImportFeatureQuantity$Outbound = {
    feature_id: string;
    quantity: number;
};
/** @internal */
declare const ImportFeatureQuantity$outboundSchema: z$1.ZodMiniType<ImportFeatureQuantity$Outbound, ImportFeatureQuantity>;
declare function importFeatureQuantityToJSON(importFeatureQuantity: ImportFeatureQuantity): string;
/** @internal */
declare const ImportInterval$outboundSchema: z$1.ZodMiniEnum<typeof ImportInterval>;
/** @internal */
declare const ImportBillingBehavior$outboundSchema: z$1.ZodMiniEnum<typeof ImportBillingBehavior>;
/** @internal */
type ImportFilter$Outbound = {
    interval?: string | null | undefined;
    billing_behavior?: string | undefined;
};
/** @internal */
declare const ImportFilter$outboundSchema: z$1.ZodMiniType<ImportFilter$Outbound, ImportFilter>;
declare function importFilterToJSON(importFilter: ImportFilter): string;
/** @internal */
type ImportBalance$Outbound = {
    feature_id: string;
    filter?: ImportFilter$Outbound | undefined;
    usage?: number | undefined;
    balance?: number | undefined;
    next_reset_at?: number | undefined;
};
/** @internal */
declare const ImportBalance$outboundSchema: z$1.ZodMiniType<ImportBalance$Outbound, ImportBalance>;
declare function importBalanceToJSON(importBalance: ImportBalance): string;
/** @internal */
type ImportPlan$Outbound = {
    plan_id: string;
    version?: number | undefined;
    status?: string | undefined;
    started_at?: number | undefined;
    quantity?: number | undefined;
    feature_quantities?: Array<ImportFeatureQuantity$Outbound> | undefined;
    balances?: Array<ImportBalance$Outbound> | undefined;
};
/** @internal */
declare const ImportPlan$outboundSchema: z$1.ZodMiniType<ImportPlan$Outbound, ImportPlan>;
declare function importPlanToJSON(importPlan: ImportPlan): string;
/** @internal */
type Billable$Outbound = {
    processor?: string | undefined;
    link?: Link$Outbound | undefined;
    billing_cycle_anchor?: number | undefined;
    plan?: ImportPlan$Outbound | undefined;
};
/** @internal */
declare const Billable$outboundSchema: z$1.ZodMiniType<Billable$Outbound, Billable>;
declare function billableToJSON(billable: Billable): string;
/** @internal */
type DfuFlashParams$Outbound = {
    customer_id: string;
    customer_data?: ImportCustomerData$Outbound | undefined;
    processors?: Array<ImportProcessor$Outbound> | undefined;
    billables: Array<Billable$Outbound>;
    dry_run?: boolean | undefined;
};
/** @internal */
declare const DfuFlashParams$outboundSchema: z$1.ZodMiniType<DfuFlashParams$Outbound, DfuFlashParams>;
declare function dfuFlashParamsToJSON(dfuFlashParams: DfuFlashParams): string;
/** @internal */
declare const Flashed$inboundSchema: z$1.ZodMiniType<Flashed, unknown>;
declare function flashedFromJSON(jsonString: string): Result$1<Flashed, SDKValidationError>;
/** @internal */
declare const DfuFlashResult$inboundSchema: z$1.ZodMiniType<DfuFlashResult, unknown>;
declare function dfuFlashResultFromJSON(jsonString: string): Result$1<DfuFlashResult, SDKValidationError>;

type LinkRevenueCatGlobals = {
    xApiVersion?: string | undefined;
};
declare const LinkRevenueCatEnv: {
    readonly Test: "test";
    readonly Live: "live";
};
type LinkRevenueCatEnv = ClosedEnum<typeof LinkRevenueCatEnv>;
type LinkRevenueCatParams = {
    organizationSlug: string;
    env: LinkRevenueCatEnv;
    projectName: string;
    redirectUrl: string;
};
/**
 * OK
 */
type LinkRevenueCatResponse = {
    oauthUrl: string;
};
/** @internal */
declare const LinkRevenueCatEnv$outboundSchema: z$1.ZodMiniEnum<typeof LinkRevenueCatEnv>;
/** @internal */
type LinkRevenueCatParams$Outbound = {
    organization_slug: string;
    env: string;
    project_name: string;
    redirect_url: string;
};
/** @internal */
declare const LinkRevenueCatParams$outboundSchema: z$1.ZodMiniType<LinkRevenueCatParams$Outbound, LinkRevenueCatParams>;
declare function linkRevenueCatParamsToJSON(linkRevenueCatParams: LinkRevenueCatParams): string;
/** @internal */
declare const LinkRevenueCatResponse$inboundSchema: z$1.ZodMiniType<LinkRevenueCatResponse, unknown>;
declare function linkRevenueCatResponseFromJSON(jsonString: string): Result$1<LinkRevenueCatResponse, SDKValidationError>;

type ListCustomersGlobals = {
    xApiVersion?: string | undefined;
};
type ListCustomersPlan = {
    id: string;
    versions?: Array<number> | undefined;
};
/**
 * Filter by customer product status. Defaults to active and scheduled.
 */
declare const ListCustomersSubscriptionStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Filter by customer product status. Defaults to active and scheduled.
 */
type ListCustomersSubscriptionStatus = ClosedEnum<typeof ListCustomersSubscriptionStatus>;
declare const ListCustomersProcessor: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
    readonly Vercel: "vercel";
};
type ListCustomersProcessor = ClosedEnum<typeof ListCustomersProcessor>;
type ListCustomersParams = {
    /**
     * Opaque pagination cursor. Empty string (default) requests the first page; use next_cursor from a prior response for subsequent pages.
     */
    startCursor?: string | undefined;
    /**
     * Number of items to return. Default 50, hard ceiling 5000.
     */
    limit?: number | undefined;
    /**
     * Filter by plan ID and version. Returns customers with active subscriptions to this plan.
     */
    plans?: Array<ListCustomersPlan> | undefined;
    /**
     * Filter by customer product status. Defaults to active and scheduled.
     */
    subscriptionStatus?: ListCustomersSubscriptionStatus | undefined;
    /**
     * Search customers by id, name, or email.
     */
    search?: string | undefined;
    /**
     * Filter by customer processor type (stripe, revenuecat, vercel).
     */
    processors?: Array<ListCustomersProcessor> | undefined;
};
/**
 * The environment this customer was created in.
 */
declare const ListCustomersEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment this customer was created in.
 */
type ListCustomersEnv = OpenEnum<typeof ListCustomersEnv>;
/**
 * The time interval for the purchase limit window.
 */
declare const ListCustomersPurchaseLimitInterval2: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type ListCustomersPurchaseLimitInterval2 = OpenEnum<typeof ListCustomersPurchaseLimitInterval2>;
type ListCustomersPurchaseLimit2 = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: ListCustomersPurchaseLimitInterval2;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
declare const ListCustomersPurchaseLimitInterval1: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
type ListCustomersPurchaseLimitInterval1 = OpenEnum<typeof ListCustomersPurchaseLimitInterval1>;
type ListCustomersPurchaseLimit1 = {
    /**
     * The time interval for the purchase limit window. Null when no purchase limit is configured.
     */
    interval: ListCustomersPurchaseLimitInterval1 | null;
    /**
     * Number of intervals in the purchase limit window. Null when no purchase limit is configured.
     */
    intervalCount: number | null;
    /**
     * Maximum number of auto top-ups allowed within the interval. Null when no purchase limit is configured.
     */
    limit: number | null;
    /**
     * Number of auto top-ups already consumed in the current window.
     */
    count: number;
    /**
     * Unix ms timestamp when the current purchase window ends and the count resets.
     */
    nextResetAt: number;
};
/**
 * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
 */
type ListCustomersPurchaseLimitUnion = ListCustomersPurchaseLimit1 | ListCustomersPurchaseLimit2;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListCustomersAutoTopupSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListCustomersAutoTopupSource = OpenEnum<typeof ListCustomersAutoTopupSource>;
type ListCustomersAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
     */
    purchaseLimit?: ListCustomersPurchaseLimit1 | ListCustomersPurchaseLimit2 | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListCustomersAutoTopupSource | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const ListCustomersLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type ListCustomersLimitType = OpenEnum<typeof ListCustomersLimitType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListCustomersSpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListCustomersSpendLimitSource = OpenEnum<typeof ListCustomersSpendLimitSource>;
type ListCustomersSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: ListCustomersLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListCustomersSpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const ListCustomersUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type ListCustomersUsageLimitInterval = OpenEnum<typeof ListCustomersUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type ListCustomersFilter = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListCustomersUsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListCustomersUsageLimitSource = OpenEnum<typeof ListCustomersUsageLimitSource>;
type ListCustomersUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: ListCustomersUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: ListCustomersFilter | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListCustomersUsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const ListCustomersThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type ListCustomersThresholdType = OpenEnum<typeof ListCustomersThresholdType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListCustomersUsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListCustomersUsageAlertSource = OpenEnum<typeof ListCustomersUsageAlertSource>;
type ListCustomersUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: ListCustomersThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListCustomersUsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListCustomersOverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListCustomersOverageAllowedSource = OpenEnum<typeof ListCustomersOverageAllowedSource>;
type ListCustomersOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListCustomersOverageAllowedSource | undefined;
};
/**
 * Billing controls for the customer (auto top-ups, etc.)
 */
type ListCustomersBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<ListCustomersAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<ListCustomersSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature, with current interval usage.
     */
    usageLimits?: Array<ListCustomersUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<ListCustomersUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<ListCustomersOverageAllowed> | undefined;
};
/**
 * Current status of the subscription.
 */
declare const ListCustomersStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type ListCustomersStatus = OpenEnum<typeof ListCustomersStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const ListCustomersSubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type ListCustomersSubscriptionScope = OpenEnum<typeof ListCustomersSubscriptionScope>;
type ListCustomersSubscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: ListCustomersStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: ListCustomersSubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const ListCustomersPurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type ListCustomersPurchaseScope = OpenEnum<typeof ListCustomersPurchaseScope>;
type ListCustomersPurchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: ListCustomersPurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const ListCustomersType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type ListCustomersType = OpenEnum<typeof ListCustomersType>;
type ListCustomersCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type ListCustomersModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type ListCustomersProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type ListCustomersDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type ListCustomersFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: ListCustomersType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<ListCustomersCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: ListCustomersModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: ListCustomersProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: ListCustomersDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type ListCustomersFlags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: ListCustomersFeature | undefined;
};
/**
 * Configuration for the customer.
 */
type ListCustomersConfig = {
    /**
     * Whether to disable the shared customer-level pool for entities.
     */
    disablePooledBalance?: boolean | undefined;
    /**
     * Stops Autumn from posting usage-overage line items to Stripe for this customer. Check/track and balance resets still behave normally. When set, this overrides the organization-level disable_overage_billing setting.
     */
    disableOverageBilling?: boolean | undefined;
};
/**
 * Stripe processor connection for the customer.
 */
type ListCustomersStripe = {
    /**
     * Stripe customer ID.
     */
    id: string;
};
/**
 * Vercel processor connection for the customer (public-safe subset).
 */
type ListCustomersVercel = {
    /**
     * Vercel marketplace installation ID for this customer.
     */
    installationId: string;
    /**
     * Vercel account ID associated with the installation.
     */
    accountId: string;
};
/**
 * RevenueCat processor connection for the customer.
 */
type ListCustomersRevenuecat = {
    /**
     * Customer's external ID, used as the RevenueCat app user ID. Null if the customer has no external ID set.
     */
    id: string | null;
};
/**
 * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
 */
type ListCustomersProcessors = {
    /**
     * Stripe processor connection for the customer.
     */
    stripe?: ListCustomersStripe | undefined;
    /**
     * Vercel processor connection for the customer (public-safe subset).
     */
    vercel?: ListCustomersVercel | undefined;
    /**
     * RevenueCat processor connection for the customer.
     */
    revenuecat?: ListCustomersRevenuecat | undefined;
};
type ListCustomersList = {
    /**
     * Your unique identifier for the customer.
     */
    id: string | null;
    /**
     * The name of the customer.
     */
    name: string | null;
    /**
     * The email address of the customer.
     */
    email: string | null;
    /**
     * Timestamp of customer creation in milliseconds since epoch.
     */
    createdAt: number;
    /**
     * A unique identifier (eg. serial number) to de-duplicate customers across devices or browsers. For example: apple device ID.
     */
    fingerprint: string | null;
    /**
     * Stripe customer ID.
     */
    stripeId: string | null;
    /**
     * The environment this customer was created in.
     */
    env: ListCustomersEnv;
    /**
     * The metadata for the customer.
     */
    metadata: {
        [k: string]: any;
    };
    /**
     * Whether to send email receipts to the customer.
     */
    sendEmailReceipts: boolean;
    /**
     * Billing controls for the customer (auto top-ups, etc.)
     */
    billingControls: ListCustomersBillingControls;
    /**
     * Active and scheduled recurring plans that this customer has attached.
     */
    subscriptions: Array<ListCustomersSubscription>;
    /**
     * One-time purchases made by the customer.
     */
    purchases: Array<ListCustomersPurchase>;
    /**
     * Feature balances keyed by feature ID, showing usage limits and remaining amounts.
     */
    balances: {
        [k: string]: Balance;
    };
    /**
     * Boolean feature flags keyed by feature ID, showing enabled access for on/off features.
     */
    flags: {
        [k: string]: ListCustomersFlags;
    };
    /**
     * Configuration for the customer.
     */
    config?: ListCustomersConfig | undefined;
    /**
     * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
     */
    processors?: ListCustomersProcessors | undefined;
};
/**
 * OK
 */
type ListCustomersResponse = {
    /**
     * Items for current page.
     */
    list: Array<ListCustomersList>;
    /**
     * Opaque cursor for the next page. Null when there are no more results.
     */
    nextCursor: string | null;
};
/** @internal */
type ListCustomersPlan$Outbound = {
    id: string;
    versions?: Array<number> | undefined;
};
/** @internal */
declare const ListCustomersPlan$outboundSchema: z$1.ZodMiniType<ListCustomersPlan$Outbound, ListCustomersPlan>;
declare function listCustomersPlanToJSON(listCustomersPlan: ListCustomersPlan): string;
/** @internal */
declare const ListCustomersSubscriptionStatus$outboundSchema: z$1.ZodMiniEnum<typeof ListCustomersSubscriptionStatus>;
/** @internal */
declare const ListCustomersProcessor$outboundSchema: z$1.ZodMiniEnum<typeof ListCustomersProcessor>;
/** @internal */
type ListCustomersParams$Outbound = {
    start_cursor: string;
    limit: number;
    plans?: Array<ListCustomersPlan$Outbound> | undefined;
    subscription_status?: string | undefined;
    search?: string | undefined;
    processors?: Array<string> | undefined;
};
/** @internal */
declare const ListCustomersParams$outboundSchema: z$1.ZodMiniType<ListCustomersParams$Outbound, ListCustomersParams>;
declare function listCustomersParamsToJSON(listCustomersParams: ListCustomersParams): string;
/** @internal */
declare const ListCustomersEnv$inboundSchema: z$1.ZodMiniType<ListCustomersEnv, unknown>;
/** @internal */
declare const ListCustomersPurchaseLimitInterval2$inboundSchema: z$1.ZodMiniType<ListCustomersPurchaseLimitInterval2, unknown>;
/** @internal */
declare const ListCustomersPurchaseLimit2$inboundSchema: z$1.ZodMiniType<ListCustomersPurchaseLimit2, unknown>;
declare function listCustomersPurchaseLimit2FromJSON(jsonString: string): Result$1<ListCustomersPurchaseLimit2, SDKValidationError>;
/** @internal */
declare const ListCustomersPurchaseLimitInterval1$inboundSchema: z$1.ZodMiniType<ListCustomersPurchaseLimitInterval1, unknown>;
/** @internal */
declare const ListCustomersPurchaseLimit1$inboundSchema: z$1.ZodMiniType<ListCustomersPurchaseLimit1, unknown>;
declare function listCustomersPurchaseLimit1FromJSON(jsonString: string): Result$1<ListCustomersPurchaseLimit1, SDKValidationError>;
/** @internal */
declare const ListCustomersPurchaseLimitUnion$inboundSchema: z$1.ZodMiniType<ListCustomersPurchaseLimitUnion, unknown>;
declare function listCustomersPurchaseLimitUnionFromJSON(jsonString: string): Result$1<ListCustomersPurchaseLimitUnion, SDKValidationError>;
/** @internal */
declare const ListCustomersAutoTopupSource$inboundSchema: z$1.ZodMiniType<ListCustomersAutoTopupSource, unknown>;
/** @internal */
declare const ListCustomersAutoTopup$inboundSchema: z$1.ZodMiniType<ListCustomersAutoTopup, unknown>;
declare function listCustomersAutoTopupFromJSON(jsonString: string): Result$1<ListCustomersAutoTopup, SDKValidationError>;
/** @internal */
declare const ListCustomersLimitType$inboundSchema: z$1.ZodMiniType<ListCustomersLimitType, unknown>;
/** @internal */
declare const ListCustomersSpendLimitSource$inboundSchema: z$1.ZodMiniType<ListCustomersSpendLimitSource, unknown>;
/** @internal */
declare const ListCustomersSpendLimit$inboundSchema: z$1.ZodMiniType<ListCustomersSpendLimit, unknown>;
declare function listCustomersSpendLimitFromJSON(jsonString: string): Result$1<ListCustomersSpendLimit, SDKValidationError>;
/** @internal */
declare const ListCustomersUsageLimitInterval$inboundSchema: z$1.ZodMiniType<ListCustomersUsageLimitInterval, unknown>;
/** @internal */
declare const ListCustomersFilter$inboundSchema: z$1.ZodMiniType<ListCustomersFilter, unknown>;
declare function listCustomersFilterFromJSON(jsonString: string): Result$1<ListCustomersFilter, SDKValidationError>;
/** @internal */
declare const ListCustomersUsageLimitSource$inboundSchema: z$1.ZodMiniType<ListCustomersUsageLimitSource, unknown>;
/** @internal */
declare const ListCustomersUsageLimit$inboundSchema: z$1.ZodMiniType<ListCustomersUsageLimit, unknown>;
declare function listCustomersUsageLimitFromJSON(jsonString: string): Result$1<ListCustomersUsageLimit, SDKValidationError>;
/** @internal */
declare const ListCustomersThresholdType$inboundSchema: z$1.ZodMiniType<ListCustomersThresholdType, unknown>;
/** @internal */
declare const ListCustomersUsageAlertSource$inboundSchema: z$1.ZodMiniType<ListCustomersUsageAlertSource, unknown>;
/** @internal */
declare const ListCustomersUsageAlert$inboundSchema: z$1.ZodMiniType<ListCustomersUsageAlert, unknown>;
declare function listCustomersUsageAlertFromJSON(jsonString: string): Result$1<ListCustomersUsageAlert, SDKValidationError>;
/** @internal */
declare const ListCustomersOverageAllowedSource$inboundSchema: z$1.ZodMiniType<ListCustomersOverageAllowedSource, unknown>;
/** @internal */
declare const ListCustomersOverageAllowed$inboundSchema: z$1.ZodMiniType<ListCustomersOverageAllowed, unknown>;
declare function listCustomersOverageAllowedFromJSON(jsonString: string): Result$1<ListCustomersOverageAllowed, SDKValidationError>;
/** @internal */
declare const ListCustomersBillingControls$inboundSchema: z$1.ZodMiniType<ListCustomersBillingControls, unknown>;
declare function listCustomersBillingControlsFromJSON(jsonString: string): Result$1<ListCustomersBillingControls, SDKValidationError>;
/** @internal */
declare const ListCustomersStatus$inboundSchema: z$1.ZodMiniType<ListCustomersStatus, unknown>;
/** @internal */
declare const ListCustomersSubscriptionScope$inboundSchema: z$1.ZodMiniType<ListCustomersSubscriptionScope, unknown>;
/** @internal */
declare const ListCustomersSubscription$inboundSchema: z$1.ZodMiniType<ListCustomersSubscription, unknown>;
declare function listCustomersSubscriptionFromJSON(jsonString: string): Result$1<ListCustomersSubscription, SDKValidationError>;
/** @internal */
declare const ListCustomersPurchaseScope$inboundSchema: z$1.ZodMiniType<ListCustomersPurchaseScope, unknown>;
/** @internal */
declare const ListCustomersPurchase$inboundSchema: z$1.ZodMiniType<ListCustomersPurchase, unknown>;
declare function listCustomersPurchaseFromJSON(jsonString: string): Result$1<ListCustomersPurchase, SDKValidationError>;
/** @internal */
declare const ListCustomersType$inboundSchema: z$1.ZodMiniType<ListCustomersType, unknown>;
/** @internal */
declare const ListCustomersCreditSchema$inboundSchema: z$1.ZodMiniType<ListCustomersCreditSchema, unknown>;
declare function listCustomersCreditSchemaFromJSON(jsonString: string): Result$1<ListCustomersCreditSchema, SDKValidationError>;
/** @internal */
declare const ListCustomersModelMarkups$inboundSchema: z$1.ZodMiniType<ListCustomersModelMarkups, unknown>;
declare function listCustomersModelMarkupsFromJSON(jsonString: string): Result$1<ListCustomersModelMarkups, SDKValidationError>;
/** @internal */
declare const ListCustomersProviderMarkups$inboundSchema: z$1.ZodMiniType<ListCustomersProviderMarkups, unknown>;
declare function listCustomersProviderMarkupsFromJSON(jsonString: string): Result$1<ListCustomersProviderMarkups, SDKValidationError>;
/** @internal */
declare const ListCustomersDisplay$inboundSchema: z$1.ZodMiniType<ListCustomersDisplay, unknown>;
declare function listCustomersDisplayFromJSON(jsonString: string): Result$1<ListCustomersDisplay, SDKValidationError>;
/** @internal */
declare const ListCustomersFeature$inboundSchema: z$1.ZodMiniType<ListCustomersFeature, unknown>;
declare function listCustomersFeatureFromJSON(jsonString: string): Result$1<ListCustomersFeature, SDKValidationError>;
/** @internal */
declare const ListCustomersFlags$inboundSchema: z$1.ZodMiniType<ListCustomersFlags, unknown>;
declare function listCustomersFlagsFromJSON(jsonString: string): Result$1<ListCustomersFlags, SDKValidationError>;
/** @internal */
declare const ListCustomersConfig$inboundSchema: z$1.ZodMiniType<ListCustomersConfig, unknown>;
declare function listCustomersConfigFromJSON(jsonString: string): Result$1<ListCustomersConfig, SDKValidationError>;
/** @internal */
declare const ListCustomersStripe$inboundSchema: z$1.ZodMiniType<ListCustomersStripe, unknown>;
declare function listCustomersStripeFromJSON(jsonString: string): Result$1<ListCustomersStripe, SDKValidationError>;
/** @internal */
declare const ListCustomersVercel$inboundSchema: z$1.ZodMiniType<ListCustomersVercel, unknown>;
declare function listCustomersVercelFromJSON(jsonString: string): Result$1<ListCustomersVercel, SDKValidationError>;
/** @internal */
declare const ListCustomersRevenuecat$inboundSchema: z$1.ZodMiniType<ListCustomersRevenuecat, unknown>;
declare function listCustomersRevenuecatFromJSON(jsonString: string): Result$1<ListCustomersRevenuecat, SDKValidationError>;
/** @internal */
declare const ListCustomersProcessors$inboundSchema: z$1.ZodMiniType<ListCustomersProcessors, unknown>;
declare function listCustomersProcessorsFromJSON(jsonString: string): Result$1<ListCustomersProcessors, SDKValidationError>;
/** @internal */
declare const ListCustomersList$inboundSchema: z$1.ZodMiniType<ListCustomersList, unknown>;
declare function listCustomersListFromJSON(jsonString: string): Result$1<ListCustomersList, SDKValidationError>;
/** @internal */
declare const ListCustomersResponse$inboundSchema: z$1.ZodMiniType<ListCustomersResponse, unknown>;
declare function listCustomersResponseFromJSON(jsonString: string): Result$1<ListCustomersResponse, SDKValidationError>;

type ListEntitiesGlobals = {
    xApiVersion?: string | undefined;
};
type ListEntitiesPlan = {
    id: string;
    versions?: Array<number> | undefined;
};
/**
 * Filter customer products used for entity hydration and plan matching. Defaults to active and scheduled.
 */
declare const ListEntitiesSubscriptionStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Filter customer products used for entity hydration and plan matching. Defaults to active and scheduled.
 */
type ListEntitiesSubscriptionStatus = ClosedEnum<typeof ListEntitiesSubscriptionStatus>;
declare const ListEntitiesProcessor: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
    readonly Vercel: "vercel";
};
type ListEntitiesProcessor = ClosedEnum<typeof ListEntitiesProcessor>;
type ListEntitiesParams = {
    /**
     * Opaque pagination cursor. Empty string (default) requests the first page; use next_cursor from a prior response for subsequent pages.
     */
    startCursor?: string | undefined;
    /**
     * Number of items to return. Default 50, hard ceiling 5000.
     */
    limit?: number | undefined;
    /**
     * Filter by plan ID and version. Returns entities with active subscriptions to this plan, including plans inherited from the parent customer.
     */
    plans?: Array<ListEntitiesPlan> | undefined;
    /**
     * Filter customer products used for entity hydration and plan matching. Defaults to active and scheduled.
     */
    subscriptionStatus?: ListEntitiesSubscriptionStatus | undefined;
    /**
     * Search entities by id or name.
     */
    search?: string | undefined;
    /**
     * Filter by parent customer processor type (stripe, revenuecat, vercel).
     */
    processors?: Array<ListEntitiesProcessor> | undefined;
    /**
     * Restrict the response to entities owned by this customer id. Use to bulk-fetch all entities for one customer in a single paginated call instead of iterating entities.get.
     */
    customerId?: string | undefined;
};
/**
 * The environment (sandbox/live)
 */
declare const ListEntitiesEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment (sandbox/live)
 */
type ListEntitiesEnv = OpenEnum<typeof ListEntitiesEnv>;
/**
 * Current status of the subscription.
 */
declare const ListEntitiesStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type ListEntitiesStatus = OpenEnum<typeof ListEntitiesStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const ListEntitiesSubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type ListEntitiesSubscriptionScope = OpenEnum<typeof ListEntitiesSubscriptionScope>;
type ListEntitiesSubscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: ListEntitiesStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: ListEntitiesSubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const ListEntitiesPurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type ListEntitiesPurchaseScope = OpenEnum<typeof ListEntitiesPurchaseScope>;
type ListEntitiesPurchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: ListEntitiesPurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const ListEntitiesType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type ListEntitiesType = OpenEnum<typeof ListEntitiesType>;
type ListEntitiesCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type ListEntitiesModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type ListEntitiesProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type ListEntitiesDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type ListEntitiesFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: ListEntitiesType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<ListEntitiesCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: ListEntitiesModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: ListEntitiesProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: ListEntitiesDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type ListEntitiesFlags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: ListEntitiesFeature | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const ListEntitiesLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type ListEntitiesLimitType = OpenEnum<typeof ListEntitiesLimitType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListEntitiesSpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListEntitiesSpendLimitSource = OpenEnum<typeof ListEntitiesSpendLimitSource>;
type ListEntitiesSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: ListEntitiesLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListEntitiesSpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const ListEntitiesInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type ListEntitiesInterval = OpenEnum<typeof ListEntitiesInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type ListEntitiesFilter = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListEntitiesUsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListEntitiesUsageLimitSource = OpenEnum<typeof ListEntitiesUsageLimitSource>;
type ListEntitiesUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: ListEntitiesInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: ListEntitiesFilter | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListEntitiesUsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const ListEntitiesThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type ListEntitiesThresholdType = OpenEnum<typeof ListEntitiesThresholdType>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListEntitiesUsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListEntitiesUsageAlertSource = OpenEnum<typeof ListEntitiesUsageAlertSource>;
type ListEntitiesUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: ListEntitiesThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListEntitiesUsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const ListEntitiesOverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type ListEntitiesOverageAllowedSource = OpenEnum<typeof ListEntitiesOverageAllowedSource>;
type ListEntitiesOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: ListEntitiesOverageAllowedSource | undefined;
};
/**
 * Billing controls for the entity.
 */
type ListEntitiesBillingControls = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<ListEntitiesSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<ListEntitiesUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<ListEntitiesUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<ListEntitiesOverageAllowed> | undefined;
};
/**
 * The billing processor that owns this invoice.
 */
declare const ListEntitiesProcessorType: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The billing processor that owns this invoice.
 */
type ListEntitiesProcessorType = OpenEnum<typeof ListEntitiesProcessorType>;
type ListEntitiesInvoice = {
    /**
     * Array of plan IDs included in this invoice
     */
    planIds: Array<string>;
    /**
     * The Stripe invoice ID
     */
    stripeId: string;
    /**
     * The billing processor that owns this invoice.
     */
    processorType: ListEntitiesProcessorType;
    /**
     * The status of the invoice
     */
    status: string;
    /**
     * The total amount of the invoice
     */
    total: number;
    /**
     * The currency code for the invoice
     */
    currency: string;
    /**
     * Timestamp when the invoice was created
     */
    createdAt: number;
    /**
     * URL to the Stripe-hosted invoice page
     */
    hostedInvoiceUrl?: string | null | undefined;
};
type ListEntitiesList = {
    /**
     * The unique identifier of the entity
     */
    id: string | null;
    /**
     * The name of the entity
     */
    name: string | null;
    /**
     * The customer ID this entity belongs to
     */
    customerId?: string | null | undefined;
    /**
     * The feature ID this entity belongs to
     */
    featureId?: string | null | undefined;
    /**
     * Unix timestamp when the entity was created
     */
    createdAt: number;
    /**
     * The environment (sandbox/live)
     */
    env: ListEntitiesEnv;
    subscriptions: Array<ListEntitiesSubscription>;
    purchases: Array<ListEntitiesPurchase>;
    balances: {
        [k: string]: Balance;
    };
    flags: {
        [k: string]: ListEntitiesFlags;
    };
    /**
     * Billing controls for the entity.
     */
    billingControls?: ListEntitiesBillingControls | undefined;
    /**
     * Invoices for this entity (only included when expand=invoices)
     */
    invoices?: Array<ListEntitiesInvoice> | undefined;
};
/**
 * OK
 */
type ListEntitiesResponse = {
    /**
     * Items for current page.
     */
    list: Array<ListEntitiesList>;
    /**
     * Opaque cursor for the next page. Null when there are no more results.
     */
    nextCursor: string | null;
};
/** @internal */
type ListEntitiesPlan$Outbound = {
    id: string;
    versions?: Array<number> | undefined;
};
/** @internal */
declare const ListEntitiesPlan$outboundSchema: z$1.ZodMiniType<ListEntitiesPlan$Outbound, ListEntitiesPlan>;
declare function listEntitiesPlanToJSON(listEntitiesPlan: ListEntitiesPlan): string;
/** @internal */
declare const ListEntitiesSubscriptionStatus$outboundSchema: z$1.ZodMiniEnum<typeof ListEntitiesSubscriptionStatus>;
/** @internal */
declare const ListEntitiesProcessor$outboundSchema: z$1.ZodMiniEnum<typeof ListEntitiesProcessor>;
/** @internal */
type ListEntitiesParams$Outbound = {
    start_cursor: string;
    limit: number;
    plans?: Array<ListEntitiesPlan$Outbound> | undefined;
    subscription_status?: string | undefined;
    search?: string | undefined;
    processors?: Array<string> | undefined;
    customer_id?: string | undefined;
};
/** @internal */
declare const ListEntitiesParams$outboundSchema: z$1.ZodMiniType<ListEntitiesParams$Outbound, ListEntitiesParams>;
declare function listEntitiesParamsToJSON(listEntitiesParams: ListEntitiesParams): string;
/** @internal */
declare const ListEntitiesEnv$inboundSchema: z$1.ZodMiniType<ListEntitiesEnv, unknown>;
/** @internal */
declare const ListEntitiesStatus$inboundSchema: z$1.ZodMiniType<ListEntitiesStatus, unknown>;
/** @internal */
declare const ListEntitiesSubscriptionScope$inboundSchema: z$1.ZodMiniType<ListEntitiesSubscriptionScope, unknown>;
/** @internal */
declare const ListEntitiesSubscription$inboundSchema: z$1.ZodMiniType<ListEntitiesSubscription, unknown>;
declare function listEntitiesSubscriptionFromJSON(jsonString: string): Result$1<ListEntitiesSubscription, SDKValidationError>;
/** @internal */
declare const ListEntitiesPurchaseScope$inboundSchema: z$1.ZodMiniType<ListEntitiesPurchaseScope, unknown>;
/** @internal */
declare const ListEntitiesPurchase$inboundSchema: z$1.ZodMiniType<ListEntitiesPurchase, unknown>;
declare function listEntitiesPurchaseFromJSON(jsonString: string): Result$1<ListEntitiesPurchase, SDKValidationError>;
/** @internal */
declare const ListEntitiesType$inboundSchema: z$1.ZodMiniType<ListEntitiesType, unknown>;
/** @internal */
declare const ListEntitiesCreditSchema$inboundSchema: z$1.ZodMiniType<ListEntitiesCreditSchema, unknown>;
declare function listEntitiesCreditSchemaFromJSON(jsonString: string): Result$1<ListEntitiesCreditSchema, SDKValidationError>;
/** @internal */
declare const ListEntitiesModelMarkups$inboundSchema: z$1.ZodMiniType<ListEntitiesModelMarkups, unknown>;
declare function listEntitiesModelMarkupsFromJSON(jsonString: string): Result$1<ListEntitiesModelMarkups, SDKValidationError>;
/** @internal */
declare const ListEntitiesProviderMarkups$inboundSchema: z$1.ZodMiniType<ListEntitiesProviderMarkups, unknown>;
declare function listEntitiesProviderMarkupsFromJSON(jsonString: string): Result$1<ListEntitiesProviderMarkups, SDKValidationError>;
/** @internal */
declare const ListEntitiesDisplay$inboundSchema: z$1.ZodMiniType<ListEntitiesDisplay, unknown>;
declare function listEntitiesDisplayFromJSON(jsonString: string): Result$1<ListEntitiesDisplay, SDKValidationError>;
/** @internal */
declare const ListEntitiesFeature$inboundSchema: z$1.ZodMiniType<ListEntitiesFeature, unknown>;
declare function listEntitiesFeatureFromJSON(jsonString: string): Result$1<ListEntitiesFeature, SDKValidationError>;
/** @internal */
declare const ListEntitiesFlags$inboundSchema: z$1.ZodMiniType<ListEntitiesFlags, unknown>;
declare function listEntitiesFlagsFromJSON(jsonString: string): Result$1<ListEntitiesFlags, SDKValidationError>;
/** @internal */
declare const ListEntitiesLimitType$inboundSchema: z$1.ZodMiniType<ListEntitiesLimitType, unknown>;
/** @internal */
declare const ListEntitiesSpendLimitSource$inboundSchema: z$1.ZodMiniType<ListEntitiesSpendLimitSource, unknown>;
/** @internal */
declare const ListEntitiesSpendLimit$inboundSchema: z$1.ZodMiniType<ListEntitiesSpendLimit, unknown>;
declare function listEntitiesSpendLimitFromJSON(jsonString: string): Result$1<ListEntitiesSpendLimit, SDKValidationError>;
/** @internal */
declare const ListEntitiesInterval$inboundSchema: z$1.ZodMiniType<ListEntitiesInterval, unknown>;
/** @internal */
declare const ListEntitiesFilter$inboundSchema: z$1.ZodMiniType<ListEntitiesFilter, unknown>;
declare function listEntitiesFilterFromJSON(jsonString: string): Result$1<ListEntitiesFilter, SDKValidationError>;
/** @internal */
declare const ListEntitiesUsageLimitSource$inboundSchema: z$1.ZodMiniType<ListEntitiesUsageLimitSource, unknown>;
/** @internal */
declare const ListEntitiesUsageLimit$inboundSchema: z$1.ZodMiniType<ListEntitiesUsageLimit, unknown>;
declare function listEntitiesUsageLimitFromJSON(jsonString: string): Result$1<ListEntitiesUsageLimit, SDKValidationError>;
/** @internal */
declare const ListEntitiesThresholdType$inboundSchema: z$1.ZodMiniType<ListEntitiesThresholdType, unknown>;
/** @internal */
declare const ListEntitiesUsageAlertSource$inboundSchema: z$1.ZodMiniType<ListEntitiesUsageAlertSource, unknown>;
/** @internal */
declare const ListEntitiesUsageAlert$inboundSchema: z$1.ZodMiniType<ListEntitiesUsageAlert, unknown>;
declare function listEntitiesUsageAlertFromJSON(jsonString: string): Result$1<ListEntitiesUsageAlert, SDKValidationError>;
/** @internal */
declare const ListEntitiesOverageAllowedSource$inboundSchema: z$1.ZodMiniType<ListEntitiesOverageAllowedSource, unknown>;
/** @internal */
declare const ListEntitiesOverageAllowed$inboundSchema: z$1.ZodMiniType<ListEntitiesOverageAllowed, unknown>;
declare function listEntitiesOverageAllowedFromJSON(jsonString: string): Result$1<ListEntitiesOverageAllowed, SDKValidationError>;
/** @internal */
declare const ListEntitiesBillingControls$inboundSchema: z$1.ZodMiniType<ListEntitiesBillingControls, unknown>;
declare function listEntitiesBillingControlsFromJSON(jsonString: string): Result$1<ListEntitiesBillingControls, SDKValidationError>;
/** @internal */
declare const ListEntitiesProcessorType$inboundSchema: z$1.ZodMiniType<ListEntitiesProcessorType, unknown>;
/** @internal */
declare const ListEntitiesInvoice$inboundSchema: z$1.ZodMiniType<ListEntitiesInvoice, unknown>;
declare function listEntitiesInvoiceFromJSON(jsonString: string): Result$1<ListEntitiesInvoice, SDKValidationError>;
/** @internal */
declare const ListEntitiesList$inboundSchema: z$1.ZodMiniType<ListEntitiesList, unknown>;
declare function listEntitiesListFromJSON(jsonString: string): Result$1<ListEntitiesList, SDKValidationError>;
/** @internal */
declare const ListEntitiesResponse$inboundSchema: z$1.ZodMiniType<ListEntitiesResponse, unknown>;
declare function listEntitiesResponseFromJSON(jsonString: string): Result$1<ListEntitiesResponse, SDKValidationError>;

type ListEventsGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Filter by specific feature ID(s)
 */
type ListEventsFeatureId = string | Array<string>;
/**
 * Filter events by time range
 */
type ListEventsCustomRange = {
    /**
     * Filter events after this timestamp (epoch milliseconds)
     */
    start?: number | undefined;
    /**
     * Filter events before this timestamp (epoch milliseconds)
     */
    end?: number | undefined;
};
type EventsListParams = {
    /**
     * Opaque pagination cursor. Empty string (default) requests the first page; use next_cursor from a prior response for subsequent pages.
     */
    startCursor?: string | undefined;
    /**
     * Number of items to return. Default 50, hard ceiling 5000.
     */
    limit?: number | undefined;
    /**
     * Filter events by customer ID
     */
    customerId?: string | undefined;
    /**
     * Filter events by entity ID (e.g., per-seat or per-resource)
     */
    entityId?: string | undefined;
    /**
     * Filter by specific feature ID(s)
     */
    featureId?: string | Array<string> | undefined;
    /**
     * Filter events by time range
     */
    customRange?: ListEventsCustomRange | undefined;
};
declare const ListEventsIntervalEnum: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type ListEventsIntervalEnum = OpenEnum<typeof ListEventsIntervalEnum>;
/**
 * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
 */
type ListEventsIntervalUnion = ListEventsIntervalEnum | string;
type ListEventsReset = {
    /**
     * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
     */
    interval: ListEventsIntervalEnum | string;
    /**
     * Number of intervals between resets (eg. 2 for bi-monthly).
     */
    intervalCount?: number | undefined;
    /**
     * Timestamp when the balance will next reset.
     */
    resetsAt: number | null;
};
type Deductions = {
    /**
     * ID of the underlying balance row that was deducted from (customer_entitlement or rollover).
     */
    balanceId: string;
    /**
     * The feature this balance belongs to.
     */
    featureId: string;
    /**
     * ID of the plan/product this balance belongs to. Null when the balance can't be attributed to a single plan (e.g. it spans multiple).
     */
    planId: string | null;
    /**
     * Reset configuration for the balance this deduction came from, or null if the balance doesn't reset.
     */
    reset: ListEventsReset | null;
    /**
     * Amount deducted from this balance. Positive when usage was consumed, negative when credit was restored (e.g. a refund via negative track value).
     */
    value: number;
};
type ListEventsList = {
    /**
     * Event ID (KSUID)
     */
    id: string;
    /**
     * Event timestamp (epoch milliseconds)
     */
    timestamp: number;
    /**
     * ID of the feature that the event belongs to
     */
    featureId: string;
    /**
     * Customer identifier
     */
    customerId: string;
    /**
     * Event value/count
     */
    value: number;
    /**
     * Event properties (JSON)
     */
    properties: {
        [k: string]: any;
    };
    /**
     * Per-balance breakdown of what this event deducted. Null for events ingested before deductions were tracked; an empty array means the event was accepted but no balance moved.
     */
    deductions: Array<Deductions> | null;
};
/**
 * OK
 */
type ListEventsResponse = {
    /**
     * Items for current page.
     */
    list: Array<ListEventsList>;
    /**
     * Opaque cursor for the next page. Null when there are no more results.
     */
    nextCursor: string | null;
};
/** @internal */
type ListEventsFeatureId$Outbound = string | Array<string>;
/** @internal */
declare const ListEventsFeatureId$outboundSchema: z$1.ZodMiniType<ListEventsFeatureId$Outbound, ListEventsFeatureId>;
declare function listEventsFeatureIdToJSON(listEventsFeatureId: ListEventsFeatureId): string;
/** @internal */
type ListEventsCustomRange$Outbound = {
    start?: number | undefined;
    end?: number | undefined;
};
/** @internal */
declare const ListEventsCustomRange$outboundSchema: z$1.ZodMiniType<ListEventsCustomRange$Outbound, ListEventsCustomRange>;
declare function listEventsCustomRangeToJSON(listEventsCustomRange: ListEventsCustomRange): string;
/** @internal */
type EventsListParams$Outbound = {
    start_cursor: string;
    limit: number;
    customer_id?: string | undefined;
    entity_id?: string | undefined;
    feature_id?: string | Array<string> | undefined;
    custom_range?: ListEventsCustomRange$Outbound | undefined;
};
/** @internal */
declare const EventsListParams$outboundSchema: z$1.ZodMiniType<EventsListParams$Outbound, EventsListParams>;
declare function eventsListParamsToJSON(eventsListParams: EventsListParams): string;
/** @internal */
declare const ListEventsIntervalEnum$inboundSchema: z$1.ZodMiniType<ListEventsIntervalEnum, unknown>;
/** @internal */
declare const ListEventsIntervalUnion$inboundSchema: z$1.ZodMiniType<ListEventsIntervalUnion, unknown>;
declare function listEventsIntervalUnionFromJSON(jsonString: string): Result$1<ListEventsIntervalUnion, SDKValidationError>;
/** @internal */
declare const ListEventsReset$inboundSchema: z$1.ZodMiniType<ListEventsReset, unknown>;
declare function listEventsResetFromJSON(jsonString: string): Result$1<ListEventsReset, SDKValidationError>;
/** @internal */
declare const Deductions$inboundSchema: z$1.ZodMiniType<Deductions, unknown>;
declare function deductionsFromJSON(jsonString: string): Result$1<Deductions, SDKValidationError>;
/** @internal */
declare const ListEventsList$inboundSchema: z$1.ZodMiniType<ListEventsList, unknown>;
declare function listEventsListFromJSON(jsonString: string): Result$1<ListEventsList, SDKValidationError>;
/** @internal */
declare const ListEventsResponse$inboundSchema: z$1.ZodMiniType<ListEventsResponse, unknown>;
declare function listEventsResponseFromJSON(jsonString: string): Result$1<ListEventsResponse, SDKValidationError>;

type ListFeaturesGlobals = {
    xApiVersion?: string | undefined;
};
type ListFeaturesRequest = {};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const ListFeaturesType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type ListFeaturesType = OpenEnum<typeof ListFeaturesType>;
type ListFeaturesCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type ListFeaturesModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type ListFeaturesProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type ListFeaturesDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
type ListFeaturesList = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: ListFeaturesType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<ListFeaturesCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: ListFeaturesModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: ListFeaturesProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: ListFeaturesDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
/**
 * OK
 */
type ListFeaturesResponse = {
    list: Array<ListFeaturesList>;
};
/** @internal */
type ListFeaturesRequest$Outbound = {};
/** @internal */
declare const ListFeaturesRequest$outboundSchema: z$1.ZodMiniType<ListFeaturesRequest$Outbound, ListFeaturesRequest>;
declare function listFeaturesRequestToJSON(listFeaturesRequest: ListFeaturesRequest): string;
/** @internal */
declare const ListFeaturesType$inboundSchema: z$1.ZodMiniType<ListFeaturesType, unknown>;
/** @internal */
declare const ListFeaturesCreditSchema$inboundSchema: z$1.ZodMiniType<ListFeaturesCreditSchema, unknown>;
declare function listFeaturesCreditSchemaFromJSON(jsonString: string): Result$1<ListFeaturesCreditSchema, SDKValidationError>;
/** @internal */
declare const ListFeaturesModelMarkups$inboundSchema: z$1.ZodMiniType<ListFeaturesModelMarkups, unknown>;
declare function listFeaturesModelMarkupsFromJSON(jsonString: string): Result$1<ListFeaturesModelMarkups, SDKValidationError>;
/** @internal */
declare const ListFeaturesProviderMarkups$inboundSchema: z$1.ZodMiniType<ListFeaturesProviderMarkups, unknown>;
declare function listFeaturesProviderMarkupsFromJSON(jsonString: string): Result$1<ListFeaturesProviderMarkups, SDKValidationError>;
/** @internal */
declare const ListFeaturesDisplay$inboundSchema: z$1.ZodMiniType<ListFeaturesDisplay, unknown>;
declare function listFeaturesDisplayFromJSON(jsonString: string): Result$1<ListFeaturesDisplay, SDKValidationError>;
/** @internal */
declare const ListFeaturesList$inboundSchema: z$1.ZodMiniType<ListFeaturesList, unknown>;
declare function listFeaturesListFromJSON(jsonString: string): Result$1<ListFeaturesList, SDKValidationError>;
/** @internal */
declare const ListFeaturesResponse$inboundSchema: z$1.ZodMiniType<ListFeaturesResponse, unknown>;
declare function listFeaturesResponseFromJSON(jsonString: string): Result$1<ListFeaturesResponse, SDKValidationError>;

type ListPlansGlobals = {
    xApiVersion?: string | undefined;
};
type ListPlansParams = {
    /**
     * Customer ID to include eligibility info (trial availability, attach scenario).
     */
    customerId?: string | undefined;
    /**
     * Entity ID for entity-scoped plans.
     */
    entityId?: string | undefined;
    /**
     * If true, includes archived plans in the response.
     */
    includeArchived?: boolean | undefined;
    /**
     * If true, includes all plan versions.
     */
    allVersions?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const ListPlansPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type ListPlansPriceInterval = OpenEnum<typeof ListPlansPriceInterval>;
/**
 * Display text for showing this price in pricing pages.
 */
type ListPlansPriceDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
type ListPlansPrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: ListPlansPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Display text for showing this price in pricing pages.
     */
    display?: ListPlansPriceDisplay | undefined;
};
/**
 * The type of the feature
 */
declare const ListPlansType: {
    readonly Static: "static";
    readonly Boolean: "boolean";
    readonly SingleUse: "single_use";
    readonly ContinuousUse: "continuous_use";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * The type of the feature
 */
type ListPlansType = OpenEnum<typeof ListPlansType>;
type ListPlansFeatureDisplay = {
    /**
     * The singular display name for the feature.
     */
    singular: string;
    /**
     * The plural display name for the feature.
     */
    plural: string;
};
type ListPlansCreditSchema = {
    /**
     * The ID of the metered feature (should be a single_use feature).
     */
    meteredFeatureId: string;
    /**
     * The credit cost of the metered feature.
     */
    creditCost: number;
};
/**
 * The full feature object if expanded.
 */
type ListPlansFeature = {
    /**
     * The ID of the feature, used to refer to it in other API calls like /track or /check.
     */
    id: string;
    /**
     * The name of the feature.
     */
    name?: string | null | undefined;
    /**
     * The type of the feature
     */
    type: ListPlansType;
    /**
     * Singular and plural display names for the feature.
     */
    display?: ListPlansFeatureDisplay | null | undefined;
    /**
     * Credit cost schema for credit system features.
     */
    creditSchema?: Array<ListPlansCreditSchema> | null | undefined;
    /**
     * Whether or not the feature is archived.
     */
    archived?: boolean | null | undefined;
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
declare const ListPlansResetItemInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
type ListPlansResetItemInterval = OpenEnum<typeof ListPlansResetItemInterval>;
type ListPlansItemReset = {
    /**
     * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
     */
    interval: ListPlansResetItemInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type ListPlansTo = number | string;
type ListPlansItemTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const ListPlansItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type ListPlansItemTierBehavior = OpenEnum<typeof ListPlansItemTierBehavior>;
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
declare const ListPlansPriceItemInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
type ListPlansPriceItemInterval = OpenEnum<typeof ListPlansPriceItemInterval>;
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
declare const ListPlansItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
type ListPlansItemBillingMethod = OpenEnum<typeof ListPlansItemBillingMethod>;
type ListPlansItemPrice = {
    /**
     * Price per billing_units after included usage is consumed. Mutually exclusive with tiers.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing configuration. Each tier's 'to' INCLUDES the included amount. Either 'tiers' or 'amount' is required.
     */
    tiers?: Array<ListPlansItemTier> | undefined;
    tierBehavior?: ListPlansItemTierBehavior | undefined;
    /**
     * Billing interval for this price. For consumable features, should match reset.interval.
     */
    interval: ListPlansPriceItemInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Number of units per price increment. Usage is rounded UP to the nearest billing_units when billed (e.g. billing_units=100 means 101 usage rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
     */
    billingMethod: ListPlansItemBillingMethod;
    /**
     * Maximum units a customer can purchase beyond included. E.g. if included=100 and max_purchase=300, customer can use up to 400 total before usage is capped. Null for no limit.
     */
    maxPurchase: number | null;
};
/**
 * Display text for showing this item in pricing pages.
 */
type ListPlansItemDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
/**
 * When rolled over units expire.
 */
declare const ListPlansItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type ListPlansItemExpiryDurationType = OpenEnum<typeof ListPlansItemExpiryDurationType>;
/**
 * Rollover configuration for unused units. If set, unused included units roll over to the next period.
 */
type ListPlansItemRollover = {
    /**
     * Maximum rollover units. Null for unlimited rollover.
     */
    max: number | null;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | null | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: ListPlansItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
type ListPlansItem = {
    /**
     * The ID of the feature this item configures.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: ListPlansFeature | undefined;
    /**
     * Number of free units included. For consumable features, balance resets to this number each interval.
     */
    included: number;
    /**
     * Whether the customer has unlimited access to this feature.
     */
    unlimited: boolean;
    /**
     * Reset configuration for consumable features. Null for non-consumable features like seats where usage persists across billing cycles.
     */
    reset: ListPlansItemReset | null;
    /**
     * Pricing configuration for usage beyond included units. Null if feature is entirely free.
     */
    price: ListPlansItemPrice | null;
    /**
     * Display text for showing this item in pricing pages.
     */
    display?: ListPlansItemDisplay | undefined;
    /**
     * Rollover configuration for unused units. If set, unused included units roll over to the next period.
     */
    rollover?: ListPlansItemRollover | undefined;
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
declare const ListPlansDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
type ListPlansDurationType = OpenEnum<typeof ListPlansDurationType>;
declare const ListPlansOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
type ListPlansOnEnd = OpenEnum<typeof ListPlansOnEnd>;
/**
 * Free trial configuration. If set, new customers can try this plan before being charged.
 */
type ListPlansFreeTrial = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial duration ('day', 'month', 'year').
     */
    durationType: ListPlansDurationType;
    /**
     * Whether a payment method is required to start the trial. If true, customer will be charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: ListPlansOnEnd | null | undefined;
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
declare const ListPlansEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
type ListPlansEnv = OpenEnum<typeof ListPlansEnv>;
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const ListPlansPriceVariantDetailsInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type ListPlansPriceVariantDetailsInterval = OpenEnum<typeof ListPlansPriceVariantDetailsInterval>;
/**
 * Base price configuration for a plan.
 */
type ListPlansBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: ListPlansPriceVariantDetailsInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const ListPlansAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type ListPlansAddItemResetInterval = OpenEnum<typeof ListPlansAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type ListPlansVariantDetailsReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: ListPlansAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type ListPlansVariantDetailsTier = {
    to?: any | undefined;
    amount: number;
    flatAmount?: number | undefined;
};
declare const ListPlansVariantDetailsTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type ListPlansVariantDetailsTierBehavior = OpenEnum<typeof ListPlansVariantDetailsTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const ListPlansAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type ListPlansAddItemPriceInterval = OpenEnum<typeof ListPlansAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const ListPlansAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type ListPlansAddItemBillingMethod = OpenEnum<typeof ListPlansAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type ListPlansVariantDetailsPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<ListPlansVariantDetailsTier> | undefined;
    tierBehavior?: ListPlansVariantDetailsTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: ListPlansAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount: number;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: ListPlansAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const ListPlansOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type ListPlansOnIncrease = OpenEnum<typeof ListPlansOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const ListPlansOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type ListPlansOnDecrease = OpenEnum<typeof ListPlansOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type ListPlansProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: ListPlansOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: ListPlansOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const ListPlansVariantDetailsExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type ListPlansVariantDetailsExpiryDurationType = OpenEnum<typeof ListPlansVariantDetailsExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type ListPlansVariantDetailsRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: ListPlansVariantDetailsExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type ListPlansPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: ListPlansVariantDetailsReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: ListPlansVariantDetailsPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: ListPlansProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: ListPlansVariantDetailsRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const ListPlansRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type ListPlansRemoveItemBillingMethod = OpenEnum<typeof ListPlansRemoveItemBillingMethod>;
declare const ListPlansIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type ListPlansIntervalRemoveItemEnum2 = OpenEnum<typeof ListPlansIntervalRemoveItemEnum2>;
declare const ListPlansIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type ListPlansIntervalRemoveItemEnum1 = OpenEnum<typeof ListPlansIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type ListPlansIntervalUnion = ListPlansIntervalRemoveItemEnum1 | ListPlansIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type ListPlansPlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: ListPlansRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: ListPlansIntervalRemoveItemEnum1 | ListPlansIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const ListPlansVariantDetailsDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type ListPlansVariantDetailsDurationType = OpenEnum<typeof ListPlansVariantDetailsDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const ListPlansVariantDetailsOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type ListPlansVariantDetailsOnEnd = OpenEnum<typeof ListPlansVariantDetailsOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type ListPlansFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType: ListPlansVariantDetailsDurationType;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: ListPlansVariantDetailsOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const ListPlansVariantDetailsPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type ListPlansVariantDetailsPurchaseLimitInterval = OpenEnum<typeof ListPlansVariantDetailsPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type ListPlansVariantDetailsPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: ListPlansVariantDetailsPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type ListPlansVariantDetailsAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: ListPlansVariantDetailsPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const ListPlansVariantDetailsLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type ListPlansVariantDetailsLimitType = OpenEnum<typeof ListPlansVariantDetailsLimitType>;
type ListPlansVariantDetailsSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: ListPlansVariantDetailsLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const ListPlansVariantDetailsUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type ListPlansVariantDetailsUsageLimitInterval = OpenEnum<typeof ListPlansVariantDetailsUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type ListPlansVariantDetailsFilter = {
    properties: {
        [k: string]: any;
    };
};
type ListPlansVariantDetailsUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: ListPlansVariantDetailsUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: ListPlansVariantDetailsFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const ListPlansVariantDetailsThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type ListPlansVariantDetailsThresholdType = OpenEnum<typeof ListPlansVariantDetailsThresholdType>;
type ListPlansVariantDetailsUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: ListPlansVariantDetailsThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type ListPlansVariantDetailsOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type ListPlansVariantDetailsBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<ListPlansVariantDetailsAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<ListPlansVariantDetailsSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<ListPlansVariantDetailsUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<ListPlansVariantDetailsUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<ListPlansVariantDetailsOverageAllowed> | undefined;
};
/**
 * The customization that transforms the base plan into this variant.
 */
type ListPlansCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: ListPlansBasePrice | null | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<ListPlansPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<ListPlansPlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: ListPlansFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: ListPlansVariantDetailsBillingControls | undefined;
};
/**
 * Details about how this variant relates to its latest base plan.
 */
type ListPlansVariantDetails = {
    /**
     * The ID of the base plan this variant was derived from.
     */
    basePlanId: string;
    /**
     * The customization that transforms the base plan into this variant.
     */
    customize?: ListPlansCustomize | undefined;
};
/**
 * Miscellaneous plan-level configuration flags.
 */
type ListPlansConfig = {
    /**
     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
     */
    ignorePastDue: boolean;
};
/**
 * The time interval for the purchase limit window.
 */
declare const ListPlansPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type ListPlansPurchaseLimitInterval = OpenEnum<typeof ListPlansPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type ListPlansPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: ListPlansPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type ListPlansAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: ListPlansPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const ListPlansLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type ListPlansLimitType = OpenEnum<typeof ListPlansLimitType>;
type ListPlansSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: ListPlansLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const ListPlansUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type ListPlansUsageLimitInterval = OpenEnum<typeof ListPlansUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type ListPlansFilter = {
    properties: {
        [k: string]: any;
    };
};
type ListPlansUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: ListPlansUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: ListPlansFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const ListPlansThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type ListPlansThresholdType = OpenEnum<typeof ListPlansThresholdType>;
type ListPlansUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: ListPlansThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type ListPlansOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Plan-level billing controls used as customer defaults.
 */
type ListPlansBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<ListPlansAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<ListPlansSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<ListPlansUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<ListPlansUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<ListPlansOverageAllowed> | undefined;
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
declare const ListPlansStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
type ListPlansStatus = OpenEnum<typeof ListPlansStatus>;
/**
 * The action that would occur if this plan were attached to the customer.
 */
declare const ListPlansAttachAction: {
    readonly Activate: "activate";
    readonly Upgrade: "upgrade";
    readonly Downgrade: "downgrade";
    readonly None: "none";
    readonly Purchase: "purchase";
};
/**
 * The action that would occur if this plan were attached to the customer.
 */
type ListPlansAttachAction = OpenEnum<typeof ListPlansAttachAction>;
type ListPlansCustomerEligibility = {
    /**
     * Whether the trial on this plan is available to this customer. For example, if the customer used the trial in the past, this will be false.
     */
    trialAvailable?: boolean | undefined;
    /**
     * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
     */
    status?: ListPlansStatus | undefined;
    /**
     * Whether the customer's active instance of this plan is set to cancel.
     */
    canceling?: boolean | undefined;
    /**
     * Whether the customer is currently on a free trial of this plan.
     */
    trialing?: boolean | undefined;
    /**
     * The action that would occur if this plan were attached to the customer.
     */
    attachAction: ListPlansAttachAction;
};
/**
 * A plan defines a set of features, pricing, and entitlements that can be attached to customers.
 */
type ListPlansList = {
    /**
     * Unique identifier for the plan.
     */
    id: string;
    /**
     * Display name of the plan.
     */
    name: string;
    /**
     * Optional description of the plan.
     */
    description: string | null;
    /**
     * Group identifier for organizing related plans. Plans in the same group are mutually exclusive.
     */
    group: string | null;
    /**
     * Version number of the plan. Incremented when plan configuration changes.
     */
    version: number;
    /**
     * Whether this is an add-on plan that can be attached alongside a main plan.
     */
    addOn: boolean;
    /**
     * If true, this plan is automatically attached when a customer is created. Used for free plans.
     */
    autoEnable: boolean;
    /**
     * Base recurring price for the plan. Null for free plans or usage-only plans.
     */
    price: ListPlansPrice | null;
    /**
     * Feature configurations included in this plan. Each item defines included units, pricing, and reset behavior for a feature.
     */
    items: Array<ListPlansItem>;
    /**
     * Free trial configuration. If set, new customers can try this plan before being charged.
     */
    freeTrial?: ListPlansFreeTrial | undefined;
    /**
     * Unix timestamp (ms) when the plan was created.
     */
    createdAt: number;
    /**
     * Environment this plan belongs to ('sandbox' or 'live').
     */
    env: ListPlansEnv;
    /**
     * Whether the plan is archived. Archived plans cannot be attached to new customers.
     */
    archived: boolean;
    /**
     * Deprecated. Use variant_details.base_plan_id instead. If this is a variant, the ID of the base plan it was created from.
     */
    baseVariantId: string | null;
    /**
     * Details about how this variant relates to its latest base plan.
     */
    variantDetails?: ListPlansVariantDetails | undefined;
    /**
     * Miscellaneous plan-level configuration flags.
     */
    config: ListPlansConfig;
    /**
     * Plan-level billing controls used as customer defaults.
     */
    billingControls?: ListPlansBillingControls | undefined;
    /**
     * Arbitrary key-value metadata defined by you for your own use. Shared across all versions of the plan.
     */
    metadata: {
        [k: string]: any;
    };
    customerEligibility?: ListPlansCustomerEligibility | undefined;
};
/**
 * OK
 */
type ListPlansResponse = {
    list: Array<ListPlansList>;
};
/** @internal */
type ListPlansParams$Outbound = {
    customer_id?: string | undefined;
    entity_id?: string | undefined;
    include_archived?: boolean | undefined;
    all_versions?: boolean | undefined;
};
/** @internal */
declare const ListPlansParams$outboundSchema: z$1.ZodMiniType<ListPlansParams$Outbound, ListPlansParams>;
declare function listPlansParamsToJSON(listPlansParams: ListPlansParams): string;
/** @internal */
declare const ListPlansPriceInterval$inboundSchema: z$1.ZodMiniType<ListPlansPriceInterval, unknown>;
/** @internal */
declare const ListPlansPriceDisplay$inboundSchema: z$1.ZodMiniType<ListPlansPriceDisplay, unknown>;
declare function listPlansPriceDisplayFromJSON(jsonString: string): Result$1<ListPlansPriceDisplay, SDKValidationError>;
/** @internal */
declare const ListPlansPrice$inboundSchema: z$1.ZodMiniType<ListPlansPrice, unknown>;
declare function listPlansPriceFromJSON(jsonString: string): Result$1<ListPlansPrice, SDKValidationError>;
/** @internal */
declare const ListPlansType$inboundSchema: z$1.ZodMiniType<ListPlansType, unknown>;
/** @internal */
declare const ListPlansFeatureDisplay$inboundSchema: z$1.ZodMiniType<ListPlansFeatureDisplay, unknown>;
declare function listPlansFeatureDisplayFromJSON(jsonString: string): Result$1<ListPlansFeatureDisplay, SDKValidationError>;
/** @internal */
declare const ListPlansCreditSchema$inboundSchema: z$1.ZodMiniType<ListPlansCreditSchema, unknown>;
declare function listPlansCreditSchemaFromJSON(jsonString: string): Result$1<ListPlansCreditSchema, SDKValidationError>;
/** @internal */
declare const ListPlansFeature$inboundSchema: z$1.ZodMiniType<ListPlansFeature, unknown>;
declare function listPlansFeatureFromJSON(jsonString: string): Result$1<ListPlansFeature, SDKValidationError>;
/** @internal */
declare const ListPlansResetItemInterval$inboundSchema: z$1.ZodMiniType<ListPlansResetItemInterval, unknown>;
/** @internal */
declare const ListPlansItemReset$inboundSchema: z$1.ZodMiniType<ListPlansItemReset, unknown>;
declare function listPlansItemResetFromJSON(jsonString: string): Result$1<ListPlansItemReset, SDKValidationError>;
/** @internal */
declare const ListPlansTo$inboundSchema: z$1.ZodMiniType<ListPlansTo, unknown>;
declare function listPlansToFromJSON(jsonString: string): Result$1<ListPlansTo, SDKValidationError>;
/** @internal */
declare const ListPlansItemTier$inboundSchema: z$1.ZodMiniType<ListPlansItemTier, unknown>;
declare function listPlansItemTierFromJSON(jsonString: string): Result$1<ListPlansItemTier, SDKValidationError>;
/** @internal */
declare const ListPlansItemTierBehavior$inboundSchema: z$1.ZodMiniType<ListPlansItemTierBehavior, unknown>;
/** @internal */
declare const ListPlansPriceItemInterval$inboundSchema: z$1.ZodMiniType<ListPlansPriceItemInterval, unknown>;
/** @internal */
declare const ListPlansItemBillingMethod$inboundSchema: z$1.ZodMiniType<ListPlansItemBillingMethod, unknown>;
/** @internal */
declare const ListPlansItemPrice$inboundSchema: z$1.ZodMiniType<ListPlansItemPrice, unknown>;
declare function listPlansItemPriceFromJSON(jsonString: string): Result$1<ListPlansItemPrice, SDKValidationError>;
/** @internal */
declare const ListPlansItemDisplay$inboundSchema: z$1.ZodMiniType<ListPlansItemDisplay, unknown>;
declare function listPlansItemDisplayFromJSON(jsonString: string): Result$1<ListPlansItemDisplay, SDKValidationError>;
/** @internal */
declare const ListPlansItemExpiryDurationType$inboundSchema: z$1.ZodMiniType<ListPlansItemExpiryDurationType, unknown>;
/** @internal */
declare const ListPlansItemRollover$inboundSchema: z$1.ZodMiniType<ListPlansItemRollover, unknown>;
declare function listPlansItemRolloverFromJSON(jsonString: string): Result$1<ListPlansItemRollover, SDKValidationError>;
/** @internal */
declare const ListPlansItem$inboundSchema: z$1.ZodMiniType<ListPlansItem, unknown>;
declare function listPlansItemFromJSON(jsonString: string): Result$1<ListPlansItem, SDKValidationError>;
/** @internal */
declare const ListPlansDurationType$inboundSchema: z$1.ZodMiniType<ListPlansDurationType, unknown>;
/** @internal */
declare const ListPlansOnEnd$inboundSchema: z$1.ZodMiniType<ListPlansOnEnd, unknown>;
/** @internal */
declare const ListPlansFreeTrial$inboundSchema: z$1.ZodMiniType<ListPlansFreeTrial, unknown>;
declare function listPlansFreeTrialFromJSON(jsonString: string): Result$1<ListPlansFreeTrial, SDKValidationError>;
/** @internal */
declare const ListPlansEnv$inboundSchema: z$1.ZodMiniType<ListPlansEnv, unknown>;
/** @internal */
declare const ListPlansPriceVariantDetailsInterval$inboundSchema: z$1.ZodMiniType<ListPlansPriceVariantDetailsInterval, unknown>;
/** @internal */
declare const ListPlansBasePrice$inboundSchema: z$1.ZodMiniType<ListPlansBasePrice, unknown>;
declare function listPlansBasePriceFromJSON(jsonString: string): Result$1<ListPlansBasePrice, SDKValidationError>;
/** @internal */
declare const ListPlansAddItemResetInterval$inboundSchema: z$1.ZodMiniType<ListPlansAddItemResetInterval, unknown>;
/** @internal */
declare const ListPlansVariantDetailsReset$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsReset, unknown>;
declare function listPlansVariantDetailsResetFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsReset, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsTier$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsTier, unknown>;
declare function listPlansVariantDetailsTierFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsTier, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsTierBehavior$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsTierBehavior, unknown>;
/** @internal */
declare const ListPlansAddItemPriceInterval$inboundSchema: z$1.ZodMiniType<ListPlansAddItemPriceInterval, unknown>;
/** @internal */
declare const ListPlansAddItemBillingMethod$inboundSchema: z$1.ZodMiniType<ListPlansAddItemBillingMethod, unknown>;
/** @internal */
declare const ListPlansVariantDetailsPrice$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsPrice, unknown>;
declare function listPlansVariantDetailsPriceFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsPrice, SDKValidationError>;
/** @internal */
declare const ListPlansOnIncrease$inboundSchema: z$1.ZodMiniType<ListPlansOnIncrease, unknown>;
/** @internal */
declare const ListPlansOnDecrease$inboundSchema: z$1.ZodMiniType<ListPlansOnDecrease, unknown>;
/** @internal */
declare const ListPlansProration$inboundSchema: z$1.ZodMiniType<ListPlansProration, unknown>;
declare function listPlansProrationFromJSON(jsonString: string): Result$1<ListPlansProration, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsExpiryDurationType$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsExpiryDurationType, unknown>;
/** @internal */
declare const ListPlansVariantDetailsRollover$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsRollover, unknown>;
declare function listPlansVariantDetailsRolloverFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsRollover, SDKValidationError>;
/** @internal */
declare const ListPlansPlanItem$inboundSchema: z$1.ZodMiniType<ListPlansPlanItem, unknown>;
declare function listPlansPlanItemFromJSON(jsonString: string): Result$1<ListPlansPlanItem, SDKValidationError>;
/** @internal */
declare const ListPlansRemoveItemBillingMethod$inboundSchema: z$1.ZodMiniType<ListPlansRemoveItemBillingMethod, unknown>;
/** @internal */
declare const ListPlansIntervalRemoveItemEnum2$inboundSchema: z$1.ZodMiniType<ListPlansIntervalRemoveItemEnum2, unknown>;
/** @internal */
declare const ListPlansIntervalRemoveItemEnum1$inboundSchema: z$1.ZodMiniType<ListPlansIntervalRemoveItemEnum1, unknown>;
/** @internal */
declare const ListPlansIntervalUnion$inboundSchema: z$1.ZodMiniType<ListPlansIntervalUnion, unknown>;
declare function listPlansIntervalUnionFromJSON(jsonString: string): Result$1<ListPlansIntervalUnion, SDKValidationError>;
/** @internal */
declare const ListPlansPlanItemFilter$inboundSchema: z$1.ZodMiniType<ListPlansPlanItemFilter, unknown>;
declare function listPlansPlanItemFilterFromJSON(jsonString: string): Result$1<ListPlansPlanItemFilter, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsDurationType$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsDurationType, unknown>;
/** @internal */
declare const ListPlansVariantDetailsOnEnd$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsOnEnd, unknown>;
/** @internal */
declare const ListPlansFreeTrialParams$inboundSchema: z$1.ZodMiniType<ListPlansFreeTrialParams, unknown>;
declare function listPlansFreeTrialParamsFromJSON(jsonString: string): Result$1<ListPlansFreeTrialParams, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsPurchaseLimitInterval, unknown>;
/** @internal */
declare const ListPlansVariantDetailsPurchaseLimit$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsPurchaseLimit, unknown>;
declare function listPlansVariantDetailsPurchaseLimitFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsPurchaseLimit, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsAutoTopup$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsAutoTopup, unknown>;
declare function listPlansVariantDetailsAutoTopupFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsAutoTopup, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsLimitType$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsLimitType, unknown>;
/** @internal */
declare const ListPlansVariantDetailsSpendLimit$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsSpendLimit, unknown>;
declare function listPlansVariantDetailsSpendLimitFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsSpendLimit, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsUsageLimitInterval$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsUsageLimitInterval, unknown>;
/** @internal */
declare const ListPlansVariantDetailsFilter$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsFilter, unknown>;
declare function listPlansVariantDetailsFilterFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsFilter, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsUsageLimit$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsUsageLimit, unknown>;
declare function listPlansVariantDetailsUsageLimitFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsUsageLimit, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsThresholdType$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsThresholdType, unknown>;
/** @internal */
declare const ListPlansVariantDetailsUsageAlert$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsUsageAlert, unknown>;
declare function listPlansVariantDetailsUsageAlertFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsUsageAlert, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsOverageAllowed$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsOverageAllowed, unknown>;
declare function listPlansVariantDetailsOverageAllowedFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsOverageAllowed, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetailsBillingControls$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetailsBillingControls, unknown>;
declare function listPlansVariantDetailsBillingControlsFromJSON(jsonString: string): Result$1<ListPlansVariantDetailsBillingControls, SDKValidationError>;
/** @internal */
declare const ListPlansCustomize$inboundSchema: z$1.ZodMiniType<ListPlansCustomize, unknown>;
declare function listPlansCustomizeFromJSON(jsonString: string): Result$1<ListPlansCustomize, SDKValidationError>;
/** @internal */
declare const ListPlansVariantDetails$inboundSchema: z$1.ZodMiniType<ListPlansVariantDetails, unknown>;
declare function listPlansVariantDetailsFromJSON(jsonString: string): Result$1<ListPlansVariantDetails, SDKValidationError>;
/** @internal */
declare const ListPlansConfig$inboundSchema: z$1.ZodMiniType<ListPlansConfig, unknown>;
declare function listPlansConfigFromJSON(jsonString: string): Result$1<ListPlansConfig, SDKValidationError>;
/** @internal */
declare const ListPlansPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<ListPlansPurchaseLimitInterval, unknown>;
/** @internal */
declare const ListPlansPurchaseLimit$inboundSchema: z$1.ZodMiniType<ListPlansPurchaseLimit, unknown>;
declare function listPlansPurchaseLimitFromJSON(jsonString: string): Result$1<ListPlansPurchaseLimit, SDKValidationError>;
/** @internal */
declare const ListPlansAutoTopup$inboundSchema: z$1.ZodMiniType<ListPlansAutoTopup, unknown>;
declare function listPlansAutoTopupFromJSON(jsonString: string): Result$1<ListPlansAutoTopup, SDKValidationError>;
/** @internal */
declare const ListPlansLimitType$inboundSchema: z$1.ZodMiniType<ListPlansLimitType, unknown>;
/** @internal */
declare const ListPlansSpendLimit$inboundSchema: z$1.ZodMiniType<ListPlansSpendLimit, unknown>;
declare function listPlansSpendLimitFromJSON(jsonString: string): Result$1<ListPlansSpendLimit, SDKValidationError>;
/** @internal */
declare const ListPlansUsageLimitInterval$inboundSchema: z$1.ZodMiniType<ListPlansUsageLimitInterval, unknown>;
/** @internal */
declare const ListPlansFilter$inboundSchema: z$1.ZodMiniType<ListPlansFilter, unknown>;
declare function listPlansFilterFromJSON(jsonString: string): Result$1<ListPlansFilter, SDKValidationError>;
/** @internal */
declare const ListPlansUsageLimit$inboundSchema: z$1.ZodMiniType<ListPlansUsageLimit, unknown>;
declare function listPlansUsageLimitFromJSON(jsonString: string): Result$1<ListPlansUsageLimit, SDKValidationError>;
/** @internal */
declare const ListPlansThresholdType$inboundSchema: z$1.ZodMiniType<ListPlansThresholdType, unknown>;
/** @internal */
declare const ListPlansUsageAlert$inboundSchema: z$1.ZodMiniType<ListPlansUsageAlert, unknown>;
declare function listPlansUsageAlertFromJSON(jsonString: string): Result$1<ListPlansUsageAlert, SDKValidationError>;
/** @internal */
declare const ListPlansOverageAllowed$inboundSchema: z$1.ZodMiniType<ListPlansOverageAllowed, unknown>;
declare function listPlansOverageAllowedFromJSON(jsonString: string): Result$1<ListPlansOverageAllowed, SDKValidationError>;
/** @internal */
declare const ListPlansBillingControls$inboundSchema: z$1.ZodMiniType<ListPlansBillingControls, unknown>;
declare function listPlansBillingControlsFromJSON(jsonString: string): Result$1<ListPlansBillingControls, SDKValidationError>;
/** @internal */
declare const ListPlansStatus$inboundSchema: z$1.ZodMiniType<ListPlansStatus, unknown>;
/** @internal */
declare const ListPlansAttachAction$inboundSchema: z$1.ZodMiniType<ListPlansAttachAction, unknown>;
/** @internal */
declare const ListPlansCustomerEligibility$inboundSchema: z$1.ZodMiniType<ListPlansCustomerEligibility, unknown>;
declare function listPlansCustomerEligibilityFromJSON(jsonString: string): Result$1<ListPlansCustomerEligibility, SDKValidationError>;
/** @internal */
declare const ListPlansList$inboundSchema: z$1.ZodMiniType<ListPlansList, unknown>;
declare function listPlansListFromJSON(jsonString: string): Result$1<ListPlansList, SDKValidationError>;
/** @internal */
declare const ListPlansResponse$inboundSchema: z$1.ZodMiniType<ListPlansResponse, unknown>;
declare function listPlansResponseFromJSON(jsonString: string): Result$1<ListPlansResponse, SDKValidationError>;

type ListRewardsGlobals = {
    xApiVersion?: string | undefined;
};
type RewardsListParams = {};
/**
 * The type of discount: percentage_discount, fixed_discount, or invoice_credits.
 */
declare const CouponType: {
    readonly PercentageDiscount: "percentage_discount";
    readonly FixedDiscount: "fixed_discount";
    readonly InvoiceCredits: "invoice_credits";
};
/**
 * The type of discount: percentage_discount, fixed_discount, or invoice_credits.
 */
type CouponType = OpenEnum<typeof CouponType>;
/**
 * The unit of time the duration is measured in.
 */
declare const DurationType: {
    readonly OneOff: "one_off";
    readonly Months: "months";
    readonly Forever: "forever";
};
/**
 * The unit of time the duration is measured in.
 */
type DurationType = OpenEnum<typeof DurationType>;
/**
 * How long the coupon applies once redeemed.
 */
type ListRewardsDuration = {
    /**
     * The unit of time the duration is measured in.
     */
    type: DurationType;
    /**
     * The number of `type` periods the duration lasts, or null when the type has no length (e.g. one_off, forever).
     */
    length: number | null;
};
type CouponPromoCode = {
    /**
     * The promo code customers enter to redeem the coupon.
     */
    code: string;
    /**
     * Maximum number of times this promo code can be redeemed across all customers, or null for unlimited.
     */
    globalMaxRedemption?: number | null | undefined;
    /**
     * Whether this promo code can only be applied to a customer's first transaction.
     */
    firstTimeTransaction?: boolean | null | undefined;
};
type Coupon = {
    /**
     * The unique identifier for the coupon.
     */
    id: string;
    /**
     * A human-readable name for the coupon.
     */
    name?: string | null | undefined;
    /**
     * The type of discount: percentage_discount, fixed_discount, or invoice_credits.
     */
    type: CouponType;
    /**
     * The discount value. A percentage for percentage_discount, or an amount for fixed_discount / invoice_credits.
     */
    value: number;
    /**
     * How long the coupon applies once redeemed.
     */
    duration: ListRewardsDuration;
    /**
     * The plan IDs the coupon applies to, or null when it applies to all plans.
     */
    planIds: Array<string> | null;
    /**
     * The promo codes customers can use to redeem the coupon.
     */
    promoCodes: Array<CouponPromoCode>;
    /**
     * The Unix timestamp (in milliseconds) when the coupon was created.
     */
    createdAt: number;
};
/**
 * The unit of time the duration is measured in.
 */
declare const ExpiryType: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * The unit of time the duration is measured in.
 */
type ExpiryType = OpenEnum<typeof ExpiryType>;
type Expiry = {
    /**
     * The unit of time the duration is measured in.
     */
    type: ExpiryType;
    /**
     * The number of `type` periods the duration lasts, or null when the type has no length (e.g. one_off, forever).
     */
    length: number | null;
};
type Grant = {
    /**
     * The feature ID this grant applies to.
     */
    featureId: string;
    /**
     * The amount of the feature granted, or null for boolean features.
     */
    included: number | null;
    /**
     * How long the granted amount lasts before expiring, or null for a permanent grant.
     */
    expiry: Expiry | null;
};
type FeatureGrantPromoCode = {
    /**
     * The promo code customers enter to redeem the feature grant.
     */
    code: string;
    /**
     * Maximum number of times this promo code can be redeemed, or null for unlimited.
     */
    maxUses: number | null;
};
type FeatureGrant = {
    /**
     * The unique identifier for the feature grant.
     */
    id: string;
    /**
     * A human-readable name for the feature grant.
     */
    name?: string | null | undefined;
    /**
     * The feature grants awarded when the grant is redeemed.
     */
    grants: Array<Grant>;
    /**
     * The promo codes customers can use to redeem the feature grant.
     */
    promoCodes: Array<FeatureGrantPromoCode>;
    /**
     * The Unix timestamp (in milliseconds) when the feature grant was created.
     */
    createdAt: number;
};
/**
 * OK
 */
type ListRewardsResponse = {
    /**
     * The list of coupons configured for the organization.
     */
    coupons: Array<Coupon>;
    /**
     * The list of feature grants configured for the organization.
     */
    featureGrants: Array<FeatureGrant>;
};
/** @internal */
type RewardsListParams$Outbound = {};
/** @internal */
declare const RewardsListParams$outboundSchema: z$1.ZodMiniType<RewardsListParams$Outbound, RewardsListParams>;
declare function rewardsListParamsToJSON(rewardsListParams: RewardsListParams): string;
/** @internal */
declare const CouponType$inboundSchema: z$1.ZodMiniType<CouponType, unknown>;
/** @internal */
declare const DurationType$inboundSchema: z$1.ZodMiniType<DurationType, unknown>;
/** @internal */
declare const ListRewardsDuration$inboundSchema: z$1.ZodMiniType<ListRewardsDuration, unknown>;
declare function listRewardsDurationFromJSON(jsonString: string): Result$1<ListRewardsDuration, SDKValidationError>;
/** @internal */
declare const CouponPromoCode$inboundSchema: z$1.ZodMiniType<CouponPromoCode, unknown>;
declare function couponPromoCodeFromJSON(jsonString: string): Result$1<CouponPromoCode, SDKValidationError>;
/** @internal */
declare const Coupon$inboundSchema: z$1.ZodMiniType<Coupon, unknown>;
declare function couponFromJSON(jsonString: string): Result$1<Coupon, SDKValidationError>;
/** @internal */
declare const ExpiryType$inboundSchema: z$1.ZodMiniType<ExpiryType, unknown>;
/** @internal */
declare const Expiry$inboundSchema: z$1.ZodMiniType<Expiry, unknown>;
declare function expiryFromJSON(jsonString: string): Result$1<Expiry, SDKValidationError>;
/** @internal */
declare const Grant$inboundSchema: z$1.ZodMiniType<Grant, unknown>;
declare function grantFromJSON(jsonString: string): Result$1<Grant, SDKValidationError>;
/** @internal */
declare const FeatureGrantPromoCode$inboundSchema: z$1.ZodMiniType<FeatureGrantPromoCode, unknown>;
declare function featureGrantPromoCodeFromJSON(jsonString: string): Result$1<FeatureGrantPromoCode, SDKValidationError>;
/** @internal */
declare const FeatureGrant$inboundSchema: z$1.ZodMiniType<FeatureGrant, unknown>;
declare function featureGrantFromJSON(jsonString: string): Result$1<FeatureGrant, SDKValidationError>;
/** @internal */
declare const ListRewardsResponse$inboundSchema: z$1.ZodMiniType<ListRewardsResponse, unknown>;
declare function listRewardsResponseFromJSON(jsonString: string): Result$1<ListRewardsResponse, SDKValidationError>;

type MintKeyGlobals = {
    xApiVersion?: string | undefined;
};
type MintKeyParams = {
    /**
     * The customer to mint a token for.
     */
    customerId: string;
    /**
     * If true, mint a non-expiring access token (no refresh token). Revoke via keys.revoke.
     */
    indefinite?: boolean | undefined;
};
/**
 * OK
 */
type MintKeyResponse = {
    /**
     * Access token (1h, or non-expiring if indefinite), prefixed `am_jwt_`.
     */
    accessToken: string;
    /**
     * Rotating refresh token (24h). Omitted for indefinite tokens.
     */
    refreshToken?: string | undefined;
    /**
     * Access-token expiry, ms since epoch. null for indefinite tokens.
     */
    expiresAt: number | null;
    /**
     * Refresh-token expiry, ms since epoch. Omitted for indefinite tokens.
     */
    refreshExpiresAt?: number | undefined;
};
/** @internal */
type MintKeyParams$Outbound = {
    customer_id: string;
    indefinite?: boolean | undefined;
};
/** @internal */
declare const MintKeyParams$outboundSchema: z$1.ZodMiniType<MintKeyParams$Outbound, MintKeyParams>;
declare function mintKeyParamsToJSON(mintKeyParams: MintKeyParams): string;
/** @internal */
declare const MintKeyResponse$inboundSchema: z$1.ZodMiniType<MintKeyResponse, unknown>;
declare function mintKeyResponseFromJSON(jsonString: string): Result$1<MintKeyResponse, SDKValidationError>;

type MultiAttachGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const MultiAttachPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type MultiAttachPriceInterval = ClosedEnum<typeof MultiAttachPriceInterval>;
/**
 * Base price configuration for a plan.
 */
type MultiAttachBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: MultiAttachPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const MultiAttachResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type MultiAttachResetInterval = ClosedEnum<typeof MultiAttachResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type MultiAttachReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: MultiAttachResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type MultiAttachTo = number | string;
type MultiAttachTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const MultiAttachTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type MultiAttachTierBehavior = ClosedEnum<typeof MultiAttachTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const MultiAttachItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type MultiAttachItemPriceInterval = ClosedEnum<typeof MultiAttachItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const MultiAttachBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type MultiAttachBillingMethod = ClosedEnum<typeof MultiAttachBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type MultiAttachPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<MultiAttachTier> | undefined;
    tierBehavior?: MultiAttachTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: MultiAttachItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: MultiAttachBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const MultiAttachOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type MultiAttachOnIncrease = ClosedEnum<typeof MultiAttachOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const MultiAttachOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type MultiAttachOnDecrease = ClosedEnum<typeof MultiAttachOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type MultiAttachProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: MultiAttachOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: MultiAttachOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const MultiAttachExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type MultiAttachExpiryDurationType = ClosedEnum<typeof MultiAttachExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type MultiAttachRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: MultiAttachExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type MultiAttachPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: MultiAttachReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: MultiAttachPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: MultiAttachProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: MultiAttachRollover | undefined;
};
/**
 * Customize the plan to attach. Can override the price or items.
 */
type MultiAttachCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: MultiAttachBasePrice | null | undefined;
    /**
     * Override the items in the plan.
     */
    items?: Array<MultiAttachPlanItem> | undefined;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type MultiAttachFeatureQuantity = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
type MultiAttachPlan = {
    /**
     * The ID of the plan to attach.
     */
    planId: string;
    /**
     * Customize the plan to attach. Can override the price or items.
     */
    customize?: MultiAttachCustomize | undefined;
    /**
     * If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature.
     */
    featureQuantities?: Array<MultiAttachFeatureQuantity> | undefined;
    /**
     * The version of the plan to attach.
     */
    version?: number | undefined;
    /**
     * A unique ID to identify this subscription. Useful when attaching the same plan multiple times.
     */
    subscriptionId?: string | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const MultiAttachDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type MultiAttachDurationType = ClosedEnum<typeof MultiAttachDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const MultiAttachOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type MultiAttachOnEnd = ClosedEnum<typeof MultiAttachOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type MultiAttachFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: MultiAttachDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: MultiAttachOnEnd | undefined;
};
/**
 * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately.
 */
type MultiAttachInvoiceMode = {
    /**
     * When true, creates an invoice and sends it to the customer instead of charging their card immediately. Uses Stripe's send_invoice collection method.
     */
    enabled: boolean;
    /**
     * If true, enables the plan immediately even though the invoice is not paid yet.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * If true, finalizes the invoice so it can be sent to the customer. If false, keeps it as a draft for manual review.
     */
    finalize?: boolean | undefined;
    /**
     * ID of an invoice template (configured in billing settings) whose footer (e.g. bank details) is applied to the invoice.
     */
    invoiceTemplateId?: string | undefined;
    /**
     * Number of days the customer has to pay the invoice before it is due (Stripe days_until_due).
     */
    netTermsDays?: number | undefined;
};
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type MultiAttachAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
declare const MultiAttachRedirectMode: {
    readonly Always: "always";
    readonly IfRequired: "if_required";
    readonly Never: "never";
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
type MultiAttachRedirectMode = ClosedEnum<typeof MultiAttachRedirectMode>;
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const MultiAttachLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type MultiAttachLimitType = ClosedEnum<typeof MultiAttachLimitType>;
type MultiAttachSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: MultiAttachLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const MultiAttachEntityDataInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type MultiAttachEntityDataInterval = ClosedEnum<typeof MultiAttachEntityDataInterval>;
type MultiAttachProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type MultiAttachFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type MultiAttachUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: MultiAttachEntityDataInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: MultiAttachFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const MultiAttachThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type MultiAttachThresholdType = ClosedEnum<typeof MultiAttachThresholdType>;
type MultiAttachUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: MultiAttachThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type MultiAttachOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Billing controls for the entity.
 */
type MultiAttachBillingControls = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<MultiAttachSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<MultiAttachUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<MultiAttachUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<MultiAttachOverageAllowed> | undefined;
};
type MultiAttachEntityData = {
    /**
     * The feature ID that this entity is associated with
     */
    featureId: string;
    /**
     * Name of the entity
     */
    name?: string | undefined;
    /**
     * Billing controls for the entity.
     */
    billingControls?: MultiAttachBillingControls | undefined;
};
type MultiAttachParams = {
    /**
     * The ID of the customer to attach the plans to.
     */
    customerId: string;
    /**
     * The ID of the entity to attach the plans to.
     */
    entityId?: string | undefined;
    /**
     * The list of plans to attach to the customer.
     */
    plans: Array<MultiAttachPlan>;
    /**
     * Free trial configuration applied to all plans. Pass an object to set a custom trial, or null to remove any trial.
     */
    freeTrial?: MultiAttachFreeTrialParams | null | undefined;
    /**
     * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately.
     */
    invoiceMode?: MultiAttachInvoiceMode | undefined;
    /**
     * List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<MultiAttachAttachDiscount> | undefined;
    /**
     * URL to redirect to after successful checkout.
     */
    successUrl?: string | undefined;
    /**
     * Additional parameters to pass into the creation of the Stripe checkout session.
     */
    checkoutSessionParams?: {
        [k: string]: any;
    } | undefined;
    /**
     * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
     */
    redirectMode?: MultiAttachRedirectMode | undefined;
    /**
     * Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one.
     */
    newBillingSubscription?: boolean | undefined;
    /**
     * If true, the cusProducts are activated immediately even when payment is pending via Stripe checkout.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * Customer details to set when creating a customer
     */
    customerData?: CustomerData | undefined;
    entityData?: MultiAttachEntityData | undefined;
};
/**
 * Invoice details if an invoice was created. Only present when a charge was made.
 */
type MultiAttachInvoice = {
    /**
     * The status of the invoice (e.g., 'paid', 'open', 'draft').
     */
    status: string | null;
    /**
     * The Stripe invoice ID.
     */
    stripeId: string;
    /**
     * The total amount of the invoice in cents.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * URL to the hosted invoice page where the customer can view and pay the invoice.
     */
    hostedInvoiceUrl: string | null;
};
/**
 * The type of action required to complete the payment.
 */
declare const MultiAttachCode: {
    readonly ThreedsRequired: "3ds_required";
    readonly PaymentMethodRequired: "payment_method_required";
    readonly PaymentFailed: "payment_failed";
    readonly PaymentProcessing: "payment_processing";
};
/**
 * The type of action required to complete the payment.
 */
type MultiAttachCode = OpenEnum<typeof MultiAttachCode>;
/**
 * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
 */
type MultiAttachRequiredAction = {
    /**
     * The type of action required to complete the payment.
     */
    code: MultiAttachCode;
    /**
     * A human-readable explanation of why this action is required.
     */
    reason: string;
};
/**
 * OK
 */
type MultiAttachResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the entity, if the plan was attached to an entity.
     */
    entityId?: string | undefined;
    /**
     * Invoice details if an invoice was created. Only present when a charge was made.
     */
    invoice?: MultiAttachInvoice | undefined;
    /**
     * URL to redirect the customer to complete payment. Null if no payment action is required.
     */
    paymentUrl: string | null;
    /**
     * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
     */
    requiredAction?: MultiAttachRequiredAction | undefined;
};
/** @internal */
declare const MultiAttachPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachPriceInterval>;
/** @internal */
type MultiAttachBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const MultiAttachBasePrice$outboundSchema: z$1.ZodMiniType<MultiAttachBasePrice$Outbound, MultiAttachBasePrice>;
declare function multiAttachBasePriceToJSON(multiAttachBasePrice: MultiAttachBasePrice): string;
/** @internal */
declare const MultiAttachResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachResetInterval>;
/** @internal */
type MultiAttachReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const MultiAttachReset$outboundSchema: z$1.ZodMiniType<MultiAttachReset$Outbound, MultiAttachReset>;
declare function multiAttachResetToJSON(multiAttachReset: MultiAttachReset): string;
/** @internal */
type MultiAttachTo$Outbound = number | string;
/** @internal */
declare const MultiAttachTo$outboundSchema: z$1.ZodMiniType<MultiAttachTo$Outbound, MultiAttachTo>;
declare function multiAttachToToJSON(multiAttachTo: MultiAttachTo): string;
/** @internal */
type MultiAttachTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const MultiAttachTier$outboundSchema: z$1.ZodMiniType<MultiAttachTier$Outbound, MultiAttachTier>;
declare function multiAttachTierToJSON(multiAttachTier: MultiAttachTier): string;
/** @internal */
declare const MultiAttachTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachTierBehavior>;
/** @internal */
declare const MultiAttachItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachItemPriceInterval>;
/** @internal */
declare const MultiAttachBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachBillingMethod>;
/** @internal */
type MultiAttachPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<MultiAttachTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const MultiAttachPrice$outboundSchema: z$1.ZodMiniType<MultiAttachPrice$Outbound, MultiAttachPrice>;
declare function multiAttachPriceToJSON(multiAttachPrice: MultiAttachPrice): string;
/** @internal */
declare const MultiAttachOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachOnIncrease>;
/** @internal */
declare const MultiAttachOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachOnDecrease>;
/** @internal */
type MultiAttachProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const MultiAttachProration$outboundSchema: z$1.ZodMiniType<MultiAttachProration$Outbound, MultiAttachProration>;
declare function multiAttachProrationToJSON(multiAttachProration: MultiAttachProration): string;
/** @internal */
declare const MultiAttachExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachExpiryDurationType>;
/** @internal */
type MultiAttachRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const MultiAttachRollover$outboundSchema: z$1.ZodMiniType<MultiAttachRollover$Outbound, MultiAttachRollover>;
declare function multiAttachRolloverToJSON(multiAttachRollover: MultiAttachRollover): string;
/** @internal */
type MultiAttachPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: MultiAttachReset$Outbound | undefined;
    price?: MultiAttachPrice$Outbound | undefined;
    proration?: MultiAttachProration$Outbound | undefined;
    rollover?: MultiAttachRollover$Outbound | undefined;
};
/** @internal */
declare const MultiAttachPlanItem$outboundSchema: z$1.ZodMiniType<MultiAttachPlanItem$Outbound, MultiAttachPlanItem>;
declare function multiAttachPlanItemToJSON(multiAttachPlanItem: MultiAttachPlanItem): string;
/** @internal */
type MultiAttachCustomize$Outbound = {
    price?: MultiAttachBasePrice$Outbound | null | undefined;
    items?: Array<MultiAttachPlanItem$Outbound> | undefined;
};
/** @internal */
declare const MultiAttachCustomize$outboundSchema: z$1.ZodMiniType<MultiAttachCustomize$Outbound, MultiAttachCustomize>;
declare function multiAttachCustomizeToJSON(multiAttachCustomize: MultiAttachCustomize): string;
/** @internal */
type MultiAttachFeatureQuantity$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const MultiAttachFeatureQuantity$outboundSchema: z$1.ZodMiniType<MultiAttachFeatureQuantity$Outbound, MultiAttachFeatureQuantity>;
declare function multiAttachFeatureQuantityToJSON(multiAttachFeatureQuantity: MultiAttachFeatureQuantity): string;
/** @internal */
type MultiAttachPlan$Outbound = {
    plan_id: string;
    customize?: MultiAttachCustomize$Outbound | undefined;
    feature_quantities?: Array<MultiAttachFeatureQuantity$Outbound> | undefined;
    version?: number | undefined;
    subscription_id?: string | undefined;
};
/** @internal */
declare const MultiAttachPlan$outboundSchema: z$1.ZodMiniType<MultiAttachPlan$Outbound, MultiAttachPlan>;
declare function multiAttachPlanToJSON(multiAttachPlan: MultiAttachPlan): string;
/** @internal */
declare const MultiAttachDurationType$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachDurationType>;
/** @internal */
declare const MultiAttachOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachOnEnd>;
/** @internal */
type MultiAttachFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const MultiAttachFreeTrialParams$outboundSchema: z$1.ZodMiniType<MultiAttachFreeTrialParams$Outbound, MultiAttachFreeTrialParams>;
declare function multiAttachFreeTrialParamsToJSON(multiAttachFreeTrialParams: MultiAttachFreeTrialParams): string;
/** @internal */
type MultiAttachInvoiceMode$Outbound = {
    enabled: boolean;
    enable_plan_immediately: boolean;
    finalize: boolean;
    invoice_template_id?: string | undefined;
    net_terms_days?: number | undefined;
};
/** @internal */
declare const MultiAttachInvoiceMode$outboundSchema: z$1.ZodMiniType<MultiAttachInvoiceMode$Outbound, MultiAttachInvoiceMode>;
declare function multiAttachInvoiceModeToJSON(multiAttachInvoiceMode: MultiAttachInvoiceMode): string;
/** @internal */
type MultiAttachAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const MultiAttachAttachDiscount$outboundSchema: z$1.ZodMiniType<MultiAttachAttachDiscount$Outbound, MultiAttachAttachDiscount>;
declare function multiAttachAttachDiscountToJSON(multiAttachAttachDiscount: MultiAttachAttachDiscount): string;
/** @internal */
declare const MultiAttachRedirectMode$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachRedirectMode>;
/** @internal */
declare const MultiAttachLimitType$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachLimitType>;
/** @internal */
type MultiAttachSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const MultiAttachSpendLimit$outboundSchema: z$1.ZodMiniType<MultiAttachSpendLimit$Outbound, MultiAttachSpendLimit>;
declare function multiAttachSpendLimitToJSON(multiAttachSpendLimit: MultiAttachSpendLimit): string;
/** @internal */
declare const MultiAttachEntityDataInterval$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachEntityDataInterval>;
/** @internal */
type MultiAttachProperties$Outbound = string | number | boolean;
/** @internal */
declare const MultiAttachProperties$outboundSchema: z$1.ZodMiniType<MultiAttachProperties$Outbound, MultiAttachProperties>;
declare function multiAttachPropertiesToJSON(multiAttachProperties: MultiAttachProperties): string;
/** @internal */
type MultiAttachFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const MultiAttachFilter$outboundSchema: z$1.ZodMiniType<MultiAttachFilter$Outbound, MultiAttachFilter>;
declare function multiAttachFilterToJSON(multiAttachFilter: MultiAttachFilter): string;
/** @internal */
type MultiAttachUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: MultiAttachFilter$Outbound | undefined;
};
/** @internal */
declare const MultiAttachUsageLimit$outboundSchema: z$1.ZodMiniType<MultiAttachUsageLimit$Outbound, MultiAttachUsageLimit>;
declare function multiAttachUsageLimitToJSON(multiAttachUsageLimit: MultiAttachUsageLimit): string;
/** @internal */
declare const MultiAttachThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof MultiAttachThresholdType>;
/** @internal */
type MultiAttachUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const MultiAttachUsageAlert$outboundSchema: z$1.ZodMiniType<MultiAttachUsageAlert$Outbound, MultiAttachUsageAlert>;
declare function multiAttachUsageAlertToJSON(multiAttachUsageAlert: MultiAttachUsageAlert): string;
/** @internal */
type MultiAttachOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const MultiAttachOverageAllowed$outboundSchema: z$1.ZodMiniType<MultiAttachOverageAllowed$Outbound, MultiAttachOverageAllowed>;
declare function multiAttachOverageAllowedToJSON(multiAttachOverageAllowed: MultiAttachOverageAllowed): string;
/** @internal */
type MultiAttachBillingControls$Outbound = {
    spend_limits?: Array<MultiAttachSpendLimit$Outbound> | undefined;
    usage_limits?: Array<MultiAttachUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<MultiAttachUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<MultiAttachOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const MultiAttachBillingControls$outboundSchema: z$1.ZodMiniType<MultiAttachBillingControls$Outbound, MultiAttachBillingControls>;
declare function multiAttachBillingControlsToJSON(multiAttachBillingControls: MultiAttachBillingControls): string;
/** @internal */
type MultiAttachEntityData$Outbound = {
    feature_id: string;
    name?: string | undefined;
    billing_controls?: MultiAttachBillingControls$Outbound | undefined;
};
/** @internal */
declare const MultiAttachEntityData$outboundSchema: z$1.ZodMiniType<MultiAttachEntityData$Outbound, MultiAttachEntityData>;
declare function multiAttachEntityDataToJSON(multiAttachEntityData: MultiAttachEntityData): string;
/** @internal */
type MultiAttachParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    plans: Array<MultiAttachPlan$Outbound>;
    free_trial?: MultiAttachFreeTrialParams$Outbound | null | undefined;
    invoice_mode?: MultiAttachInvoiceMode$Outbound | undefined;
    discounts?: Array<MultiAttachAttachDiscount$Outbound> | undefined;
    success_url?: string | undefined;
    checkout_session_params?: {
        [k: string]: any;
    } | undefined;
    redirect_mode: string;
    new_billing_subscription?: boolean | undefined;
    enable_plan_immediately?: boolean | undefined;
    customer_data?: CustomerData$Outbound | undefined;
    entity_data?: MultiAttachEntityData$Outbound | undefined;
};
/** @internal */
declare const MultiAttachParams$outboundSchema: z$1.ZodMiniType<MultiAttachParams$Outbound, MultiAttachParams>;
declare function multiAttachParamsToJSON(multiAttachParams: MultiAttachParams): string;
/** @internal */
declare const MultiAttachInvoice$inboundSchema: z$1.ZodMiniType<MultiAttachInvoice, unknown>;
declare function multiAttachInvoiceFromJSON(jsonString: string): Result$1<MultiAttachInvoice, SDKValidationError>;
/** @internal */
declare const MultiAttachCode$inboundSchema: z$1.ZodMiniType<MultiAttachCode, unknown>;
/** @internal */
declare const MultiAttachRequiredAction$inboundSchema: z$1.ZodMiniType<MultiAttachRequiredAction, unknown>;
declare function multiAttachRequiredActionFromJSON(jsonString: string): Result$1<MultiAttachRequiredAction, SDKValidationError>;
/** @internal */
declare const MultiAttachResponse$inboundSchema: z$1.ZodMiniType<MultiAttachResponse, unknown>;
declare function multiAttachResponseFromJSON(jsonString: string): Result$1<MultiAttachResponse, SDKValidationError>;

type MultiUpdateGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
declare const MultiUpdateCancelAction: {
    readonly CancelImmediately: "cancel_immediately";
    readonly CancelEndOfCycle: "cancel_end_of_cycle";
    readonly Uncancel: "uncancel";
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
type MultiUpdateCancelAction = ClosedEnum<typeof MultiUpdateCancelAction>;
/**
 * How to handle proration for this update. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
declare const MultiUpdateProrationBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * How to handle proration for this update. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
type MultiUpdateProrationBehavior = ClosedEnum<typeof MultiUpdateProrationBehavior>;
type MultiUpdateUpdate = {
    /**
     * The ID of the plan to update. Optional if subscription_id is provided.
     */
    planId?: string | undefined;
    /**
     * A unique ID to identify the subscription to update. Useful when a customer has multiple products with the same plan.
     */
    subscriptionId?: string | undefined;
    /**
     * The ID of the entity this update targets. Overrides the top-level entity_id for this update.
     */
    entityId?: string | undefined;
    /**
     * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
     */
    cancelAction: MultiUpdateCancelAction;
    /**
     * How to handle proration for this update. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
     */
    prorationBehavior?: MultiUpdateProrationBehavior | undefined;
};
type MultiUpdateParams = {
    /**
     * The ID of the customer to update plans for.
     */
    customerId: string;
    /**
     * The ID of the entity to update plans for. Individual updates can override this with their own entity_id.
     */
    entityId?: string | undefined;
    /**
     * The list of plan updates to apply to the customer.
     */
    updates: Array<MultiUpdateUpdate>;
};
/**
 * Invoice details if an invoice was created. Only present when a charge was made.
 */
type MultiUpdateInvoice = {
    /**
     * The status of the invoice (e.g., 'paid', 'open', 'draft').
     */
    status: string | null;
    /**
     * The Stripe invoice ID.
     */
    stripeId: string;
    /**
     * The total amount of the invoice in cents.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * URL to the hosted invoice page where the customer can view and pay the invoice.
     */
    hostedInvoiceUrl: string | null;
};
/**
 * The type of action required to complete the payment.
 */
declare const MultiUpdateCode: {
    readonly ThreedsRequired: "3ds_required";
    readonly PaymentMethodRequired: "payment_method_required";
    readonly PaymentFailed: "payment_failed";
    readonly PaymentProcessing: "payment_processing";
};
/**
 * The type of action required to complete the payment.
 */
type MultiUpdateCode = OpenEnum<typeof MultiUpdateCode>;
/**
 * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
 */
type MultiUpdateRequiredAction = {
    /**
     * The type of action required to complete the payment.
     */
    code: MultiUpdateCode;
    /**
     * A human-readable explanation of why this action is required.
     */
    reason: string;
};
/**
 * OK
 */
type MultiUpdateResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the entity, if the plan was attached to an entity.
     */
    entityId?: string | undefined;
    /**
     * Invoice details if an invoice was created. Only present when a charge was made.
     */
    invoice?: MultiUpdateInvoice | undefined;
    /**
     * URL to redirect the customer to complete payment. Null if no payment action is required.
     */
    paymentUrl: string | null;
    /**
     * Details about any action required to complete the payment. Present when the payment could not be processed automatically.
     */
    requiredAction?: MultiUpdateRequiredAction | undefined;
};
/** @internal */
declare const MultiUpdateCancelAction$outboundSchema: z$1.ZodMiniEnum<typeof MultiUpdateCancelAction>;
/** @internal */
declare const MultiUpdateProrationBehavior$outboundSchema: z$1.ZodMiniEnum<typeof MultiUpdateProrationBehavior>;
/** @internal */
type MultiUpdateUpdate$Outbound = {
    plan_id?: string | undefined;
    subscription_id?: string | undefined;
    entity_id?: string | undefined;
    cancel_action: string;
    proration_behavior?: string | undefined;
};
/** @internal */
declare const MultiUpdateUpdate$outboundSchema: z$1.ZodMiniType<MultiUpdateUpdate$Outbound, MultiUpdateUpdate>;
declare function multiUpdateUpdateToJSON(multiUpdateUpdate: MultiUpdateUpdate): string;
/** @internal */
type MultiUpdateParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    updates: Array<MultiUpdateUpdate$Outbound>;
};
/** @internal */
declare const MultiUpdateParams$outboundSchema: z$1.ZodMiniType<MultiUpdateParams$Outbound, MultiUpdateParams>;
declare function multiUpdateParamsToJSON(multiUpdateParams: MultiUpdateParams): string;
/** @internal */
declare const MultiUpdateInvoice$inboundSchema: z$1.ZodMiniType<MultiUpdateInvoice, unknown>;
declare function multiUpdateInvoiceFromJSON(jsonString: string): Result$1<MultiUpdateInvoice, SDKValidationError>;
/** @internal */
declare const MultiUpdateCode$inboundSchema: z$1.ZodMiniType<MultiUpdateCode, unknown>;
/** @internal */
declare const MultiUpdateRequiredAction$inboundSchema: z$1.ZodMiniType<MultiUpdateRequiredAction, unknown>;
declare function multiUpdateRequiredActionFromJSON(jsonString: string): Result$1<MultiUpdateRequiredAction, SDKValidationError>;
/** @internal */
declare const MultiUpdateResponse$inboundSchema: z$1.ZodMiniType<MultiUpdateResponse, unknown>;
declare function multiUpdateResponseFromJSON(jsonString: string): Result$1<MultiUpdateResponse, SDKValidationError>;

type OpenCustomerPortalGlobals = {
    xApiVersion?: string | undefined;
};
type OpenCustomerPortalParams = {
    /**
     * The ID of the customer to open the billing portal for.
     */
    customerId: string;
    /**
     * Stripe billing portal configuration ID. Create configurations in your Stripe dashboard.
     */
    configurationId?: string | undefined;
    /**
     * URL to redirect to when back button is clicked in the billing portal
     */
    returnUrl?: string | undefined;
};
/**
 * OK
 */
type OpenCustomerPortalResponse = {
    /**
     * The ID of the billing portal session
     */
    customerId: string;
    /**
     * URL to the billing portal
     */
    url: string;
};
/** @internal */
type OpenCustomerPortalParams$Outbound = {
    customer_id: string;
    configuration_id?: string | undefined;
    return_url?: string | undefined;
};
/** @internal */
declare const OpenCustomerPortalParams$outboundSchema: z$1.ZodMiniType<OpenCustomerPortalParams$Outbound, OpenCustomerPortalParams>;
declare function openCustomerPortalParamsToJSON(openCustomerPortalParams: OpenCustomerPortalParams): string;
/** @internal */
declare const OpenCustomerPortalResponse$inboundSchema: z$1.ZodMiniType<OpenCustomerPortalResponse, unknown>;
declare function openCustomerPortalResponseFromJSON(jsonString: string): Result$1<OpenCustomerPortalResponse, SDKValidationError>;

type PreviewAttachGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type PreviewAttachFeatureQuantityRequest = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const PreviewAttachPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type PreviewAttachPriceInterval = ClosedEnum<typeof PreviewAttachPriceInterval>;
/**
 * Base price configuration for a plan.
 */
type PreviewAttachBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: PreviewAttachPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const PreviewAttachItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type PreviewAttachItemResetInterval = ClosedEnum<typeof PreviewAttachItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type PreviewAttachItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: PreviewAttachItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type PreviewAttachItemTo = number | string;
type PreviewAttachItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const PreviewAttachItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type PreviewAttachItemTierBehavior = ClosedEnum<typeof PreviewAttachItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const PreviewAttachItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type PreviewAttachItemPriceInterval = ClosedEnum<typeof PreviewAttachItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const PreviewAttachItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type PreviewAttachItemBillingMethod = ClosedEnum<typeof PreviewAttachItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type PreviewAttachItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<PreviewAttachItemTier> | undefined;
    tierBehavior?: PreviewAttachItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: PreviewAttachItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: PreviewAttachItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const PreviewAttachItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type PreviewAttachItemOnIncrease = ClosedEnum<typeof PreviewAttachItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const PreviewAttachItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type PreviewAttachItemOnDecrease = ClosedEnum<typeof PreviewAttachItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type PreviewAttachItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: PreviewAttachItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: PreviewAttachItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const PreviewAttachItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type PreviewAttachItemExpiryDurationType = ClosedEnum<typeof PreviewAttachItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type PreviewAttachItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: PreviewAttachItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type PreviewAttachItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: PreviewAttachItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: PreviewAttachItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: PreviewAttachItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: PreviewAttachItemRollover | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const PreviewAttachAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type PreviewAttachAddItemResetInterval = ClosedEnum<typeof PreviewAttachAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type PreviewAttachAddItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: PreviewAttachAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type PreviewAttachAddItemTo = number | string;
type PreviewAttachAddItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const PreviewAttachAddItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type PreviewAttachAddItemTierBehavior = ClosedEnum<typeof PreviewAttachAddItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const PreviewAttachAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type PreviewAttachAddItemPriceInterval = ClosedEnum<typeof PreviewAttachAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const PreviewAttachAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type PreviewAttachAddItemBillingMethod = ClosedEnum<typeof PreviewAttachAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type PreviewAttachAddItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<PreviewAttachAddItemTier> | undefined;
    tierBehavior?: PreviewAttachAddItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: PreviewAttachAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: PreviewAttachAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const PreviewAttachAddItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type PreviewAttachAddItemOnIncrease = ClosedEnum<typeof PreviewAttachAddItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const PreviewAttachAddItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type PreviewAttachAddItemOnDecrease = ClosedEnum<typeof PreviewAttachAddItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type PreviewAttachAddItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: PreviewAttachAddItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: PreviewAttachAddItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const PreviewAttachAddItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type PreviewAttachAddItemExpiryDurationType = ClosedEnum<typeof PreviewAttachAddItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type PreviewAttachAddItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: PreviewAttachAddItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type PreviewAttachAddItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: PreviewAttachAddItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: PreviewAttachAddItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: PreviewAttachAddItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: PreviewAttachAddItemRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const PreviewAttachRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type PreviewAttachRemoveItemBillingMethod = ClosedEnum<typeof PreviewAttachRemoveItemBillingMethod>;
declare const PreviewAttachIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type PreviewAttachIntervalRemoveItemEnum2 = ClosedEnum<typeof PreviewAttachIntervalRemoveItemEnum2>;
declare const PreviewAttachIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type PreviewAttachIntervalRemoveItemEnum1 = ClosedEnum<typeof PreviewAttachIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type PreviewAttachIntervalUnion = PreviewAttachIntervalRemoveItemEnum1 | PreviewAttachIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type PreviewAttachPlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: PreviewAttachRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: PreviewAttachIntervalRemoveItemEnum1 | PreviewAttachIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const PreviewAttachDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type PreviewAttachDurationType = ClosedEnum<typeof PreviewAttachDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const PreviewAttachOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type PreviewAttachOnEnd = ClosedEnum<typeof PreviewAttachOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type PreviewAttachFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: PreviewAttachDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: PreviewAttachOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const PreviewAttachPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type PreviewAttachPurchaseLimitInterval = ClosedEnum<typeof PreviewAttachPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type PreviewAttachPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: PreviewAttachPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type PreviewAttachAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: PreviewAttachPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const PreviewAttachLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type PreviewAttachLimitType = ClosedEnum<typeof PreviewAttachLimitType>;
type PreviewAttachSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: PreviewAttachLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const PreviewAttachUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type PreviewAttachUsageLimitInterval = ClosedEnum<typeof PreviewAttachUsageLimitInterval>;
type PreviewAttachProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type PreviewAttachFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type PreviewAttachUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: PreviewAttachUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: PreviewAttachFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const PreviewAttachThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type PreviewAttachThresholdType = ClosedEnum<typeof PreviewAttachThresholdType>;
type PreviewAttachUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: PreviewAttachThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type PreviewAttachOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type PreviewAttachBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<PreviewAttachAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<PreviewAttachSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<PreviewAttachUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<PreviewAttachUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<PreviewAttachOverageAllowed> | undefined;
};
/**
 * Customize the plan to attach. Can override the price, items, free trial, or a combination.
 */
type PreviewAttachCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: PreviewAttachBasePrice | null | undefined;
    /**
     * Override the items in the plan (PUT-style — replaces all existing items). Mutually exclusive with add_items / remove_items / deprecated update_items.
     */
    items?: Array<PreviewAttachItemPlanItem> | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<PreviewAttachAddItemPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<PreviewAttachPlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: PreviewAttachFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: PreviewAttachBillingControls | undefined;
};
/**
 * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
 */
type PreviewAttachInvoiceMode = {
    /**
     * When true, creates an invoice and sends it to the customer instead of charging their card immediately. Uses Stripe's send_invoice collection method.
     */
    enabled: boolean;
    /**
     * If true, enables the plan immediately even though the invoice is not paid yet.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * If true, finalizes the invoice so it can be sent to the customer. If false, keeps it as a draft for manual review.
     */
    finalize?: boolean | undefined;
    /**
     * ID of an invoice template (configured in billing settings) whose footer (e.g. bank details) is applied to the invoice.
     */
    invoiceTemplateId?: string | undefined;
    /**
     * Number of days the customer has to pay the invoice before it is due (Stripe days_until_due).
     */
    netTermsDays?: number | undefined;
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
declare const PreviewAttachProrationBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
type PreviewAttachProrationBehavior = ClosedEnum<typeof PreviewAttachProrationBehavior>;
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
declare const PreviewAttachRedirectMode: {
    readonly Always: "always";
    readonly IfRequired: "if_required";
    readonly Never: "never";
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
type PreviewAttachRedirectMode = ClosedEnum<typeof PreviewAttachRedirectMode>;
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type PreviewAttachAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
/**
 * When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled.
 */
declare const PreviewAttachPlanSchedule: {
    readonly Immediate: "immediate";
    readonly EndOfCycle: "end_of_cycle";
};
/**
 * When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled.
 */
type PreviewAttachPlanSchedule = ClosedEnum<typeof PreviewAttachPlanSchedule>;
type PreviewAttachCustomLineItem = {
    /**
     * Amount in dollars for this line item (e.g. 10.50). Can be negative for credits.
     */
    amount: number;
    /**
     * Description for the line item.
     */
    description: string;
};
/**
 * Whether to carry over balances from the previous plan.
 */
type PreviewAttachCarryOverBalances = {
    /**
     * Whether to carry over balances from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over balances from. If left undefined, all features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
/**
 * Whether to carry over usages from the previous plan.
 */
type PreviewAttachCarryOverUsages = {
    /**
     * Whether to carry over usages from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over usages for. If left undefined, all consumable features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
type PreviewAttachParams = {
    /**
     * The ID of the customer to attach the plan to.
     */
    customerId: string;
    /**
     * The ID of the entity to attach the plan to.
     */
    entityId?: string | undefined;
    /**
     * The ID of the plan.
     */
    planId: string;
    /**
     * If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan.
     */
    featureQuantities?: Array<PreviewAttachFeatureQuantityRequest> | undefined;
    /**
     * The version of the plan to attach.
     */
    version?: number | undefined;
    /**
     * Customize the plan to attach. Can override the price, items, free trial, or a combination.
     */
    customize?: PreviewAttachCustomize | undefined;
    /**
     * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
     */
    invoiceMode?: PreviewAttachInvoiceMode | undefined;
    /**
     * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
     */
    prorationBehavior?: PreviewAttachProrationBehavior | undefined;
    /**
     * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
     */
    redirectMode?: PreviewAttachRedirectMode | undefined;
    /**
     * A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan.
     */
    subscriptionId?: string | undefined;
    /**
     * List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<PreviewAttachAttachDiscount> | undefined;
    /**
     * URL to redirect to after successful checkout.
     */
    successUrl?: string | undefined;
    /**
     * Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one.
     */
    newBillingSubscription?: boolean | undefined;
    /**
     * Reset the billing cycle anchor immediately with 'now'.
     */
    billingCycleAnchor?: "now" | undefined;
    /**
     * When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled.
     */
    planSchedule?: PreviewAttachPlanSchedule | undefined;
    /**
     * Unix timestamp in milliseconds for when the attached plan should start. Future dates create a scheduled subscription.
     */
    startsAt?: number | undefined;
    /**
     * Unix timestamp in milliseconds for when the attached plan should end.
     */
    endsAt?: number | undefined;
    /**
     * Additional parameters to pass into the creation of the Stripe checkout session.
     */
    checkoutSessionParams?: {
        [k: string]: any;
    } | undefined;
    /**
     * If true, returns an Autumn-hosted checkout link that can create a fresh Stripe checkout session when opened.
     */
    longLivedCheckout?: boolean | undefined;
    /**
     * Custom line items that override the auto-generated proration invoice. Only valid for immediate plan changes (eg. upgrades or one off plans).
     */
    customLineItems?: Array<PreviewAttachCustomLineItem> | undefined;
    /**
     * The processor subscription ID to link. Use this to attach an existing Stripe subscription instead of creating a new one.
     */
    processorSubscriptionId?: string | undefined;
    /**
     * Whether to carry over balances from the previous plan.
     */
    carryOverBalances?: PreviewAttachCarryOverBalances | undefined;
    /**
     * Whether to carry over usages from the previous plan.
     */
    carryOverUsages?: PreviewAttachCarryOverUsages | undefined;
    /**
     * Key-value metadata to attach to the Stripe subscription, invoice, and checkout session created during this attach flow. Keys prefixed with 'autumn_' are reserved and will be stripped.
     */
    metadata?: {
        [k: string]: string;
    } | undefined;
    /**
     * If true, skips any billing changes for the attach operation.
     */
    noBillingChanges?: boolean | undefined;
    /**
     * If true, the customer's plan is activated immediately even when payment is deferred (invoice mode) or pending (Stripe checkout). For Stripe checkout, the customer_product is inserted before the customer completes the hosted form.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * Stripe tax rate ID (txr_...) to apply as the default tax rate on the created subscription, invoice, or checkout session line items.
     */
    taxRateId?: string | undefined;
};
type PreviewAttachDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewAttachLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewAttachLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewAttachDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewAttachLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
type PreviewAttachNextCycleDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewAttachNextCycleLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewAttachNextCycleLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewAttachNextCycleDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewAttachNextCycleLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewAttachUsageLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewAttachUsageLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewAttachUsageLineItemPeriod | undefined;
};
/**
 * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
 */
type PreviewAttachNextCycle = {
    /**
     * Unix timestamp (milliseconds) when the next billing cycle starts.
     */
    startsAt: number;
    /**
     * The total amount in cents before discounts and tax for the next cycle.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the next cycle.
     */
    total: number;
    /**
     * List of line items for the next billing cycle.
     */
    lineItems: Array<PreviewAttachNextCycleLineItem>;
    /**
     * List of line items for usage-based features in the next cycle.
     */
    usageLineItems: Array<PreviewAttachUsageLineItem>;
};
type PreviewAttachIncomingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewAttachIncoming = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewAttachIncomingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
type PreviewAttachOutgoingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewAttachOutgoing = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewAttachOutgoingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
declare const PreviewAttachCheckoutType: {
    readonly StripeCheckout: "stripe_checkout";
    readonly AutumnCheckout: "autumn_checkout";
};
type PreviewAttachCheckoutType = OpenEnum<typeof PreviewAttachCheckoutType>;
/**
 * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
 */
declare const PreviewAttachStatus: {
    readonly Complete: "complete";
    readonly Incomplete: "incomplete";
};
/**
 * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
 */
type PreviewAttachStatus = OpenEnum<typeof PreviewAttachStatus>;
/**
 * Tax preview for the immediate charge. Contact us to enable the tax flag on your organisation. Shows only with flag enabled, a Stripe customer exists and has a location.
 */
type PreviewAttachTax = {
    /**
     * Total tax amount in major currency units.
     */
    total: number;
    /**
     * Tax included in line item subtotals.
     */
    amountInclusive: number;
    /**
     * Tax added on top of subtotals.
     */
    amountExclusive: number;
    /**
     * Three-letter currency code.
     */
    currency: string;
    /**
     * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
     */
    status: PreviewAttachStatus;
};
/**
 * Stripe customer invoice credits preview.
 */
type PreviewAttachInvoiceCredits = {
    /**
     * Stripe customer credit balance available, expressed as a positive number in major currency units.
     */
    balance: number;
    /**
     * Three-letter currency code.
     */
    currency: string;
};
/**
 * OK
 */
type PreviewAttachResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    lineItems: Array<PreviewAttachLineItem>;
    /**
     * The total amount in cents before discounts and tax for the current billing period.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the current billing period.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
     */
    nextCycle?: PreviewAttachNextCycle | undefined;
    /**
     * Expand the response with additional data.
     */
    expand?: Array<string> | undefined;
    /**
     * Products or subscription changes being added or updated.
     */
    incoming: Array<PreviewAttachIncoming>;
    /**
     * Products or subscription changes being removed or ended.
     */
    outgoing: Array<PreviewAttachOutgoing>;
    /**
     * Whether the customer will be redirected to a checkout page if attach is called.
     */
    redirectToCheckout: boolean;
    /**
     * The type of checkout that will be used if the customer is redirected to a checkout page.
     */
    checkoutType: PreviewAttachCheckoutType | null;
    /**
     * Tax preview for the immediate charge. Contact us to enable the tax flag on your organisation. Shows only with flag enabled, a Stripe customer exists and has a location.
     */
    tax?: PreviewAttachTax | undefined;
    /**
     * Stripe customer invoice credits preview.
     */
    invoiceCredits?: PreviewAttachInvoiceCredits | undefined;
};
/** @internal */
type PreviewAttachFeatureQuantityRequest$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const PreviewAttachFeatureQuantityRequest$outboundSchema: z$1.ZodMiniType<PreviewAttachFeatureQuantityRequest$Outbound, PreviewAttachFeatureQuantityRequest>;
declare function previewAttachFeatureQuantityRequestToJSON(previewAttachFeatureQuantityRequest: PreviewAttachFeatureQuantityRequest): string;
/** @internal */
declare const PreviewAttachPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachPriceInterval>;
/** @internal */
type PreviewAttachBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewAttachBasePrice$outboundSchema: z$1.ZodMiniType<PreviewAttachBasePrice$Outbound, PreviewAttachBasePrice>;
declare function previewAttachBasePriceToJSON(previewAttachBasePrice: PreviewAttachBasePrice): string;
/** @internal */
declare const PreviewAttachItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachItemResetInterval>;
/** @internal */
type PreviewAttachItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewAttachItemReset$outboundSchema: z$1.ZodMiniType<PreviewAttachItemReset$Outbound, PreviewAttachItemReset>;
declare function previewAttachItemResetToJSON(previewAttachItemReset: PreviewAttachItemReset): string;
/** @internal */
type PreviewAttachItemTo$Outbound = number | string;
/** @internal */
declare const PreviewAttachItemTo$outboundSchema: z$1.ZodMiniType<PreviewAttachItemTo$Outbound, PreviewAttachItemTo>;
declare function previewAttachItemToToJSON(previewAttachItemTo: PreviewAttachItemTo): string;
/** @internal */
type PreviewAttachItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const PreviewAttachItemTier$outboundSchema: z$1.ZodMiniType<PreviewAttachItemTier$Outbound, PreviewAttachItemTier>;
declare function previewAttachItemTierToJSON(previewAttachItemTier: PreviewAttachItemTier): string;
/** @internal */
declare const PreviewAttachItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachItemTierBehavior>;
/** @internal */
declare const PreviewAttachItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachItemPriceInterval>;
/** @internal */
declare const PreviewAttachItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachItemBillingMethod>;
/** @internal */
type PreviewAttachItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<PreviewAttachItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const PreviewAttachItemPrice$outboundSchema: z$1.ZodMiniType<PreviewAttachItemPrice$Outbound, PreviewAttachItemPrice>;
declare function previewAttachItemPriceToJSON(previewAttachItemPrice: PreviewAttachItemPrice): string;
/** @internal */
declare const PreviewAttachItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachItemOnIncrease>;
/** @internal */
declare const PreviewAttachItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachItemOnDecrease>;
/** @internal */
type PreviewAttachItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const PreviewAttachItemProration$outboundSchema: z$1.ZodMiniType<PreviewAttachItemProration$Outbound, PreviewAttachItemProration>;
declare function previewAttachItemProrationToJSON(previewAttachItemProration: PreviewAttachItemProration): string;
/** @internal */
declare const PreviewAttachItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachItemExpiryDurationType>;
/** @internal */
type PreviewAttachItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const PreviewAttachItemRollover$outboundSchema: z$1.ZodMiniType<PreviewAttachItemRollover$Outbound, PreviewAttachItemRollover>;
declare function previewAttachItemRolloverToJSON(previewAttachItemRollover: PreviewAttachItemRollover): string;
/** @internal */
type PreviewAttachItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: PreviewAttachItemReset$Outbound | undefined;
    price?: PreviewAttachItemPrice$Outbound | undefined;
    proration?: PreviewAttachItemProration$Outbound | undefined;
    rollover?: PreviewAttachItemRollover$Outbound | undefined;
};
/** @internal */
declare const PreviewAttachItemPlanItem$outboundSchema: z$1.ZodMiniType<PreviewAttachItemPlanItem$Outbound, PreviewAttachItemPlanItem>;
declare function previewAttachItemPlanItemToJSON(previewAttachItemPlanItem: PreviewAttachItemPlanItem): string;
/** @internal */
declare const PreviewAttachAddItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachAddItemResetInterval>;
/** @internal */
type PreviewAttachAddItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewAttachAddItemReset$outboundSchema: z$1.ZodMiniType<PreviewAttachAddItemReset$Outbound, PreviewAttachAddItemReset>;
declare function previewAttachAddItemResetToJSON(previewAttachAddItemReset: PreviewAttachAddItemReset): string;
/** @internal */
type PreviewAttachAddItemTo$Outbound = number | string;
/** @internal */
declare const PreviewAttachAddItemTo$outboundSchema: z$1.ZodMiniType<PreviewAttachAddItemTo$Outbound, PreviewAttachAddItemTo>;
declare function previewAttachAddItemToToJSON(previewAttachAddItemTo: PreviewAttachAddItemTo): string;
/** @internal */
type PreviewAttachAddItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const PreviewAttachAddItemTier$outboundSchema: z$1.ZodMiniType<PreviewAttachAddItemTier$Outbound, PreviewAttachAddItemTier>;
declare function previewAttachAddItemTierToJSON(previewAttachAddItemTier: PreviewAttachAddItemTier): string;
/** @internal */
declare const PreviewAttachAddItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachAddItemTierBehavior>;
/** @internal */
declare const PreviewAttachAddItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachAddItemPriceInterval>;
/** @internal */
declare const PreviewAttachAddItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachAddItemBillingMethod>;
/** @internal */
type PreviewAttachAddItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<PreviewAttachAddItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const PreviewAttachAddItemPrice$outboundSchema: z$1.ZodMiniType<PreviewAttachAddItemPrice$Outbound, PreviewAttachAddItemPrice>;
declare function previewAttachAddItemPriceToJSON(previewAttachAddItemPrice: PreviewAttachAddItemPrice): string;
/** @internal */
declare const PreviewAttachAddItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachAddItemOnIncrease>;
/** @internal */
declare const PreviewAttachAddItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachAddItemOnDecrease>;
/** @internal */
type PreviewAttachAddItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const PreviewAttachAddItemProration$outboundSchema: z$1.ZodMiniType<PreviewAttachAddItemProration$Outbound, PreviewAttachAddItemProration>;
declare function previewAttachAddItemProrationToJSON(previewAttachAddItemProration: PreviewAttachAddItemProration): string;
/** @internal */
declare const PreviewAttachAddItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachAddItemExpiryDurationType>;
/** @internal */
type PreviewAttachAddItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const PreviewAttachAddItemRollover$outboundSchema: z$1.ZodMiniType<PreviewAttachAddItemRollover$Outbound, PreviewAttachAddItemRollover>;
declare function previewAttachAddItemRolloverToJSON(previewAttachAddItemRollover: PreviewAttachAddItemRollover): string;
/** @internal */
type PreviewAttachAddItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: PreviewAttachAddItemReset$Outbound | undefined;
    price?: PreviewAttachAddItemPrice$Outbound | undefined;
    proration?: PreviewAttachAddItemProration$Outbound | undefined;
    rollover?: PreviewAttachAddItemRollover$Outbound | undefined;
};
/** @internal */
declare const PreviewAttachAddItemPlanItem$outboundSchema: z$1.ZodMiniType<PreviewAttachAddItemPlanItem$Outbound, PreviewAttachAddItemPlanItem>;
declare function previewAttachAddItemPlanItemToJSON(previewAttachAddItemPlanItem: PreviewAttachAddItemPlanItem): string;
/** @internal */
declare const PreviewAttachRemoveItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachRemoveItemBillingMethod>;
/** @internal */
declare const PreviewAttachIntervalRemoveItemEnum2$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachIntervalRemoveItemEnum2>;
/** @internal */
declare const PreviewAttachIntervalRemoveItemEnum1$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachIntervalRemoveItemEnum1>;
/** @internal */
type PreviewAttachIntervalUnion$Outbound = string | string;
/** @internal */
declare const PreviewAttachIntervalUnion$outboundSchema: z$1.ZodMiniType<PreviewAttachIntervalUnion$Outbound, PreviewAttachIntervalUnion>;
declare function previewAttachIntervalUnionToJSON(previewAttachIntervalUnion: PreviewAttachIntervalUnion): string;
/** @internal */
type PreviewAttachPlanItemFilter$Outbound = {
    feature_id?: string | undefined;
    billing_method?: string | undefined;
    interval?: string | string | undefined;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewAttachPlanItemFilter$outboundSchema: z$1.ZodMiniType<PreviewAttachPlanItemFilter$Outbound, PreviewAttachPlanItemFilter>;
declare function previewAttachPlanItemFilterToJSON(previewAttachPlanItemFilter: PreviewAttachPlanItemFilter): string;
/** @internal */
declare const PreviewAttachDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachDurationType>;
/** @internal */
declare const PreviewAttachOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachOnEnd>;
/** @internal */
type PreviewAttachFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const PreviewAttachFreeTrialParams$outboundSchema: z$1.ZodMiniType<PreviewAttachFreeTrialParams$Outbound, PreviewAttachFreeTrialParams>;
declare function previewAttachFreeTrialParamsToJSON(previewAttachFreeTrialParams: PreviewAttachFreeTrialParams): string;
/** @internal */
declare const PreviewAttachPurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachPurchaseLimitInterval>;
/** @internal */
type PreviewAttachPurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const PreviewAttachPurchaseLimit$outboundSchema: z$1.ZodMiniType<PreviewAttachPurchaseLimit$Outbound, PreviewAttachPurchaseLimit>;
declare function previewAttachPurchaseLimitToJSON(previewAttachPurchaseLimit: PreviewAttachPurchaseLimit): string;
/** @internal */
type PreviewAttachAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: PreviewAttachPurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const PreviewAttachAutoTopup$outboundSchema: z$1.ZodMiniType<PreviewAttachAutoTopup$Outbound, PreviewAttachAutoTopup>;
declare function previewAttachAutoTopupToJSON(previewAttachAutoTopup: PreviewAttachAutoTopup): string;
/** @internal */
declare const PreviewAttachLimitType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachLimitType>;
/** @internal */
type PreviewAttachSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const PreviewAttachSpendLimit$outboundSchema: z$1.ZodMiniType<PreviewAttachSpendLimit$Outbound, PreviewAttachSpendLimit>;
declare function previewAttachSpendLimitToJSON(previewAttachSpendLimit: PreviewAttachSpendLimit): string;
/** @internal */
declare const PreviewAttachUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachUsageLimitInterval>;
/** @internal */
type PreviewAttachProperties$Outbound = string | number | boolean;
/** @internal */
declare const PreviewAttachProperties$outboundSchema: z$1.ZodMiniType<PreviewAttachProperties$Outbound, PreviewAttachProperties>;
declare function previewAttachPropertiesToJSON(previewAttachProperties: PreviewAttachProperties): string;
/** @internal */
type PreviewAttachFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const PreviewAttachFilter$outboundSchema: z$1.ZodMiniType<PreviewAttachFilter$Outbound, PreviewAttachFilter>;
declare function previewAttachFilterToJSON(previewAttachFilter: PreviewAttachFilter): string;
/** @internal */
type PreviewAttachUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: PreviewAttachFilter$Outbound | undefined;
};
/** @internal */
declare const PreviewAttachUsageLimit$outboundSchema: z$1.ZodMiniType<PreviewAttachUsageLimit$Outbound, PreviewAttachUsageLimit>;
declare function previewAttachUsageLimitToJSON(previewAttachUsageLimit: PreviewAttachUsageLimit): string;
/** @internal */
declare const PreviewAttachThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachThresholdType>;
/** @internal */
type PreviewAttachUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const PreviewAttachUsageAlert$outboundSchema: z$1.ZodMiniType<PreviewAttachUsageAlert$Outbound, PreviewAttachUsageAlert>;
declare function previewAttachUsageAlertToJSON(previewAttachUsageAlert: PreviewAttachUsageAlert): string;
/** @internal */
type PreviewAttachOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const PreviewAttachOverageAllowed$outboundSchema: z$1.ZodMiniType<PreviewAttachOverageAllowed$Outbound, PreviewAttachOverageAllowed>;
declare function previewAttachOverageAllowedToJSON(previewAttachOverageAllowed: PreviewAttachOverageAllowed): string;
/** @internal */
type PreviewAttachBillingControls$Outbound = {
    auto_topups?: Array<PreviewAttachAutoTopup$Outbound> | undefined;
    spend_limits?: Array<PreviewAttachSpendLimit$Outbound> | undefined;
    usage_limits?: Array<PreviewAttachUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<PreviewAttachUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<PreviewAttachOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const PreviewAttachBillingControls$outboundSchema: z$1.ZodMiniType<PreviewAttachBillingControls$Outbound, PreviewAttachBillingControls>;
declare function previewAttachBillingControlsToJSON(previewAttachBillingControls: PreviewAttachBillingControls): string;
/** @internal */
type PreviewAttachCustomize$Outbound = {
    price?: PreviewAttachBasePrice$Outbound | null | undefined;
    items?: Array<PreviewAttachItemPlanItem$Outbound> | undefined;
    add_items?: Array<PreviewAttachAddItemPlanItem$Outbound> | undefined;
    remove_items?: Array<PreviewAttachPlanItemFilter$Outbound> | undefined;
    free_trial?: PreviewAttachFreeTrialParams$Outbound | null | undefined;
    billing_controls?: PreviewAttachBillingControls$Outbound | undefined;
};
/** @internal */
declare const PreviewAttachCustomize$outboundSchema: z$1.ZodMiniType<PreviewAttachCustomize$Outbound, PreviewAttachCustomize>;
declare function previewAttachCustomizeToJSON(previewAttachCustomize: PreviewAttachCustomize): string;
/** @internal */
type PreviewAttachInvoiceMode$Outbound = {
    enabled: boolean;
    enable_plan_immediately: boolean;
    finalize: boolean;
    invoice_template_id?: string | undefined;
    net_terms_days?: number | undefined;
};
/** @internal */
declare const PreviewAttachInvoiceMode$outboundSchema: z$1.ZodMiniType<PreviewAttachInvoiceMode$Outbound, PreviewAttachInvoiceMode>;
declare function previewAttachInvoiceModeToJSON(previewAttachInvoiceMode: PreviewAttachInvoiceMode): string;
/** @internal */
declare const PreviewAttachProrationBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachProrationBehavior>;
/** @internal */
declare const PreviewAttachRedirectMode$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachRedirectMode>;
/** @internal */
type PreviewAttachAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const PreviewAttachAttachDiscount$outboundSchema: z$1.ZodMiniType<PreviewAttachAttachDiscount$Outbound, PreviewAttachAttachDiscount>;
declare function previewAttachAttachDiscountToJSON(previewAttachAttachDiscount: PreviewAttachAttachDiscount): string;
/** @internal */
declare const PreviewAttachPlanSchedule$outboundSchema: z$1.ZodMiniEnum<typeof PreviewAttachPlanSchedule>;
/** @internal */
type PreviewAttachCustomLineItem$Outbound = {
    amount: number;
    description: string;
};
/** @internal */
declare const PreviewAttachCustomLineItem$outboundSchema: z$1.ZodMiniType<PreviewAttachCustomLineItem$Outbound, PreviewAttachCustomLineItem>;
declare function previewAttachCustomLineItemToJSON(previewAttachCustomLineItem: PreviewAttachCustomLineItem): string;
/** @internal */
type PreviewAttachCarryOverBalances$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const PreviewAttachCarryOverBalances$outboundSchema: z$1.ZodMiniType<PreviewAttachCarryOverBalances$Outbound, PreviewAttachCarryOverBalances>;
declare function previewAttachCarryOverBalancesToJSON(previewAttachCarryOverBalances: PreviewAttachCarryOverBalances): string;
/** @internal */
type PreviewAttachCarryOverUsages$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const PreviewAttachCarryOverUsages$outboundSchema: z$1.ZodMiniType<PreviewAttachCarryOverUsages$Outbound, PreviewAttachCarryOverUsages>;
declare function previewAttachCarryOverUsagesToJSON(previewAttachCarryOverUsages: PreviewAttachCarryOverUsages): string;
/** @internal */
type PreviewAttachParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    plan_id: string;
    feature_quantities?: Array<PreviewAttachFeatureQuantityRequest$Outbound> | undefined;
    version?: number | undefined;
    customize?: PreviewAttachCustomize$Outbound | undefined;
    invoice_mode?: PreviewAttachInvoiceMode$Outbound | undefined;
    proration_behavior?: string | undefined;
    redirect_mode: string;
    subscription_id?: string | undefined;
    discounts?: Array<PreviewAttachAttachDiscount$Outbound> | undefined;
    success_url?: string | undefined;
    new_billing_subscription?: boolean | undefined;
    billing_cycle_anchor?: "now" | undefined;
    plan_schedule?: string | undefined;
    starts_at?: number | undefined;
    ends_at?: number | undefined;
    checkout_session_params?: {
        [k: string]: any;
    } | undefined;
    long_lived_checkout?: boolean | undefined;
    custom_line_items?: Array<PreviewAttachCustomLineItem$Outbound> | undefined;
    processor_subscription_id?: string | undefined;
    carry_over_balances?: PreviewAttachCarryOverBalances$Outbound | undefined;
    carry_over_usages?: PreviewAttachCarryOverUsages$Outbound | undefined;
    metadata?: {
        [k: string]: string;
    } | undefined;
    no_billing_changes?: boolean | undefined;
    enable_plan_immediately?: boolean | undefined;
    tax_rate_id?: string | undefined;
};
/** @internal */
declare const PreviewAttachParams$outboundSchema: z$1.ZodMiniType<PreviewAttachParams$Outbound, PreviewAttachParams>;
declare function previewAttachParamsToJSON(previewAttachParams: PreviewAttachParams): string;
/** @internal */
declare const PreviewAttachDiscount$inboundSchema: z$1.ZodMiniType<PreviewAttachDiscount, unknown>;
declare function previewAttachDiscountFromJSON(jsonString: string): Result$1<PreviewAttachDiscount, SDKValidationError>;
/** @internal */
declare const PreviewAttachLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewAttachLineItemPeriod, unknown>;
declare function previewAttachLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewAttachLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewAttachLineItem$inboundSchema: z$1.ZodMiniType<PreviewAttachLineItem, unknown>;
declare function previewAttachLineItemFromJSON(jsonString: string): Result$1<PreviewAttachLineItem, SDKValidationError>;
/** @internal */
declare const PreviewAttachNextCycleDiscount$inboundSchema: z$1.ZodMiniType<PreviewAttachNextCycleDiscount, unknown>;
declare function previewAttachNextCycleDiscountFromJSON(jsonString: string): Result$1<PreviewAttachNextCycleDiscount, SDKValidationError>;
/** @internal */
declare const PreviewAttachNextCycleLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewAttachNextCycleLineItemPeriod, unknown>;
declare function previewAttachNextCycleLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewAttachNextCycleLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewAttachNextCycleLineItem$inboundSchema: z$1.ZodMiniType<PreviewAttachNextCycleLineItem, unknown>;
declare function previewAttachNextCycleLineItemFromJSON(jsonString: string): Result$1<PreviewAttachNextCycleLineItem, SDKValidationError>;
/** @internal */
declare const PreviewAttachUsageLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewAttachUsageLineItemPeriod, unknown>;
declare function previewAttachUsageLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewAttachUsageLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewAttachUsageLineItem$inboundSchema: z$1.ZodMiniType<PreviewAttachUsageLineItem, unknown>;
declare function previewAttachUsageLineItemFromJSON(jsonString: string): Result$1<PreviewAttachUsageLineItem, SDKValidationError>;
/** @internal */
declare const PreviewAttachNextCycle$inboundSchema: z$1.ZodMiniType<PreviewAttachNextCycle, unknown>;
declare function previewAttachNextCycleFromJSON(jsonString: string): Result$1<PreviewAttachNextCycle, SDKValidationError>;
/** @internal */
declare const PreviewAttachIncomingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewAttachIncomingFeatureQuantity, unknown>;
declare function previewAttachIncomingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewAttachIncomingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewAttachIncoming$inboundSchema: z$1.ZodMiniType<PreviewAttachIncoming, unknown>;
declare function previewAttachIncomingFromJSON(jsonString: string): Result$1<PreviewAttachIncoming, SDKValidationError>;
/** @internal */
declare const PreviewAttachOutgoingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewAttachOutgoingFeatureQuantity, unknown>;
declare function previewAttachOutgoingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewAttachOutgoingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewAttachOutgoing$inboundSchema: z$1.ZodMiniType<PreviewAttachOutgoing, unknown>;
declare function previewAttachOutgoingFromJSON(jsonString: string): Result$1<PreviewAttachOutgoing, SDKValidationError>;
/** @internal */
declare const PreviewAttachCheckoutType$inboundSchema: z$1.ZodMiniType<PreviewAttachCheckoutType, unknown>;
/** @internal */
declare const PreviewAttachStatus$inboundSchema: z$1.ZodMiniType<PreviewAttachStatus, unknown>;
/** @internal */
declare const PreviewAttachTax$inboundSchema: z$1.ZodMiniType<PreviewAttachTax, unknown>;
declare function previewAttachTaxFromJSON(jsonString: string): Result$1<PreviewAttachTax, SDKValidationError>;
/** @internal */
declare const PreviewAttachInvoiceCredits$inboundSchema: z$1.ZodMiniType<PreviewAttachInvoiceCredits, unknown>;
declare function previewAttachInvoiceCreditsFromJSON(jsonString: string): Result$1<PreviewAttachInvoiceCredits, SDKValidationError>;
/** @internal */
declare const PreviewAttachResponse$inboundSchema: z$1.ZodMiniType<PreviewAttachResponse, unknown>;
declare function previewAttachResponseFromJSON(jsonString: string): Result$1<PreviewAttachResponse, SDKValidationError>;

type PreviewMultiAttachGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const PreviewMultiAttachPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type PreviewMultiAttachPriceInterval = ClosedEnum<typeof PreviewMultiAttachPriceInterval>;
/**
 * Base price configuration for a plan.
 */
type PreviewMultiAttachBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: PreviewMultiAttachPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const PreviewMultiAttachResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type PreviewMultiAttachResetInterval = ClosedEnum<typeof PreviewMultiAttachResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type PreviewMultiAttachReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: PreviewMultiAttachResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type PreviewMultiAttachTo = number | string;
type PreviewMultiAttachTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const PreviewMultiAttachTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type PreviewMultiAttachTierBehavior = ClosedEnum<typeof PreviewMultiAttachTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const PreviewMultiAttachItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type PreviewMultiAttachItemPriceInterval = ClosedEnum<typeof PreviewMultiAttachItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const PreviewMultiAttachBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type PreviewMultiAttachBillingMethod = ClosedEnum<typeof PreviewMultiAttachBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type PreviewMultiAttachPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<PreviewMultiAttachTier> | undefined;
    tierBehavior?: PreviewMultiAttachTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: PreviewMultiAttachItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: PreviewMultiAttachBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const PreviewMultiAttachOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type PreviewMultiAttachOnIncrease = ClosedEnum<typeof PreviewMultiAttachOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const PreviewMultiAttachOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type PreviewMultiAttachOnDecrease = ClosedEnum<typeof PreviewMultiAttachOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type PreviewMultiAttachProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: PreviewMultiAttachOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: PreviewMultiAttachOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const PreviewMultiAttachExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type PreviewMultiAttachExpiryDurationType = ClosedEnum<typeof PreviewMultiAttachExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type PreviewMultiAttachRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: PreviewMultiAttachExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type PreviewMultiAttachPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: PreviewMultiAttachReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: PreviewMultiAttachPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: PreviewMultiAttachProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: PreviewMultiAttachRollover | undefined;
};
/**
 * Customize the plan to attach. Can override the price or items.
 */
type PreviewMultiAttachCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: PreviewMultiAttachBasePrice | null | undefined;
    /**
     * Override the items in the plan.
     */
    items?: Array<PreviewMultiAttachPlanItem> | undefined;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type PreviewMultiAttachPlanFeatureQuantity = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
type PreviewMultiAttachPlan = {
    /**
     * The ID of the plan to attach.
     */
    planId: string;
    /**
     * Customize the plan to attach. Can override the price or items.
     */
    customize?: PreviewMultiAttachCustomize | undefined;
    /**
     * If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature.
     */
    featureQuantities?: Array<PreviewMultiAttachPlanFeatureQuantity> | undefined;
    /**
     * The version of the plan to attach.
     */
    version?: number | undefined;
    /**
     * A unique ID to identify this subscription. Useful when attaching the same plan multiple times.
     */
    subscriptionId?: string | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const PreviewMultiAttachDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type PreviewMultiAttachDurationType = ClosedEnum<typeof PreviewMultiAttachDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const PreviewMultiAttachOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type PreviewMultiAttachOnEnd = ClosedEnum<typeof PreviewMultiAttachOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type PreviewMultiAttachFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: PreviewMultiAttachDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: PreviewMultiAttachOnEnd | undefined;
};
/**
 * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately.
 */
type PreviewMultiAttachInvoiceMode = {
    /**
     * When true, creates an invoice and sends it to the customer instead of charging their card immediately. Uses Stripe's send_invoice collection method.
     */
    enabled: boolean;
    /**
     * If true, enables the plan immediately even though the invoice is not paid yet.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * If true, finalizes the invoice so it can be sent to the customer. If false, keeps it as a draft for manual review.
     */
    finalize?: boolean | undefined;
    /**
     * ID of an invoice template (configured in billing settings) whose footer (e.g. bank details) is applied to the invoice.
     */
    invoiceTemplateId?: string | undefined;
    /**
     * Number of days the customer has to pay the invoice before it is due (Stripe days_until_due).
     */
    netTermsDays?: number | undefined;
};
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type PreviewMultiAttachAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
declare const PreviewMultiAttachRedirectMode: {
    readonly Always: "always";
    readonly IfRequired: "if_required";
    readonly Never: "never";
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
type PreviewMultiAttachRedirectMode = ClosedEnum<typeof PreviewMultiAttachRedirectMode>;
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const PreviewMultiAttachLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type PreviewMultiAttachLimitType = ClosedEnum<typeof PreviewMultiAttachLimitType>;
type PreviewMultiAttachSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: PreviewMultiAttachLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const PreviewMultiAttachEntityDataInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type PreviewMultiAttachEntityDataInterval = ClosedEnum<typeof PreviewMultiAttachEntityDataInterval>;
type PreviewMultiAttachProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type PreviewMultiAttachFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type PreviewMultiAttachUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: PreviewMultiAttachEntityDataInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: PreviewMultiAttachFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const PreviewMultiAttachThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type PreviewMultiAttachThresholdType = ClosedEnum<typeof PreviewMultiAttachThresholdType>;
type PreviewMultiAttachUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: PreviewMultiAttachThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type PreviewMultiAttachOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Billing controls for the entity.
 */
type PreviewMultiAttachBillingControls = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<PreviewMultiAttachSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<PreviewMultiAttachUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<PreviewMultiAttachUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<PreviewMultiAttachOverageAllowed> | undefined;
};
type PreviewMultiAttachEntityData = {
    /**
     * The feature ID that this entity is associated with
     */
    featureId: string;
    /**
     * Name of the entity
     */
    name?: string | undefined;
    /**
     * Billing controls for the entity.
     */
    billingControls?: PreviewMultiAttachBillingControls | undefined;
};
type PreviewMultiAttachParams = {
    /**
     * The ID of the customer to attach the plans to.
     */
    customerId: string;
    /**
     * The ID of the entity to attach the plans to.
     */
    entityId?: string | undefined;
    /**
     * The list of plans to attach to the customer.
     */
    plans: Array<PreviewMultiAttachPlan>;
    /**
     * Free trial configuration applied to all plans. Pass an object to set a custom trial, or null to remove any trial.
     */
    freeTrial?: PreviewMultiAttachFreeTrialParams | null | undefined;
    /**
     * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately.
     */
    invoiceMode?: PreviewMultiAttachInvoiceMode | undefined;
    /**
     * List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<PreviewMultiAttachAttachDiscount> | undefined;
    /**
     * URL to redirect to after successful checkout.
     */
    successUrl?: string | undefined;
    /**
     * Additional parameters to pass into the creation of the Stripe checkout session.
     */
    checkoutSessionParams?: {
        [k: string]: any;
    } | undefined;
    /**
     * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
     */
    redirectMode?: PreviewMultiAttachRedirectMode | undefined;
    /**
     * Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one.
     */
    newBillingSubscription?: boolean | undefined;
    /**
     * If true, the cusProducts are activated immediately even when payment is pending via Stripe checkout.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * Customer details to set when creating a customer
     */
    customerData?: CustomerData | undefined;
    entityData?: PreviewMultiAttachEntityData | undefined;
};
type PreviewMultiAttachDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewMultiAttachLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewMultiAttachLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewMultiAttachDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewMultiAttachLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
type PreviewMultiAttachNextCycleDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewMultiAttachNextCycleLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewMultiAttachNextCycleLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewMultiAttachNextCycleDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewMultiAttachNextCycleLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewMultiAttachUsageLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewMultiAttachUsageLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewMultiAttachUsageLineItemPeriod | undefined;
};
/**
 * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
 */
type PreviewMultiAttachNextCycle = {
    /**
     * Unix timestamp (milliseconds) when the next billing cycle starts.
     */
    startsAt: number;
    /**
     * The total amount in cents before discounts and tax for the next cycle.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the next cycle.
     */
    total: number;
    /**
     * List of line items for the next billing cycle.
     */
    lineItems: Array<PreviewMultiAttachNextCycleLineItem>;
    /**
     * List of line items for usage-based features in the next cycle.
     */
    usageLineItems: Array<PreviewMultiAttachUsageLineItem>;
};
type PreviewMultiAttachIncomingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewMultiAttachIncoming = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewMultiAttachIncomingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
type PreviewMultiAttachOutgoingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewMultiAttachOutgoing = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewMultiAttachOutgoingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
declare const PreviewMultiAttachCheckoutType: {
    readonly StripeCheckout: "stripe_checkout";
    readonly AutumnCheckout: "autumn_checkout";
};
type PreviewMultiAttachCheckoutType = OpenEnum<typeof PreviewMultiAttachCheckoutType>;
/**
 * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
 */
declare const PreviewMultiAttachStatus: {
    readonly Complete: "complete";
    readonly Incomplete: "incomplete";
};
/**
 * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
 */
type PreviewMultiAttachStatus = OpenEnum<typeof PreviewMultiAttachStatus>;
/**
 * Tax preview for the immediate charge. Contact us to enable the tax flag on your organisation. Shows only with flag enabled, a Stripe customer exists and has a location.
 */
type PreviewMultiAttachTax = {
    /**
     * Total tax amount in major currency units.
     */
    total: number;
    /**
     * Tax included in line item subtotals.
     */
    amountInclusive: number;
    /**
     * Tax added on top of subtotals.
     */
    amountExclusive: number;
    /**
     * Three-letter currency code.
     */
    currency: string;
    /**
     * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
     */
    status: PreviewMultiAttachStatus;
};
/**
 * Stripe customer invoice credits preview.
 */
type PreviewMultiAttachInvoiceCredits = {
    /**
     * Stripe customer credit balance available, expressed as a positive number in major currency units.
     */
    balance: number;
    /**
     * Three-letter currency code.
     */
    currency: string;
};
/**
 * OK
 */
type PreviewMultiAttachResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    lineItems: Array<PreviewMultiAttachLineItem>;
    /**
     * The total amount in cents before discounts and tax for the current billing period.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the current billing period.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
     */
    nextCycle?: PreviewMultiAttachNextCycle | undefined;
    /**
     * Expand the response with additional data.
     */
    expand?: Array<string> | undefined;
    /**
     * Products or subscription changes being added or updated.
     */
    incoming: Array<PreviewMultiAttachIncoming>;
    /**
     * Products or subscription changes being removed or ended.
     */
    outgoing: Array<PreviewMultiAttachOutgoing>;
    /**
     * Whether the customer will be redirected to a checkout page if attach is called.
     */
    redirectToCheckout: boolean;
    /**
     * The type of checkout that will be used if the customer is redirected to a checkout page.
     */
    checkoutType: PreviewMultiAttachCheckoutType | null;
    /**
     * Tax preview for the immediate charge. Contact us to enable the tax flag on your organisation. Shows only with flag enabled, a Stripe customer exists and has a location.
     */
    tax?: PreviewMultiAttachTax | undefined;
    /**
     * Stripe customer invoice credits preview.
     */
    invoiceCredits?: PreviewMultiAttachInvoiceCredits | undefined;
};
/** @internal */
declare const PreviewMultiAttachPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachPriceInterval>;
/** @internal */
type PreviewMultiAttachBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewMultiAttachBasePrice$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachBasePrice$Outbound, PreviewMultiAttachBasePrice>;
declare function previewMultiAttachBasePriceToJSON(previewMultiAttachBasePrice: PreviewMultiAttachBasePrice): string;
/** @internal */
declare const PreviewMultiAttachResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachResetInterval>;
/** @internal */
type PreviewMultiAttachReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewMultiAttachReset$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachReset$Outbound, PreviewMultiAttachReset>;
declare function previewMultiAttachResetToJSON(previewMultiAttachReset: PreviewMultiAttachReset): string;
/** @internal */
type PreviewMultiAttachTo$Outbound = number | string;
/** @internal */
declare const PreviewMultiAttachTo$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachTo$Outbound, PreviewMultiAttachTo>;
declare function previewMultiAttachToToJSON(previewMultiAttachTo: PreviewMultiAttachTo): string;
/** @internal */
type PreviewMultiAttachTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const PreviewMultiAttachTier$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachTier$Outbound, PreviewMultiAttachTier>;
declare function previewMultiAttachTierToJSON(previewMultiAttachTier: PreviewMultiAttachTier): string;
/** @internal */
declare const PreviewMultiAttachTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachTierBehavior>;
/** @internal */
declare const PreviewMultiAttachItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachItemPriceInterval>;
/** @internal */
declare const PreviewMultiAttachBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachBillingMethod>;
/** @internal */
type PreviewMultiAttachPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<PreviewMultiAttachTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const PreviewMultiAttachPrice$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachPrice$Outbound, PreviewMultiAttachPrice>;
declare function previewMultiAttachPriceToJSON(previewMultiAttachPrice: PreviewMultiAttachPrice): string;
/** @internal */
declare const PreviewMultiAttachOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachOnIncrease>;
/** @internal */
declare const PreviewMultiAttachOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachOnDecrease>;
/** @internal */
type PreviewMultiAttachProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const PreviewMultiAttachProration$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachProration$Outbound, PreviewMultiAttachProration>;
declare function previewMultiAttachProrationToJSON(previewMultiAttachProration: PreviewMultiAttachProration): string;
/** @internal */
declare const PreviewMultiAttachExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachExpiryDurationType>;
/** @internal */
type PreviewMultiAttachRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const PreviewMultiAttachRollover$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachRollover$Outbound, PreviewMultiAttachRollover>;
declare function previewMultiAttachRolloverToJSON(previewMultiAttachRollover: PreviewMultiAttachRollover): string;
/** @internal */
type PreviewMultiAttachPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: PreviewMultiAttachReset$Outbound | undefined;
    price?: PreviewMultiAttachPrice$Outbound | undefined;
    proration?: PreviewMultiAttachProration$Outbound | undefined;
    rollover?: PreviewMultiAttachRollover$Outbound | undefined;
};
/** @internal */
declare const PreviewMultiAttachPlanItem$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachPlanItem$Outbound, PreviewMultiAttachPlanItem>;
declare function previewMultiAttachPlanItemToJSON(previewMultiAttachPlanItem: PreviewMultiAttachPlanItem): string;
/** @internal */
type PreviewMultiAttachCustomize$Outbound = {
    price?: PreviewMultiAttachBasePrice$Outbound | null | undefined;
    items?: Array<PreviewMultiAttachPlanItem$Outbound> | undefined;
};
/** @internal */
declare const PreviewMultiAttachCustomize$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachCustomize$Outbound, PreviewMultiAttachCustomize>;
declare function previewMultiAttachCustomizeToJSON(previewMultiAttachCustomize: PreviewMultiAttachCustomize): string;
/** @internal */
type PreviewMultiAttachPlanFeatureQuantity$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const PreviewMultiAttachPlanFeatureQuantity$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachPlanFeatureQuantity$Outbound, PreviewMultiAttachPlanFeatureQuantity>;
declare function previewMultiAttachPlanFeatureQuantityToJSON(previewMultiAttachPlanFeatureQuantity: PreviewMultiAttachPlanFeatureQuantity): string;
/** @internal */
type PreviewMultiAttachPlan$Outbound = {
    plan_id: string;
    customize?: PreviewMultiAttachCustomize$Outbound | undefined;
    feature_quantities?: Array<PreviewMultiAttachPlanFeatureQuantity$Outbound> | undefined;
    version?: number | undefined;
    subscription_id?: string | undefined;
};
/** @internal */
declare const PreviewMultiAttachPlan$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachPlan$Outbound, PreviewMultiAttachPlan>;
declare function previewMultiAttachPlanToJSON(previewMultiAttachPlan: PreviewMultiAttachPlan): string;
/** @internal */
declare const PreviewMultiAttachDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachDurationType>;
/** @internal */
declare const PreviewMultiAttachOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachOnEnd>;
/** @internal */
type PreviewMultiAttachFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const PreviewMultiAttachFreeTrialParams$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachFreeTrialParams$Outbound, PreviewMultiAttachFreeTrialParams>;
declare function previewMultiAttachFreeTrialParamsToJSON(previewMultiAttachFreeTrialParams: PreviewMultiAttachFreeTrialParams): string;
/** @internal */
type PreviewMultiAttachInvoiceMode$Outbound = {
    enabled: boolean;
    enable_plan_immediately: boolean;
    finalize: boolean;
    invoice_template_id?: string | undefined;
    net_terms_days?: number | undefined;
};
/** @internal */
declare const PreviewMultiAttachInvoiceMode$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachInvoiceMode$Outbound, PreviewMultiAttachInvoiceMode>;
declare function previewMultiAttachInvoiceModeToJSON(previewMultiAttachInvoiceMode: PreviewMultiAttachInvoiceMode): string;
/** @internal */
type PreviewMultiAttachAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const PreviewMultiAttachAttachDiscount$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachAttachDiscount$Outbound, PreviewMultiAttachAttachDiscount>;
declare function previewMultiAttachAttachDiscountToJSON(previewMultiAttachAttachDiscount: PreviewMultiAttachAttachDiscount): string;
/** @internal */
declare const PreviewMultiAttachRedirectMode$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachRedirectMode>;
/** @internal */
declare const PreviewMultiAttachLimitType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachLimitType>;
/** @internal */
type PreviewMultiAttachSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const PreviewMultiAttachSpendLimit$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachSpendLimit$Outbound, PreviewMultiAttachSpendLimit>;
declare function previewMultiAttachSpendLimitToJSON(previewMultiAttachSpendLimit: PreviewMultiAttachSpendLimit): string;
/** @internal */
declare const PreviewMultiAttachEntityDataInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachEntityDataInterval>;
/** @internal */
type PreviewMultiAttachProperties$Outbound = string | number | boolean;
/** @internal */
declare const PreviewMultiAttachProperties$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachProperties$Outbound, PreviewMultiAttachProperties>;
declare function previewMultiAttachPropertiesToJSON(previewMultiAttachProperties: PreviewMultiAttachProperties): string;
/** @internal */
type PreviewMultiAttachFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const PreviewMultiAttachFilter$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachFilter$Outbound, PreviewMultiAttachFilter>;
declare function previewMultiAttachFilterToJSON(previewMultiAttachFilter: PreviewMultiAttachFilter): string;
/** @internal */
type PreviewMultiAttachUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: PreviewMultiAttachFilter$Outbound | undefined;
};
/** @internal */
declare const PreviewMultiAttachUsageLimit$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachUsageLimit$Outbound, PreviewMultiAttachUsageLimit>;
declare function previewMultiAttachUsageLimitToJSON(previewMultiAttachUsageLimit: PreviewMultiAttachUsageLimit): string;
/** @internal */
declare const PreviewMultiAttachThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiAttachThresholdType>;
/** @internal */
type PreviewMultiAttachUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const PreviewMultiAttachUsageAlert$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachUsageAlert$Outbound, PreviewMultiAttachUsageAlert>;
declare function previewMultiAttachUsageAlertToJSON(previewMultiAttachUsageAlert: PreviewMultiAttachUsageAlert): string;
/** @internal */
type PreviewMultiAttachOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const PreviewMultiAttachOverageAllowed$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachOverageAllowed$Outbound, PreviewMultiAttachOverageAllowed>;
declare function previewMultiAttachOverageAllowedToJSON(previewMultiAttachOverageAllowed: PreviewMultiAttachOverageAllowed): string;
/** @internal */
type PreviewMultiAttachBillingControls$Outbound = {
    spend_limits?: Array<PreviewMultiAttachSpendLimit$Outbound> | undefined;
    usage_limits?: Array<PreviewMultiAttachUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<PreviewMultiAttachUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<PreviewMultiAttachOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const PreviewMultiAttachBillingControls$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachBillingControls$Outbound, PreviewMultiAttachBillingControls>;
declare function previewMultiAttachBillingControlsToJSON(previewMultiAttachBillingControls: PreviewMultiAttachBillingControls): string;
/** @internal */
type PreviewMultiAttachEntityData$Outbound = {
    feature_id: string;
    name?: string | undefined;
    billing_controls?: PreviewMultiAttachBillingControls$Outbound | undefined;
};
/** @internal */
declare const PreviewMultiAttachEntityData$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachEntityData$Outbound, PreviewMultiAttachEntityData>;
declare function previewMultiAttachEntityDataToJSON(previewMultiAttachEntityData: PreviewMultiAttachEntityData): string;
/** @internal */
type PreviewMultiAttachParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    plans: Array<PreviewMultiAttachPlan$Outbound>;
    free_trial?: PreviewMultiAttachFreeTrialParams$Outbound | null | undefined;
    invoice_mode?: PreviewMultiAttachInvoiceMode$Outbound | undefined;
    discounts?: Array<PreviewMultiAttachAttachDiscount$Outbound> | undefined;
    success_url?: string | undefined;
    checkout_session_params?: {
        [k: string]: any;
    } | undefined;
    redirect_mode: string;
    new_billing_subscription?: boolean | undefined;
    enable_plan_immediately?: boolean | undefined;
    customer_data?: CustomerData$Outbound | undefined;
    entity_data?: PreviewMultiAttachEntityData$Outbound | undefined;
};
/** @internal */
declare const PreviewMultiAttachParams$outboundSchema: z$1.ZodMiniType<PreviewMultiAttachParams$Outbound, PreviewMultiAttachParams>;
declare function previewMultiAttachParamsToJSON(previewMultiAttachParams: PreviewMultiAttachParams): string;
/** @internal */
declare const PreviewMultiAttachDiscount$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachDiscount, unknown>;
declare function previewMultiAttachDiscountFromJSON(jsonString: string): Result$1<PreviewMultiAttachDiscount, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachLineItemPeriod, unknown>;
declare function previewMultiAttachLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewMultiAttachLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachLineItem$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachLineItem, unknown>;
declare function previewMultiAttachLineItemFromJSON(jsonString: string): Result$1<PreviewMultiAttachLineItem, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachNextCycleDiscount$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachNextCycleDiscount, unknown>;
declare function previewMultiAttachNextCycleDiscountFromJSON(jsonString: string): Result$1<PreviewMultiAttachNextCycleDiscount, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachNextCycleLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachNextCycleLineItemPeriod, unknown>;
declare function previewMultiAttachNextCycleLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewMultiAttachNextCycleLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachNextCycleLineItem$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachNextCycleLineItem, unknown>;
declare function previewMultiAttachNextCycleLineItemFromJSON(jsonString: string): Result$1<PreviewMultiAttachNextCycleLineItem, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachUsageLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachUsageLineItemPeriod, unknown>;
declare function previewMultiAttachUsageLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewMultiAttachUsageLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachUsageLineItem$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachUsageLineItem, unknown>;
declare function previewMultiAttachUsageLineItemFromJSON(jsonString: string): Result$1<PreviewMultiAttachUsageLineItem, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachNextCycle$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachNextCycle, unknown>;
declare function previewMultiAttachNextCycleFromJSON(jsonString: string): Result$1<PreviewMultiAttachNextCycle, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachIncomingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachIncomingFeatureQuantity, unknown>;
declare function previewMultiAttachIncomingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewMultiAttachIncomingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachIncoming$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachIncoming, unknown>;
declare function previewMultiAttachIncomingFromJSON(jsonString: string): Result$1<PreviewMultiAttachIncoming, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachOutgoingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachOutgoingFeatureQuantity, unknown>;
declare function previewMultiAttachOutgoingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewMultiAttachOutgoingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachOutgoing$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachOutgoing, unknown>;
declare function previewMultiAttachOutgoingFromJSON(jsonString: string): Result$1<PreviewMultiAttachOutgoing, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachCheckoutType$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachCheckoutType, unknown>;
/** @internal */
declare const PreviewMultiAttachStatus$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachStatus, unknown>;
/** @internal */
declare const PreviewMultiAttachTax$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachTax, unknown>;
declare function previewMultiAttachTaxFromJSON(jsonString: string): Result$1<PreviewMultiAttachTax, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachInvoiceCredits$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachInvoiceCredits, unknown>;
declare function previewMultiAttachInvoiceCreditsFromJSON(jsonString: string): Result$1<PreviewMultiAttachInvoiceCredits, SDKValidationError>;
/** @internal */
declare const PreviewMultiAttachResponse$inboundSchema: z$1.ZodMiniType<PreviewMultiAttachResponse, unknown>;
declare function previewMultiAttachResponseFromJSON(jsonString: string): Result$1<PreviewMultiAttachResponse, SDKValidationError>;

type PreviewMultiUpdateGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
declare const PreviewMultiUpdateCancelAction: {
    readonly CancelImmediately: "cancel_immediately";
    readonly CancelEndOfCycle: "cancel_end_of_cycle";
    readonly Uncancel: "uncancel";
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
type PreviewMultiUpdateCancelAction = ClosedEnum<typeof PreviewMultiUpdateCancelAction>;
/**
 * How to handle proration for this update. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
declare const PreviewMultiUpdateProrationBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * How to handle proration for this update. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
type PreviewMultiUpdateProrationBehavior = ClosedEnum<typeof PreviewMultiUpdateProrationBehavior>;
type PreviewMultiUpdateUpdate = {
    /**
     * The ID of the plan to update. Optional if subscription_id is provided.
     */
    planId?: string | undefined;
    /**
     * A unique ID to identify the subscription to update. Useful when a customer has multiple products with the same plan.
     */
    subscriptionId?: string | undefined;
    /**
     * The ID of the entity this update targets. Overrides the top-level entity_id for this update.
     */
    entityId?: string | undefined;
    /**
     * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
     */
    cancelAction: PreviewMultiUpdateCancelAction;
    /**
     * How to handle proration for this update. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
     */
    prorationBehavior?: PreviewMultiUpdateProrationBehavior | undefined;
};
type PreviewMultiUpdateParams = {
    /**
     * The ID of the customer to update plans for.
     */
    customerId: string;
    /**
     * The ID of the entity to update plans for. Individual updates can override this with their own entity_id.
     */
    entityId?: string | undefined;
    /**
     * The list of plan updates to apply to the customer.
     */
    updates: Array<PreviewMultiUpdateUpdate>;
};
type PreviewMultiUpdateDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewMultiUpdateLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewMultiUpdateLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewMultiUpdateDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewMultiUpdateLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
type PreviewMultiUpdateNextCycleDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewMultiUpdateNextCycleLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewMultiUpdateNextCycleLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewMultiUpdateNextCycleDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewMultiUpdateNextCycleLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewMultiUpdateUsageLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewMultiUpdateUsageLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewMultiUpdateUsageLineItemPeriod | undefined;
};
/**
 * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
 */
type PreviewMultiUpdateNextCycle = {
    /**
     * Unix timestamp (milliseconds) when the next billing cycle starts.
     */
    startsAt: number;
    /**
     * The total amount in cents before discounts and tax for the next cycle.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the next cycle.
     */
    total: number;
    /**
     * List of line items for the next billing cycle.
     */
    lineItems: Array<PreviewMultiUpdateNextCycleLineItem>;
    /**
     * List of line items for usage-based features in the next cycle.
     */
    usageLineItems: Array<PreviewMultiUpdateUsageLineItem>;
};
type PreviewMultiUpdateIncomingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewMultiUpdateIncoming = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewMultiUpdateIncomingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
type PreviewMultiUpdateOutgoingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewMultiUpdateOutgoing = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewMultiUpdateOutgoingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
type PreviewMultiUpdateSubscription = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * List of line items for the current billing period.
     */
    lineItems: Array<PreviewMultiUpdateLineItem>;
    /**
     * The total amount in cents before discounts and tax for the current billing period.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the current billing period.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
     */
    nextCycle?: PreviewMultiUpdateNextCycle | undefined;
    /**
     * Expand the response with additional data.
     */
    expand?: Array<string> | undefined;
    /**
     * Products or subscription changes being added or updated.
     */
    incoming: Array<PreviewMultiUpdateIncoming>;
    /**
     * Products or subscription changes being removed or ended.
     */
    outgoing: Array<PreviewMultiUpdateOutgoing>;
    /**
     * The IDs of the plans updated on this subscription.
     */
    planIds: Array<string>;
};
/**
 * OK
 */
type MultiUpdatePreviewResponse = {
    /**
     * The ID of the customer the preview applies to.
     */
    customerId: string;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * The combined amount due today across all subscriptions (sum of subscriptions[].total).
     */
    total: number;
    /**
     * One preview per affected Stripe subscription. Updates to plans without a subscription (free plans) produce no entry.
     */
    subscriptions: Array<PreviewMultiUpdateSubscription>;
};
/** @internal */
declare const PreviewMultiUpdateCancelAction$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiUpdateCancelAction>;
/** @internal */
declare const PreviewMultiUpdateProrationBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewMultiUpdateProrationBehavior>;
/** @internal */
type PreviewMultiUpdateUpdate$Outbound = {
    plan_id?: string | undefined;
    subscription_id?: string | undefined;
    entity_id?: string | undefined;
    cancel_action: string;
    proration_behavior?: string | undefined;
};
/** @internal */
declare const PreviewMultiUpdateUpdate$outboundSchema: z$1.ZodMiniType<PreviewMultiUpdateUpdate$Outbound, PreviewMultiUpdateUpdate>;
declare function previewMultiUpdateUpdateToJSON(previewMultiUpdateUpdate: PreviewMultiUpdateUpdate): string;
/** @internal */
type PreviewMultiUpdateParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    updates: Array<PreviewMultiUpdateUpdate$Outbound>;
};
/** @internal */
declare const PreviewMultiUpdateParams$outboundSchema: z$1.ZodMiniType<PreviewMultiUpdateParams$Outbound, PreviewMultiUpdateParams>;
declare function previewMultiUpdateParamsToJSON(previewMultiUpdateParams: PreviewMultiUpdateParams): string;
/** @internal */
declare const PreviewMultiUpdateDiscount$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateDiscount, unknown>;
declare function previewMultiUpdateDiscountFromJSON(jsonString: string): Result$1<PreviewMultiUpdateDiscount, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateLineItemPeriod, unknown>;
declare function previewMultiUpdateLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewMultiUpdateLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateLineItem$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateLineItem, unknown>;
declare function previewMultiUpdateLineItemFromJSON(jsonString: string): Result$1<PreviewMultiUpdateLineItem, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateNextCycleDiscount$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateNextCycleDiscount, unknown>;
declare function previewMultiUpdateNextCycleDiscountFromJSON(jsonString: string): Result$1<PreviewMultiUpdateNextCycleDiscount, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateNextCycleLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateNextCycleLineItemPeriod, unknown>;
declare function previewMultiUpdateNextCycleLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewMultiUpdateNextCycleLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateNextCycleLineItem$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateNextCycleLineItem, unknown>;
declare function previewMultiUpdateNextCycleLineItemFromJSON(jsonString: string): Result$1<PreviewMultiUpdateNextCycleLineItem, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateUsageLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateUsageLineItemPeriod, unknown>;
declare function previewMultiUpdateUsageLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewMultiUpdateUsageLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateUsageLineItem$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateUsageLineItem, unknown>;
declare function previewMultiUpdateUsageLineItemFromJSON(jsonString: string): Result$1<PreviewMultiUpdateUsageLineItem, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateNextCycle$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateNextCycle, unknown>;
declare function previewMultiUpdateNextCycleFromJSON(jsonString: string): Result$1<PreviewMultiUpdateNextCycle, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateIncomingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateIncomingFeatureQuantity, unknown>;
declare function previewMultiUpdateIncomingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewMultiUpdateIncomingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateIncoming$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateIncoming, unknown>;
declare function previewMultiUpdateIncomingFromJSON(jsonString: string): Result$1<PreviewMultiUpdateIncoming, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateOutgoingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateOutgoingFeatureQuantity, unknown>;
declare function previewMultiUpdateOutgoingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewMultiUpdateOutgoingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateOutgoing$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateOutgoing, unknown>;
declare function previewMultiUpdateOutgoingFromJSON(jsonString: string): Result$1<PreviewMultiUpdateOutgoing, SDKValidationError>;
/** @internal */
declare const PreviewMultiUpdateSubscription$inboundSchema: z$1.ZodMiniType<PreviewMultiUpdateSubscription, unknown>;
declare function previewMultiUpdateSubscriptionFromJSON(jsonString: string): Result$1<PreviewMultiUpdateSubscription, SDKValidationError>;
/** @internal */
declare const MultiUpdatePreviewResponse$inboundSchema: z$1.ZodMiniType<MultiUpdatePreviewResponse, unknown>;
declare function multiUpdatePreviewResponseFromJSON(jsonString: string): Result$1<MultiUpdatePreviewResponse, SDKValidationError>;

type PreviewUpdateGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type PreviewUpdateFeatureQuantityRequest = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const PreviewUpdatePriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type PreviewUpdatePriceInterval = ClosedEnum<typeof PreviewUpdatePriceInterval>;
/**
 * Base price configuration for a plan.
 */
type PreviewUpdateBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: PreviewUpdatePriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const PreviewUpdateItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type PreviewUpdateItemResetInterval = ClosedEnum<typeof PreviewUpdateItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type PreviewUpdateItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: PreviewUpdateItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type PreviewUpdateItemTo = number | string;
type PreviewUpdateItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const PreviewUpdateItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type PreviewUpdateItemTierBehavior = ClosedEnum<typeof PreviewUpdateItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const PreviewUpdateItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type PreviewUpdateItemPriceInterval = ClosedEnum<typeof PreviewUpdateItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const PreviewUpdateItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type PreviewUpdateItemBillingMethod = ClosedEnum<typeof PreviewUpdateItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type PreviewUpdateItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<PreviewUpdateItemTier> | undefined;
    tierBehavior?: PreviewUpdateItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: PreviewUpdateItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: PreviewUpdateItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const PreviewUpdateItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type PreviewUpdateItemOnIncrease = ClosedEnum<typeof PreviewUpdateItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const PreviewUpdateItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type PreviewUpdateItemOnDecrease = ClosedEnum<typeof PreviewUpdateItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type PreviewUpdateItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: PreviewUpdateItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: PreviewUpdateItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const PreviewUpdateItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type PreviewUpdateItemExpiryDurationType = ClosedEnum<typeof PreviewUpdateItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type PreviewUpdateItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: PreviewUpdateItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type PreviewUpdateItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: PreviewUpdateItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: PreviewUpdateItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: PreviewUpdateItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: PreviewUpdateItemRollover | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const PreviewUpdateAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type PreviewUpdateAddItemResetInterval = ClosedEnum<typeof PreviewUpdateAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type PreviewUpdateAddItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: PreviewUpdateAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type PreviewUpdateAddItemTo = number | string;
type PreviewUpdateAddItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const PreviewUpdateAddItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type PreviewUpdateAddItemTierBehavior = ClosedEnum<typeof PreviewUpdateAddItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const PreviewUpdateAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type PreviewUpdateAddItemPriceInterval = ClosedEnum<typeof PreviewUpdateAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const PreviewUpdateAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type PreviewUpdateAddItemBillingMethod = ClosedEnum<typeof PreviewUpdateAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type PreviewUpdateAddItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<PreviewUpdateAddItemTier> | undefined;
    tierBehavior?: PreviewUpdateAddItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: PreviewUpdateAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: PreviewUpdateAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const PreviewUpdateAddItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type PreviewUpdateAddItemOnIncrease = ClosedEnum<typeof PreviewUpdateAddItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const PreviewUpdateAddItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type PreviewUpdateAddItemOnDecrease = ClosedEnum<typeof PreviewUpdateAddItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type PreviewUpdateAddItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: PreviewUpdateAddItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: PreviewUpdateAddItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const PreviewUpdateAddItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type PreviewUpdateAddItemExpiryDurationType = ClosedEnum<typeof PreviewUpdateAddItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type PreviewUpdateAddItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: PreviewUpdateAddItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type PreviewUpdateAddItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: PreviewUpdateAddItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: PreviewUpdateAddItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: PreviewUpdateAddItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: PreviewUpdateAddItemRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const PreviewUpdateRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type PreviewUpdateRemoveItemBillingMethod = ClosedEnum<typeof PreviewUpdateRemoveItemBillingMethod>;
declare const PreviewUpdateIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type PreviewUpdateIntervalRemoveItemEnum2 = ClosedEnum<typeof PreviewUpdateIntervalRemoveItemEnum2>;
declare const PreviewUpdateIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type PreviewUpdateIntervalRemoveItemEnum1 = ClosedEnum<typeof PreviewUpdateIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type PreviewUpdateIntervalUnion = PreviewUpdateIntervalRemoveItemEnum1 | PreviewUpdateIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type PreviewUpdatePlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: PreviewUpdateRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: PreviewUpdateIntervalRemoveItemEnum1 | PreviewUpdateIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const PreviewUpdateDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type PreviewUpdateDurationType = ClosedEnum<typeof PreviewUpdateDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const PreviewUpdateOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type PreviewUpdateOnEnd = ClosedEnum<typeof PreviewUpdateOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type PreviewUpdateFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: PreviewUpdateDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: PreviewUpdateOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const PreviewUpdatePurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type PreviewUpdatePurchaseLimitInterval = ClosedEnum<typeof PreviewUpdatePurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type PreviewUpdatePurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: PreviewUpdatePurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type PreviewUpdateAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: PreviewUpdatePurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const PreviewUpdateLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type PreviewUpdateLimitType = ClosedEnum<typeof PreviewUpdateLimitType>;
type PreviewUpdateSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: PreviewUpdateLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const PreviewUpdateUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type PreviewUpdateUsageLimitInterval = ClosedEnum<typeof PreviewUpdateUsageLimitInterval>;
type PreviewUpdateProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type PreviewUpdateFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type PreviewUpdateUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: PreviewUpdateUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: PreviewUpdateFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const PreviewUpdateThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type PreviewUpdateThresholdType = ClosedEnum<typeof PreviewUpdateThresholdType>;
type PreviewUpdateUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: PreviewUpdateThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type PreviewUpdateOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type PreviewUpdateBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<PreviewUpdateAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<PreviewUpdateSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<PreviewUpdateUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<PreviewUpdateUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<PreviewUpdateOverageAllowed> | undefined;
};
/**
 * Customize the plan to attach. Can override the price, items, free trial, or a combination.
 */
type PreviewUpdateCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: PreviewUpdateBasePrice | null | undefined;
    /**
     * Override the items in the plan (PUT-style — replaces all existing items). Mutually exclusive with add_items / remove_items / deprecated update_items.
     */
    items?: Array<PreviewUpdateItemPlanItem> | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<PreviewUpdateAddItemPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<PreviewUpdatePlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: PreviewUpdateFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: PreviewUpdateBillingControls | undefined;
};
/**
 * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
 */
type PreviewUpdateInvoiceMode = {
    /**
     * When true, creates an invoice and sends it to the customer instead of charging their card immediately. Uses Stripe's send_invoice collection method.
     */
    enabled: boolean;
    /**
     * If true, enables the plan immediately even though the invoice is not paid yet.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * If true, finalizes the invoice so it can be sent to the customer. If false, keeps it as a draft for manual review.
     */
    finalize?: boolean | undefined;
    /**
     * ID of an invoice template (configured in billing settings) whose footer (e.g. bank details) is applied to the invoice.
     */
    invoiceTemplateId?: string | undefined;
    /**
     * Number of days the customer has to pay the invoice before it is due (Stripe days_until_due).
     */
    netTermsDays?: number | undefined;
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
declare const PreviewUpdateProrationBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
type PreviewUpdateProrationBehavior = ClosedEnum<typeof PreviewUpdateProrationBehavior>;
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
declare const PreviewUpdateRedirectMode: {
    readonly Always: "always";
    readonly IfRequired: "if_required";
    readonly Never: "never";
};
/**
 * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
 */
type PreviewUpdateRedirectMode = ClosedEnum<typeof PreviewUpdateRedirectMode>;
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type PreviewUpdateAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
declare const PreviewUpdateCancelAction: {
    readonly CancelImmediately: "cancel_immediately";
    readonly CancelEndOfCycle: "cancel_end_of_cycle";
    readonly Uncancel: "uncancel";
};
/**
 * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
 */
type PreviewUpdateCancelAction = ClosedEnum<typeof PreviewUpdateCancelAction>;
/**
 * Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment.
 */
declare const PreviewUpdateRefundLastPayment: {
    readonly Prorated: "prorated";
    readonly Full: "full";
};
/**
 * Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment.
 */
type PreviewUpdateRefundLastPayment = ClosedEnum<typeof PreviewUpdateRefundLastPayment>;
/**
 * Controls whether balances should be recalculated during the subscription update.
 */
type PreviewUpdateRecalculateBalances = {
    /**
     * If true, recalculates balances during the subscription update. Only applicable when updating feature quantities.
     */
    enabled: boolean;
};
/**
 * Whether to carry over usages from the previous plan.
 */
type PreviewUpdateCarryOverUsages = {
    /**
     * Whether to carry over usages from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over usages for. If left undefined, all consumable features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
type PreviewUpdateParams = {
    /**
     * The ID of the customer to attach the plan to.
     */
    customerId: string;
    /**
     * The ID of the entity to attach the plan to.
     */
    entityId?: string | undefined;
    /**
     * The ID of the plan to update. Optional if subscription_id is provided, or if the customer has only one product.
     */
    planId?: string | undefined;
    /**
     * If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan.
     */
    featureQuantities?: Array<PreviewUpdateFeatureQuantityRequest> | undefined;
    /**
     * The version of the plan to attach.
     */
    version?: number | undefined;
    /**
     * Customize the plan to attach. Can override the price, items, free trial, or a combination.
     */
    customize?: PreviewUpdateCustomize | undefined;
    /**
     * Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method.
     */
    invoiceMode?: PreviewUpdateInvoiceMode | undefined;
    /**
     * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
     */
    prorationBehavior?: PreviewUpdateProrationBehavior | undefined;
    /**
     * Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects.
     */
    redirectMode?: PreviewUpdateRedirectMode | undefined;
    /**
     * A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan.
     */
    subscriptionId?: string | undefined;
    /**
     * List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<PreviewUpdateAttachDiscount> | undefined;
    /**
     * Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation.
     */
    cancelAction?: PreviewUpdateCancelAction | undefined;
    /**
     * Reset the billing cycle anchor immediately with 'now'
     */
    billingCycleAnchor?: "now" | undefined;
    /**
     * If true, the subscription is updated internally without applying billing changes in Stripe.
     */
    noBillingChanges?: boolean | undefined;
    /**
     * Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment.
     */
    refundLastPayment?: PreviewUpdateRefundLastPayment | undefined;
    /**
     * Controls whether balances should be recalculated during the subscription update.
     */
    recalculateBalances?: PreviewUpdateRecalculateBalances | undefined;
    /**
     * Whether to carry over usages from the previous plan.
     */
    carryOverUsages?: PreviewUpdateCarryOverUsages | undefined;
};
type PreviewUpdateDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewUpdateLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewUpdateLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewUpdateDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewUpdateLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
type PreviewUpdateNextCycleDiscount = {
    amountOff: number;
    percentOff?: number | undefined;
    rewardId?: string | undefined;
    rewardName?: string | undefined;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewUpdateNextCycleLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewUpdateNextCycleLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * A detailed description of the line item.
     */
    description: string;
    /**
     * The amount in cents before discounts and tax for this line item.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for this line item.
     */
    total: number;
    /**
     * List of discounts applied to this line item.
     */
    discounts?: Array<PreviewUpdateNextCycleDiscount> | undefined;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewUpdateNextCycleLineItemPeriod | undefined;
    /**
     * The quantity of the line item.
     */
    quantity: number;
};
/**
 * The period of time that this line item is being charged for.
 */
type PreviewUpdateUsageLineItemPeriod = {
    /**
     * The start of the period in milliseconds since the Unix epoch.
     */
    start: number;
    /**
     * The end of the period in milliseconds since the Unix epoch.
     */
    end: number;
};
type PreviewUpdateUsageLineItem = {
    /**
     * The name of the line item to display to the customer if you're building a UI. It will either be the plan name or the feature name.
     */
    displayName: string;
    /**
     * The ID of the plan that this line item belongs to.
     */
    planId: string;
    /**
     * The ID of the feature that this line item belongs to.
     */
    featureId: string | null;
    /**
     * The period of time that this line item is being charged for.
     */
    period?: PreviewUpdateUsageLineItemPeriod | undefined;
};
/**
 * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
 */
type PreviewUpdateNextCycle = {
    /**
     * Unix timestamp (milliseconds) when the next billing cycle starts.
     */
    startsAt: number;
    /**
     * The total amount in cents before discounts and tax for the next cycle.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the next cycle.
     */
    total: number;
    /**
     * List of line items for the next billing cycle.
     */
    lineItems: Array<PreviewUpdateNextCycleLineItem>;
    /**
     * List of line items for usage-based features in the next cycle.
     */
    usageLineItems: Array<PreviewUpdateUsageLineItem>;
};
type PreviewUpdateIncomingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewUpdateIncoming = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewUpdateIncomingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
type PreviewUpdateOutgoingFeatureQuantity = {
    /**
     * The ID of the adjustable feature included in this change.
     */
    featureId: string;
    /**
     * The quantity that will apply for this feature in the change.
     */
    quantity: number;
};
type PreviewUpdateOutgoing = {
    /**
     * The ID of the plan affected by this preview change.
     */
    planId: string;
    plan?: Plan | undefined;
    /**
     * The feature quantity selections associated with this plan change.
     */
    featureQuantities: Array<PreviewUpdateOutgoingFeatureQuantity>;
    /**
     * When this change takes effect, in milliseconds since the Unix epoch, or null if it applies immediately.
     */
    effectiveAt: number | null;
    /**
     * When this plan was canceled, in milliseconds since the Unix epoch, or null if it is not canceled.
     */
    canceledAt: number | null;
    /**
     * When this plan expires, in milliseconds since the Unix epoch, or null if it does not expire.
     */
    expiresAt: number | null;
};
declare const Intent: {
    readonly UpdatePlan: "update_plan";
    readonly UpdateQuantity: "update_quantity";
    readonly CancelImmediately: "cancel_immediately";
    readonly CancelEndOfCycle: "cancel_end_of_cycle";
    readonly Uncancel: "uncancel";
    readonly None: "none";
};
type Intent = OpenEnum<typeof Intent>;
/**
 * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
 */
declare const PreviewUpdateStatus: {
    readonly Complete: "complete";
    readonly Incomplete: "incomplete";
};
/**
 * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
 */
type PreviewUpdateStatus = OpenEnum<typeof PreviewUpdateStatus>;
/**
 * Tax preview for the immediate charge. Contact us to enable the tax flag on your organisation. Shows only with flag enabled, a Stripe customer exists and has a location.
 */
type PreviewUpdateTax = {
    /**
     * Total tax amount in major currency units.
     */
    total: number;
    /**
     * Tax included in line item subtotals.
     */
    amountInclusive: number;
    /**
     * Tax added on top of subtotals.
     */
    amountExclusive: number;
    /**
     * Three-letter currency code.
     */
    currency: string;
    /**
     * Calculation status ('complete' when Stripe Tax succeeds or 'incomplete' when Stripe Tax returned 0 or errored).
     */
    status: PreviewUpdateStatus;
};
/**
 * Stripe customer invoice credits preview.
 */
type PreviewUpdateInvoiceCredits = {
    /**
     * Stripe customer credit balance available, expressed as a positive number in major currency units.
     */
    balance: number;
    /**
     * Three-letter currency code.
     */
    currency: string;
};
/**
 * OK
 */
type PreviewUpdateResponse = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * List of line items for the current billing period.
     */
    lineItems: Array<PreviewUpdateLineItem>;
    /**
     * The total amount in cents before discounts and tax for the current billing period.
     */
    subtotal: number;
    /**
     * The final amount in cents after discounts and tax for the current billing period.
     */
    total: number;
    /**
     * The three-letter ISO currency code (e.g., 'usd').
     */
    currency: string;
    /**
     * Preview of the next billing cycle, if applicable. This shows what the customer will be charged in subsequent cycles.
     */
    nextCycle?: PreviewUpdateNextCycle | undefined;
    /**
     * Expand the response with additional data.
     */
    expand?: Array<string> | undefined;
    /**
     * Products or subscription changes being added or updated.
     */
    incoming: Array<PreviewUpdateIncoming>;
    /**
     * Products or subscription changes being removed or ended.
     */
    outgoing: Array<PreviewUpdateOutgoing>;
    intent: Intent;
    /**
     * Tax preview for the immediate charge. Contact us to enable the tax flag on your organisation. Shows only with flag enabled, a Stripe customer exists and has a location.
     */
    tax?: PreviewUpdateTax | undefined;
    /**
     * Stripe customer invoice credits preview.
     */
    invoiceCredits?: PreviewUpdateInvoiceCredits | undefined;
};
/** @internal */
type PreviewUpdateFeatureQuantityRequest$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const PreviewUpdateFeatureQuantityRequest$outboundSchema: z$1.ZodMiniType<PreviewUpdateFeatureQuantityRequest$Outbound, PreviewUpdateFeatureQuantityRequest>;
declare function previewUpdateFeatureQuantityRequestToJSON(previewUpdateFeatureQuantityRequest: PreviewUpdateFeatureQuantityRequest): string;
/** @internal */
declare const PreviewUpdatePriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdatePriceInterval>;
/** @internal */
type PreviewUpdateBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewUpdateBasePrice$outboundSchema: z$1.ZodMiniType<PreviewUpdateBasePrice$Outbound, PreviewUpdateBasePrice>;
declare function previewUpdateBasePriceToJSON(previewUpdateBasePrice: PreviewUpdateBasePrice): string;
/** @internal */
declare const PreviewUpdateItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateItemResetInterval>;
/** @internal */
type PreviewUpdateItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewUpdateItemReset$outboundSchema: z$1.ZodMiniType<PreviewUpdateItemReset$Outbound, PreviewUpdateItemReset>;
declare function previewUpdateItemResetToJSON(previewUpdateItemReset: PreviewUpdateItemReset): string;
/** @internal */
type PreviewUpdateItemTo$Outbound = number | string;
/** @internal */
declare const PreviewUpdateItemTo$outboundSchema: z$1.ZodMiniType<PreviewUpdateItemTo$Outbound, PreviewUpdateItemTo>;
declare function previewUpdateItemToToJSON(previewUpdateItemTo: PreviewUpdateItemTo): string;
/** @internal */
type PreviewUpdateItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const PreviewUpdateItemTier$outboundSchema: z$1.ZodMiniType<PreviewUpdateItemTier$Outbound, PreviewUpdateItemTier>;
declare function previewUpdateItemTierToJSON(previewUpdateItemTier: PreviewUpdateItemTier): string;
/** @internal */
declare const PreviewUpdateItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateItemTierBehavior>;
/** @internal */
declare const PreviewUpdateItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateItemPriceInterval>;
/** @internal */
declare const PreviewUpdateItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateItemBillingMethod>;
/** @internal */
type PreviewUpdateItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<PreviewUpdateItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const PreviewUpdateItemPrice$outboundSchema: z$1.ZodMiniType<PreviewUpdateItemPrice$Outbound, PreviewUpdateItemPrice>;
declare function previewUpdateItemPriceToJSON(previewUpdateItemPrice: PreviewUpdateItemPrice): string;
/** @internal */
declare const PreviewUpdateItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateItemOnIncrease>;
/** @internal */
declare const PreviewUpdateItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateItemOnDecrease>;
/** @internal */
type PreviewUpdateItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const PreviewUpdateItemProration$outboundSchema: z$1.ZodMiniType<PreviewUpdateItemProration$Outbound, PreviewUpdateItemProration>;
declare function previewUpdateItemProrationToJSON(previewUpdateItemProration: PreviewUpdateItemProration): string;
/** @internal */
declare const PreviewUpdateItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateItemExpiryDurationType>;
/** @internal */
type PreviewUpdateItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const PreviewUpdateItemRollover$outboundSchema: z$1.ZodMiniType<PreviewUpdateItemRollover$Outbound, PreviewUpdateItemRollover>;
declare function previewUpdateItemRolloverToJSON(previewUpdateItemRollover: PreviewUpdateItemRollover): string;
/** @internal */
type PreviewUpdateItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: PreviewUpdateItemReset$Outbound | undefined;
    price?: PreviewUpdateItemPrice$Outbound | undefined;
    proration?: PreviewUpdateItemProration$Outbound | undefined;
    rollover?: PreviewUpdateItemRollover$Outbound | undefined;
};
/** @internal */
declare const PreviewUpdateItemPlanItem$outboundSchema: z$1.ZodMiniType<PreviewUpdateItemPlanItem$Outbound, PreviewUpdateItemPlanItem>;
declare function previewUpdateItemPlanItemToJSON(previewUpdateItemPlanItem: PreviewUpdateItemPlanItem): string;
/** @internal */
declare const PreviewUpdateAddItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateAddItemResetInterval>;
/** @internal */
type PreviewUpdateAddItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewUpdateAddItemReset$outboundSchema: z$1.ZodMiniType<PreviewUpdateAddItemReset$Outbound, PreviewUpdateAddItemReset>;
declare function previewUpdateAddItemResetToJSON(previewUpdateAddItemReset: PreviewUpdateAddItemReset): string;
/** @internal */
type PreviewUpdateAddItemTo$Outbound = number | string;
/** @internal */
declare const PreviewUpdateAddItemTo$outboundSchema: z$1.ZodMiniType<PreviewUpdateAddItemTo$Outbound, PreviewUpdateAddItemTo>;
declare function previewUpdateAddItemToToJSON(previewUpdateAddItemTo: PreviewUpdateAddItemTo): string;
/** @internal */
type PreviewUpdateAddItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const PreviewUpdateAddItemTier$outboundSchema: z$1.ZodMiniType<PreviewUpdateAddItemTier$Outbound, PreviewUpdateAddItemTier>;
declare function previewUpdateAddItemTierToJSON(previewUpdateAddItemTier: PreviewUpdateAddItemTier): string;
/** @internal */
declare const PreviewUpdateAddItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateAddItemTierBehavior>;
/** @internal */
declare const PreviewUpdateAddItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateAddItemPriceInterval>;
/** @internal */
declare const PreviewUpdateAddItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateAddItemBillingMethod>;
/** @internal */
type PreviewUpdateAddItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<PreviewUpdateAddItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const PreviewUpdateAddItemPrice$outboundSchema: z$1.ZodMiniType<PreviewUpdateAddItemPrice$Outbound, PreviewUpdateAddItemPrice>;
declare function previewUpdateAddItemPriceToJSON(previewUpdateAddItemPrice: PreviewUpdateAddItemPrice): string;
/** @internal */
declare const PreviewUpdateAddItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateAddItemOnIncrease>;
/** @internal */
declare const PreviewUpdateAddItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateAddItemOnDecrease>;
/** @internal */
type PreviewUpdateAddItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const PreviewUpdateAddItemProration$outboundSchema: z$1.ZodMiniType<PreviewUpdateAddItemProration$Outbound, PreviewUpdateAddItemProration>;
declare function previewUpdateAddItemProrationToJSON(previewUpdateAddItemProration: PreviewUpdateAddItemProration): string;
/** @internal */
declare const PreviewUpdateAddItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateAddItemExpiryDurationType>;
/** @internal */
type PreviewUpdateAddItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const PreviewUpdateAddItemRollover$outboundSchema: z$1.ZodMiniType<PreviewUpdateAddItemRollover$Outbound, PreviewUpdateAddItemRollover>;
declare function previewUpdateAddItemRolloverToJSON(previewUpdateAddItemRollover: PreviewUpdateAddItemRollover): string;
/** @internal */
type PreviewUpdateAddItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: PreviewUpdateAddItemReset$Outbound | undefined;
    price?: PreviewUpdateAddItemPrice$Outbound | undefined;
    proration?: PreviewUpdateAddItemProration$Outbound | undefined;
    rollover?: PreviewUpdateAddItemRollover$Outbound | undefined;
};
/** @internal */
declare const PreviewUpdateAddItemPlanItem$outboundSchema: z$1.ZodMiniType<PreviewUpdateAddItemPlanItem$Outbound, PreviewUpdateAddItemPlanItem>;
declare function previewUpdateAddItemPlanItemToJSON(previewUpdateAddItemPlanItem: PreviewUpdateAddItemPlanItem): string;
/** @internal */
declare const PreviewUpdateRemoveItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateRemoveItemBillingMethod>;
/** @internal */
declare const PreviewUpdateIntervalRemoveItemEnum2$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateIntervalRemoveItemEnum2>;
/** @internal */
declare const PreviewUpdateIntervalRemoveItemEnum1$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateIntervalRemoveItemEnum1>;
/** @internal */
type PreviewUpdateIntervalUnion$Outbound = string | string;
/** @internal */
declare const PreviewUpdateIntervalUnion$outboundSchema: z$1.ZodMiniType<PreviewUpdateIntervalUnion$Outbound, PreviewUpdateIntervalUnion>;
declare function previewUpdateIntervalUnionToJSON(previewUpdateIntervalUnion: PreviewUpdateIntervalUnion): string;
/** @internal */
type PreviewUpdatePlanItemFilter$Outbound = {
    feature_id?: string | undefined;
    billing_method?: string | undefined;
    interval?: string | string | undefined;
    interval_count?: number | undefined;
};
/** @internal */
declare const PreviewUpdatePlanItemFilter$outboundSchema: z$1.ZodMiniType<PreviewUpdatePlanItemFilter$Outbound, PreviewUpdatePlanItemFilter>;
declare function previewUpdatePlanItemFilterToJSON(previewUpdatePlanItemFilter: PreviewUpdatePlanItemFilter): string;
/** @internal */
declare const PreviewUpdateDurationType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateDurationType>;
/** @internal */
declare const PreviewUpdateOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateOnEnd>;
/** @internal */
type PreviewUpdateFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const PreviewUpdateFreeTrialParams$outboundSchema: z$1.ZodMiniType<PreviewUpdateFreeTrialParams$Outbound, PreviewUpdateFreeTrialParams>;
declare function previewUpdateFreeTrialParamsToJSON(previewUpdateFreeTrialParams: PreviewUpdateFreeTrialParams): string;
/** @internal */
declare const PreviewUpdatePurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdatePurchaseLimitInterval>;
/** @internal */
type PreviewUpdatePurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const PreviewUpdatePurchaseLimit$outboundSchema: z$1.ZodMiniType<PreviewUpdatePurchaseLimit$Outbound, PreviewUpdatePurchaseLimit>;
declare function previewUpdatePurchaseLimitToJSON(previewUpdatePurchaseLimit: PreviewUpdatePurchaseLimit): string;
/** @internal */
type PreviewUpdateAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: PreviewUpdatePurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const PreviewUpdateAutoTopup$outboundSchema: z$1.ZodMiniType<PreviewUpdateAutoTopup$Outbound, PreviewUpdateAutoTopup>;
declare function previewUpdateAutoTopupToJSON(previewUpdateAutoTopup: PreviewUpdateAutoTopup): string;
/** @internal */
declare const PreviewUpdateLimitType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateLimitType>;
/** @internal */
type PreviewUpdateSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const PreviewUpdateSpendLimit$outboundSchema: z$1.ZodMiniType<PreviewUpdateSpendLimit$Outbound, PreviewUpdateSpendLimit>;
declare function previewUpdateSpendLimitToJSON(previewUpdateSpendLimit: PreviewUpdateSpendLimit): string;
/** @internal */
declare const PreviewUpdateUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateUsageLimitInterval>;
/** @internal */
type PreviewUpdateProperties$Outbound = string | number | boolean;
/** @internal */
declare const PreviewUpdateProperties$outboundSchema: z$1.ZodMiniType<PreviewUpdateProperties$Outbound, PreviewUpdateProperties>;
declare function previewUpdatePropertiesToJSON(previewUpdateProperties: PreviewUpdateProperties): string;
/** @internal */
type PreviewUpdateFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const PreviewUpdateFilter$outboundSchema: z$1.ZodMiniType<PreviewUpdateFilter$Outbound, PreviewUpdateFilter>;
declare function previewUpdateFilterToJSON(previewUpdateFilter: PreviewUpdateFilter): string;
/** @internal */
type PreviewUpdateUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: PreviewUpdateFilter$Outbound | undefined;
};
/** @internal */
declare const PreviewUpdateUsageLimit$outboundSchema: z$1.ZodMiniType<PreviewUpdateUsageLimit$Outbound, PreviewUpdateUsageLimit>;
declare function previewUpdateUsageLimitToJSON(previewUpdateUsageLimit: PreviewUpdateUsageLimit): string;
/** @internal */
declare const PreviewUpdateThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateThresholdType>;
/** @internal */
type PreviewUpdateUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const PreviewUpdateUsageAlert$outboundSchema: z$1.ZodMiniType<PreviewUpdateUsageAlert$Outbound, PreviewUpdateUsageAlert>;
declare function previewUpdateUsageAlertToJSON(previewUpdateUsageAlert: PreviewUpdateUsageAlert): string;
/** @internal */
type PreviewUpdateOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const PreviewUpdateOverageAllowed$outboundSchema: z$1.ZodMiniType<PreviewUpdateOverageAllowed$Outbound, PreviewUpdateOverageAllowed>;
declare function previewUpdateOverageAllowedToJSON(previewUpdateOverageAllowed: PreviewUpdateOverageAllowed): string;
/** @internal */
type PreviewUpdateBillingControls$Outbound = {
    auto_topups?: Array<PreviewUpdateAutoTopup$Outbound> | undefined;
    spend_limits?: Array<PreviewUpdateSpendLimit$Outbound> | undefined;
    usage_limits?: Array<PreviewUpdateUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<PreviewUpdateUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<PreviewUpdateOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const PreviewUpdateBillingControls$outboundSchema: z$1.ZodMiniType<PreviewUpdateBillingControls$Outbound, PreviewUpdateBillingControls>;
declare function previewUpdateBillingControlsToJSON(previewUpdateBillingControls: PreviewUpdateBillingControls): string;
/** @internal */
type PreviewUpdateCustomize$Outbound = {
    price?: PreviewUpdateBasePrice$Outbound | null | undefined;
    items?: Array<PreviewUpdateItemPlanItem$Outbound> | undefined;
    add_items?: Array<PreviewUpdateAddItemPlanItem$Outbound> | undefined;
    remove_items?: Array<PreviewUpdatePlanItemFilter$Outbound> | undefined;
    free_trial?: PreviewUpdateFreeTrialParams$Outbound | null | undefined;
    billing_controls?: PreviewUpdateBillingControls$Outbound | undefined;
};
/** @internal */
declare const PreviewUpdateCustomize$outboundSchema: z$1.ZodMiniType<PreviewUpdateCustomize$Outbound, PreviewUpdateCustomize>;
declare function previewUpdateCustomizeToJSON(previewUpdateCustomize: PreviewUpdateCustomize): string;
/** @internal */
type PreviewUpdateInvoiceMode$Outbound = {
    enabled: boolean;
    enable_plan_immediately: boolean;
    finalize: boolean;
    invoice_template_id?: string | undefined;
    net_terms_days?: number | undefined;
};
/** @internal */
declare const PreviewUpdateInvoiceMode$outboundSchema: z$1.ZodMiniType<PreviewUpdateInvoiceMode$Outbound, PreviewUpdateInvoiceMode>;
declare function previewUpdateInvoiceModeToJSON(previewUpdateInvoiceMode: PreviewUpdateInvoiceMode): string;
/** @internal */
declare const PreviewUpdateProrationBehavior$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateProrationBehavior>;
/** @internal */
declare const PreviewUpdateRedirectMode$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateRedirectMode>;
/** @internal */
type PreviewUpdateAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const PreviewUpdateAttachDiscount$outboundSchema: z$1.ZodMiniType<PreviewUpdateAttachDiscount$Outbound, PreviewUpdateAttachDiscount>;
declare function previewUpdateAttachDiscountToJSON(previewUpdateAttachDiscount: PreviewUpdateAttachDiscount): string;
/** @internal */
declare const PreviewUpdateCancelAction$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateCancelAction>;
/** @internal */
declare const PreviewUpdateRefundLastPayment$outboundSchema: z$1.ZodMiniEnum<typeof PreviewUpdateRefundLastPayment>;
/** @internal */
type PreviewUpdateRecalculateBalances$Outbound = {
    enabled: boolean;
};
/** @internal */
declare const PreviewUpdateRecalculateBalances$outboundSchema: z$1.ZodMiniType<PreviewUpdateRecalculateBalances$Outbound, PreviewUpdateRecalculateBalances>;
declare function previewUpdateRecalculateBalancesToJSON(previewUpdateRecalculateBalances: PreviewUpdateRecalculateBalances): string;
/** @internal */
type PreviewUpdateCarryOverUsages$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const PreviewUpdateCarryOverUsages$outboundSchema: z$1.ZodMiniType<PreviewUpdateCarryOverUsages$Outbound, PreviewUpdateCarryOverUsages>;
declare function previewUpdateCarryOverUsagesToJSON(previewUpdateCarryOverUsages: PreviewUpdateCarryOverUsages): string;
/** @internal */
type PreviewUpdateParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    plan_id?: string | undefined;
    feature_quantities?: Array<PreviewUpdateFeatureQuantityRequest$Outbound> | undefined;
    version?: number | undefined;
    customize?: PreviewUpdateCustomize$Outbound | undefined;
    invoice_mode?: PreviewUpdateInvoiceMode$Outbound | undefined;
    proration_behavior?: string | undefined;
    redirect_mode: string;
    subscription_id?: string | undefined;
    discounts?: Array<PreviewUpdateAttachDiscount$Outbound> | undefined;
    cancel_action?: string | undefined;
    billing_cycle_anchor?: "now" | undefined;
    no_billing_changes?: boolean | undefined;
    refund_last_payment?: string | undefined;
    recalculate_balances?: PreviewUpdateRecalculateBalances$Outbound | undefined;
    carry_over_usages?: PreviewUpdateCarryOverUsages$Outbound | undefined;
};
/** @internal */
declare const PreviewUpdateParams$outboundSchema: z$1.ZodMiniType<PreviewUpdateParams$Outbound, PreviewUpdateParams>;
declare function previewUpdateParamsToJSON(previewUpdateParams: PreviewUpdateParams): string;
/** @internal */
declare const PreviewUpdateDiscount$inboundSchema: z$1.ZodMiniType<PreviewUpdateDiscount, unknown>;
declare function previewUpdateDiscountFromJSON(jsonString: string): Result$1<PreviewUpdateDiscount, SDKValidationError>;
/** @internal */
declare const PreviewUpdateLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewUpdateLineItemPeriod, unknown>;
declare function previewUpdateLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewUpdateLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewUpdateLineItem$inboundSchema: z$1.ZodMiniType<PreviewUpdateLineItem, unknown>;
declare function previewUpdateLineItemFromJSON(jsonString: string): Result$1<PreviewUpdateLineItem, SDKValidationError>;
/** @internal */
declare const PreviewUpdateNextCycleDiscount$inboundSchema: z$1.ZodMiniType<PreviewUpdateNextCycleDiscount, unknown>;
declare function previewUpdateNextCycleDiscountFromJSON(jsonString: string): Result$1<PreviewUpdateNextCycleDiscount, SDKValidationError>;
/** @internal */
declare const PreviewUpdateNextCycleLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewUpdateNextCycleLineItemPeriod, unknown>;
declare function previewUpdateNextCycleLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewUpdateNextCycleLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewUpdateNextCycleLineItem$inboundSchema: z$1.ZodMiniType<PreviewUpdateNextCycleLineItem, unknown>;
declare function previewUpdateNextCycleLineItemFromJSON(jsonString: string): Result$1<PreviewUpdateNextCycleLineItem, SDKValidationError>;
/** @internal */
declare const PreviewUpdateUsageLineItemPeriod$inboundSchema: z$1.ZodMiniType<PreviewUpdateUsageLineItemPeriod, unknown>;
declare function previewUpdateUsageLineItemPeriodFromJSON(jsonString: string): Result$1<PreviewUpdateUsageLineItemPeriod, SDKValidationError>;
/** @internal */
declare const PreviewUpdateUsageLineItem$inboundSchema: z$1.ZodMiniType<PreviewUpdateUsageLineItem, unknown>;
declare function previewUpdateUsageLineItemFromJSON(jsonString: string): Result$1<PreviewUpdateUsageLineItem, SDKValidationError>;
/** @internal */
declare const PreviewUpdateNextCycle$inboundSchema: z$1.ZodMiniType<PreviewUpdateNextCycle, unknown>;
declare function previewUpdateNextCycleFromJSON(jsonString: string): Result$1<PreviewUpdateNextCycle, SDKValidationError>;
/** @internal */
declare const PreviewUpdateIncomingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewUpdateIncomingFeatureQuantity, unknown>;
declare function previewUpdateIncomingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewUpdateIncomingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewUpdateIncoming$inboundSchema: z$1.ZodMiniType<PreviewUpdateIncoming, unknown>;
declare function previewUpdateIncomingFromJSON(jsonString: string): Result$1<PreviewUpdateIncoming, SDKValidationError>;
/** @internal */
declare const PreviewUpdateOutgoingFeatureQuantity$inboundSchema: z$1.ZodMiniType<PreviewUpdateOutgoingFeatureQuantity, unknown>;
declare function previewUpdateOutgoingFeatureQuantityFromJSON(jsonString: string): Result$1<PreviewUpdateOutgoingFeatureQuantity, SDKValidationError>;
/** @internal */
declare const PreviewUpdateOutgoing$inboundSchema: z$1.ZodMiniType<PreviewUpdateOutgoing, unknown>;
declare function previewUpdateOutgoingFromJSON(jsonString: string): Result$1<PreviewUpdateOutgoing, SDKValidationError>;
/** @internal */
declare const Intent$inboundSchema: z$1.ZodMiniType<Intent, unknown>;
/** @internal */
declare const PreviewUpdateStatus$inboundSchema: z$1.ZodMiniType<PreviewUpdateStatus, unknown>;
/** @internal */
declare const PreviewUpdateTax$inboundSchema: z$1.ZodMiniType<PreviewUpdateTax, unknown>;
declare function previewUpdateTaxFromJSON(jsonString: string): Result$1<PreviewUpdateTax, SDKValidationError>;
/** @internal */
declare const PreviewUpdateInvoiceCredits$inboundSchema: z$1.ZodMiniType<PreviewUpdateInvoiceCredits, unknown>;
declare function previewUpdateInvoiceCreditsFromJSON(jsonString: string): Result$1<PreviewUpdateInvoiceCredits, SDKValidationError>;
/** @internal */
declare const PreviewUpdateResponse$inboundSchema: z$1.ZodMiniType<PreviewUpdateResponse, unknown>;
declare function previewUpdateResponseFromJSON(jsonString: string): Result$1<PreviewUpdateResponse, SDKValidationError>;

type RedeemReferralCodeGlobals = {
    xApiVersion?: string | undefined;
};
type RedeemReferralCodeParams = {
    /**
     * The referral code to redeem
     */
    code: string;
    /**
     * The unique identifier of the customer redeeming the code
     */
    customerId: string;
};
/**
 * OK
 */
type RedeemReferralCodeResponse = {
    /**
     * The ID of the redemption event
     */
    id: string;
    /**
     * Your unique identifier for the customer
     */
    customerId: string;
    /**
     * The ID of the reward that will be granted
     */
    rewardId: string;
};
/** @internal */
type RedeemReferralCodeParams$Outbound = {
    code: string;
    customer_id: string;
};
/** @internal */
declare const RedeemReferralCodeParams$outboundSchema: z$1.ZodMiniType<RedeemReferralCodeParams$Outbound, RedeemReferralCodeParams>;
declare function redeemReferralCodeParamsToJSON(redeemReferralCodeParams: RedeemReferralCodeParams): string;
/** @internal */
declare const RedeemReferralCodeResponse$inboundSchema: z$1.ZodMiniType<RedeemReferralCodeResponse, unknown>;
declare function redeemReferralCodeResponseFromJSON(jsonString: string): Result$1<RedeemReferralCodeResponse, SDKValidationError>;

type RedeemRewardCodeGlobals = {
    xApiVersion?: string | undefined;
};
type RedeemRewardCodeParams = {
    /**
     * The reward promo code to redeem
     */
    code: string;
    /**
     * The unique identifier of the customer redeeming the code
     */
    customerId: string;
};
type EntitlementsGranted = {
    /**
     * The ID of the feature granted by the reward
     */
    featureId: string;
    /**
     * The balance granted for the feature
     */
    balance: number;
};
/**
 * OK
 */
type RedeemRewardCodeResponse = {
    /**
     * The ID of the redeemed reward
     */
    rewardId: string;
    /**
     * The feature balances granted to the customer
     */
    entitlementsGranted: Array<EntitlementsGranted>;
};
/** @internal */
type RedeemRewardCodeParams$Outbound = {
    code: string;
    customer_id: string;
};
/** @internal */
declare const RedeemRewardCodeParams$outboundSchema: z$1.ZodMiniType<RedeemRewardCodeParams$Outbound, RedeemRewardCodeParams>;
declare function redeemRewardCodeParamsToJSON(redeemRewardCodeParams: RedeemRewardCodeParams): string;
/** @internal */
declare const EntitlementsGranted$inboundSchema: z$1.ZodMiniType<EntitlementsGranted, unknown>;
declare function entitlementsGrantedFromJSON(jsonString: string): Result$1<EntitlementsGranted, SDKValidationError>;
/** @internal */
declare const RedeemRewardCodeResponse$inboundSchema: z$1.ZodMiniType<RedeemRewardCodeResponse, unknown>;
declare function redeemRewardCodeResponseFromJSON(jsonString: string): Result$1<RedeemRewardCodeResponse, SDKValidationError>;

type RefreshKeyGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * No body. The refresh token is supplied as the Bearer credential; the response is a freshly rotated access + refresh pair.
 */
type RefreshKeyParams = {};
/**
 * OK
 */
type RefreshKeyResponse = {
    /**
     * Access token (1h, or non-expiring if indefinite), prefixed `am_jwt_`.
     */
    accessToken: string;
    /**
     * Rotating refresh token (24h). Omitted for indefinite tokens.
     */
    refreshToken?: string | undefined;
    /**
     * Access-token expiry, ms since epoch. null for indefinite tokens.
     */
    expiresAt: number | null;
    /**
     * Refresh-token expiry, ms since epoch. Omitted for indefinite tokens.
     */
    refreshExpiresAt?: number | undefined;
};
/** @internal */
type RefreshKeyParams$Outbound = {};
/** @internal */
declare const RefreshKeyParams$outboundSchema: z$1.ZodMiniType<RefreshKeyParams$Outbound, RefreshKeyParams>;
declare function refreshKeyParamsToJSON(refreshKeyParams: RefreshKeyParams): string;
/** @internal */
declare const RefreshKeyResponse$inboundSchema: z$1.ZodMiniType<RefreshKeyResponse, unknown>;
declare function refreshKeyResponseFromJSON(jsonString: string): Result$1<RefreshKeyResponse, SDKValidationError>;

declare class ResponseValidationError extends AutumnError {
    /**
     * The raw value that failed validation.
     */
    readonly rawValue: unknown;
    /**
     * The raw message that failed validation.
     */
    readonly rawMessage: unknown;
    constructor(message: string, extra: {
        response: Response;
        request: Request;
        body: string;
        cause: unknown;
        rawValue: unknown;
        rawMessage: unknown;
    });
    /**
     * Return a pretty-formatted error message if the underlying validation error
     * is a ZodError or some other recognized error type, otherwise return the
     * default error message.
     */
    pretty(): string;
}

type RevokeKeyGlobals = {
    xApiVersion?: string | undefined;
};
type RevokeKeyParams = {
    /**
     * The customer whose tokens (every outstanding access + refresh token) should be revoked.
     */
    customerId: string;
};
/**
 * OK
 */
type RevokeKeyResponse = {
    revoked: true;
};
/** @internal */
type RevokeKeyParams$Outbound = {
    customer_id: string;
};
/** @internal */
declare const RevokeKeyParams$outboundSchema: z$1.ZodMiniType<RevokeKeyParams$Outbound, RevokeKeyParams>;
declare function revokeKeyParamsToJSON(revokeKeyParams: RevokeKeyParams): string;
/** @internal */
declare const RevokeKeyResponse$inboundSchema: z$1.ZodMiniType<RevokeKeyResponse, unknown>;
declare function revokeKeyResponseFromJSON(jsonString: string): Result$1<RevokeKeyResponse, SDKValidationError>;

type Security = {
    secretKey?: string | undefined;
};
/** @internal */
type Security$Outbound = {
    secretKey?: string | undefined;
};
/** @internal */
declare const Security$outboundSchema: z$1.ZodMiniType<Security$Outbound, Security>;
declare function securityToJSON(security: Security): string;

type SetupPaymentGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Quantity configuration for a prepaid feature.
 */
type SetupPaymentFeatureQuantity = {
    /**
     * The ID of the feature to set quantity for.
     */
    featureId: string;
    /**
     * The quantity of the feature.
     */
    quantity?: number | undefined;
    /**
     * Whether the customer can adjust the quantity.
     */
    adjustable?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const SetupPaymentPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type SetupPaymentPriceInterval = ClosedEnum<typeof SetupPaymentPriceInterval>;
/**
 * Base price configuration for a plan.
 */
type SetupPaymentBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: SetupPaymentPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const SetupPaymentItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type SetupPaymentItemResetInterval = ClosedEnum<typeof SetupPaymentItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type SetupPaymentItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: SetupPaymentItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type SetupPaymentItemTo = number | string;
type SetupPaymentItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const SetupPaymentItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type SetupPaymentItemTierBehavior = ClosedEnum<typeof SetupPaymentItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const SetupPaymentItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type SetupPaymentItemPriceInterval = ClosedEnum<typeof SetupPaymentItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const SetupPaymentItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type SetupPaymentItemBillingMethod = ClosedEnum<typeof SetupPaymentItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type SetupPaymentItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<SetupPaymentItemTier> | undefined;
    tierBehavior?: SetupPaymentItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: SetupPaymentItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: SetupPaymentItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const SetupPaymentItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type SetupPaymentItemOnIncrease = ClosedEnum<typeof SetupPaymentItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const SetupPaymentItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type SetupPaymentItemOnDecrease = ClosedEnum<typeof SetupPaymentItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type SetupPaymentItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: SetupPaymentItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: SetupPaymentItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const SetupPaymentItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type SetupPaymentItemExpiryDurationType = ClosedEnum<typeof SetupPaymentItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type SetupPaymentItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: SetupPaymentItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type SetupPaymentItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: SetupPaymentItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: SetupPaymentItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: SetupPaymentItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: SetupPaymentItemRollover | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const SetupPaymentAddItemResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type SetupPaymentAddItemResetInterval = ClosedEnum<typeof SetupPaymentAddItemResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type SetupPaymentAddItemReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: SetupPaymentAddItemResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type SetupPaymentAddItemTo = number | string;
type SetupPaymentAddItemTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const SetupPaymentAddItemTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type SetupPaymentAddItemTierBehavior = ClosedEnum<typeof SetupPaymentAddItemTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const SetupPaymentAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type SetupPaymentAddItemPriceInterval = ClosedEnum<typeof SetupPaymentAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const SetupPaymentAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type SetupPaymentAddItemBillingMethod = ClosedEnum<typeof SetupPaymentAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type SetupPaymentAddItemPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<SetupPaymentAddItemTier> | undefined;
    tierBehavior?: SetupPaymentAddItemTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: SetupPaymentAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: SetupPaymentAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const SetupPaymentAddItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type SetupPaymentAddItemOnIncrease = ClosedEnum<typeof SetupPaymentAddItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const SetupPaymentAddItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type SetupPaymentAddItemOnDecrease = ClosedEnum<typeof SetupPaymentAddItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type SetupPaymentAddItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: SetupPaymentAddItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: SetupPaymentAddItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const SetupPaymentAddItemExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type SetupPaymentAddItemExpiryDurationType = ClosedEnum<typeof SetupPaymentAddItemExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type SetupPaymentAddItemRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: SetupPaymentAddItemExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type SetupPaymentAddItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: SetupPaymentAddItemReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: SetupPaymentAddItemPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: SetupPaymentAddItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: SetupPaymentAddItemRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const SetupPaymentRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type SetupPaymentRemoveItemBillingMethod = ClosedEnum<typeof SetupPaymentRemoveItemBillingMethod>;
declare const SetupPaymentIntervalRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type SetupPaymentIntervalRemoveItemEnum2 = ClosedEnum<typeof SetupPaymentIntervalRemoveItemEnum2>;
declare const SetupPaymentIntervalRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type SetupPaymentIntervalRemoveItemEnum1 = ClosedEnum<typeof SetupPaymentIntervalRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type SetupPaymentIntervalUnion = SetupPaymentIntervalRemoveItemEnum1 | SetupPaymentIntervalRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type SetupPaymentPlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: SetupPaymentRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: SetupPaymentIntervalRemoveItemEnum1 | SetupPaymentIntervalRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const SetupPaymentDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type SetupPaymentDurationType = ClosedEnum<typeof SetupPaymentDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const SetupPaymentOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type SetupPaymentOnEnd = ClosedEnum<typeof SetupPaymentOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type SetupPaymentFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: SetupPaymentDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: SetupPaymentOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const SetupPaymentPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type SetupPaymentPurchaseLimitInterval = ClosedEnum<typeof SetupPaymentPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type SetupPaymentPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: SetupPaymentPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type SetupPaymentAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: SetupPaymentPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const SetupPaymentLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type SetupPaymentLimitType = ClosedEnum<typeof SetupPaymentLimitType>;
type SetupPaymentSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: SetupPaymentLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const SetupPaymentUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type SetupPaymentUsageLimitInterval = ClosedEnum<typeof SetupPaymentUsageLimitInterval>;
type SetupPaymentProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type SetupPaymentFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type SetupPaymentUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: SetupPaymentUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: SetupPaymentFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const SetupPaymentThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type SetupPaymentThresholdType = ClosedEnum<typeof SetupPaymentThresholdType>;
type SetupPaymentUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: SetupPaymentThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type SetupPaymentOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type SetupPaymentBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<SetupPaymentAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<SetupPaymentSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<SetupPaymentUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<SetupPaymentUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<SetupPaymentOverageAllowed> | undefined;
};
/**
 * Customize the plan to attach. Can override the price, items, free trial, or a combination.
 */
type SetupPaymentCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: SetupPaymentBasePrice | null | undefined;
    /**
     * Override the items in the plan (PUT-style — replaces all existing items). Mutually exclusive with add_items / remove_items / deprecated update_items.
     */
    items?: Array<SetupPaymentItemPlanItem> | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<SetupPaymentAddItemPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<SetupPaymentPlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: SetupPaymentFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: SetupPaymentBillingControls | undefined;
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
declare const SetupPaymentProrationBehavior: {
    readonly ProrateImmediately: "prorate_immediately";
    readonly None: "none";
};
/**
 * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
 */
type SetupPaymentProrationBehavior = ClosedEnum<typeof SetupPaymentProrationBehavior>;
/**
 * A discount to apply. Can be either a reward ID or a promotion code.
 */
type SetupPaymentAttachDiscount = {
    /**
     * The ID of the reward to apply as a discount.
     */
    rewardId?: string | undefined;
    /**
     * The promotion code to apply as a discount.
     */
    promotionCode?: string | undefined;
};
type SetupPaymentCustomLineItem = {
    /**
     * Amount in dollars for this line item (e.g. 10.50). Can be negative for credits.
     */
    amount: number;
    /**
     * Description for the line item.
     */
    description: string;
};
/**
 * Whether to carry over balances from the previous plan.
 */
type SetupPaymentCarryOverBalances = {
    /**
     * Whether to carry over balances from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over balances from. If left undefined, all features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
/**
 * Whether to carry over usages from the previous plan.
 */
type SetupPaymentCarryOverUsages = {
    /**
     * Whether to carry over usages from the previous plan.
     */
    enabled: boolean;
    /**
     * The IDs of the features to carry over usages for. If left undefined, all consumable features will be carried over.
     */
    featureIds?: Array<string> | undefined;
};
type SetupPaymentParams = {
    /**
     * The ID of the customer to attach the plan to.
     */
    customerId: string;
    /**
     * The ID of the entity to attach the plan to.
     */
    entityId?: string | undefined;
    /**
     * If specified, the plan will be attached to the customer after setup.
     */
    planId?: string | undefined;
    /**
     * If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan.
     */
    featureQuantities?: Array<SetupPaymentFeatureQuantity> | undefined;
    /**
     * The version of the plan to attach.
     */
    version?: number | undefined;
    /**
     * Customize the plan to attach. Can override the price, items, free trial, or a combination.
     */
    customize?: SetupPaymentCustomize | undefined;
    /**
     * How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges.
     */
    prorationBehavior?: SetupPaymentProrationBehavior | undefined;
    /**
     * A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan.
     */
    subscriptionId?: string | undefined;
    /**
     * List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code.
     */
    discounts?: Array<SetupPaymentAttachDiscount> | undefined;
    /**
     * URL to redirect to after successful checkout.
     */
    successUrl?: string | undefined;
    /**
     * Reset the billing cycle anchor immediately with 'now'.
     */
    billingCycleAnchor?: "now" | undefined;
    /**
     * Unix timestamp in milliseconds for when the attached plan should start. Future dates create a scheduled subscription.
     */
    startsAt?: number | undefined;
    /**
     * Unix timestamp in milliseconds for when the attached plan should end.
     */
    endsAt?: number | undefined;
    /**
     * Additional parameters to pass into the creation of the Stripe checkout session.
     */
    checkoutSessionParams?: {
        [k: string]: any;
    } | undefined;
    /**
     * Custom line items that override the auto-generated proration invoice. Only valid for immediate plan changes (eg. upgrades or one off plans).
     */
    customLineItems?: Array<SetupPaymentCustomLineItem> | undefined;
    /**
     * The processor subscription ID to link. Use this to attach an existing Stripe subscription instead of creating a new one.
     */
    processorSubscriptionId?: string | undefined;
    /**
     * Whether to carry over balances from the previous plan.
     */
    carryOverBalances?: SetupPaymentCarryOverBalances | undefined;
    /**
     * Whether to carry over usages from the previous plan.
     */
    carryOverUsages?: SetupPaymentCarryOverUsages | undefined;
    /**
     * Key-value metadata to attach to the Stripe subscription, invoice, and checkout session created during this attach flow. Keys prefixed with 'autumn_' are reserved and will be stripped.
     */
    metadata?: {
        [k: string]: string;
    } | undefined;
    /**
     * If true, skips any billing changes for the attach operation.
     */
    noBillingChanges?: boolean | undefined;
    /**
     * If true, the customer's plan is activated immediately even when payment is deferred (invoice mode) or pending (Stripe checkout). For Stripe checkout, the customer_product is inserted before the customer completes the hosted form.
     */
    enablePlanImmediately?: boolean | undefined;
    /**
     * Stripe tax rate ID (txr_...) to apply as the default tax rate on the created subscription, invoice, or checkout session line items.
     */
    taxRateId?: string | undefined;
};
/**
 * OK
 */
type SetupPaymentResponse = {
    /**
     * The ID of the customer
     */
    customerId: string;
    /**
     * The ID of the entity the plan (if specified) will be attached to after setup.
     */
    entityId?: string | undefined;
    /**
     * URL to redirect the customer to setup their payment.
     */
    url: string;
};
/** @internal */
type SetupPaymentFeatureQuantity$Outbound = {
    feature_id: string;
    quantity?: number | undefined;
    adjustable?: boolean | undefined;
};
/** @internal */
declare const SetupPaymentFeatureQuantity$outboundSchema: z$1.ZodMiniType<SetupPaymentFeatureQuantity$Outbound, SetupPaymentFeatureQuantity>;
declare function setupPaymentFeatureQuantityToJSON(setupPaymentFeatureQuantity: SetupPaymentFeatureQuantity): string;
/** @internal */
declare const SetupPaymentPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentPriceInterval>;
/** @internal */
type SetupPaymentBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const SetupPaymentBasePrice$outboundSchema: z$1.ZodMiniType<SetupPaymentBasePrice$Outbound, SetupPaymentBasePrice>;
declare function setupPaymentBasePriceToJSON(setupPaymentBasePrice: SetupPaymentBasePrice): string;
/** @internal */
declare const SetupPaymentItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentItemResetInterval>;
/** @internal */
type SetupPaymentItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const SetupPaymentItemReset$outboundSchema: z$1.ZodMiniType<SetupPaymentItemReset$Outbound, SetupPaymentItemReset>;
declare function setupPaymentItemResetToJSON(setupPaymentItemReset: SetupPaymentItemReset): string;
/** @internal */
type SetupPaymentItemTo$Outbound = number | string;
/** @internal */
declare const SetupPaymentItemTo$outboundSchema: z$1.ZodMiniType<SetupPaymentItemTo$Outbound, SetupPaymentItemTo>;
declare function setupPaymentItemToToJSON(setupPaymentItemTo: SetupPaymentItemTo): string;
/** @internal */
type SetupPaymentItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const SetupPaymentItemTier$outboundSchema: z$1.ZodMiniType<SetupPaymentItemTier$Outbound, SetupPaymentItemTier>;
declare function setupPaymentItemTierToJSON(setupPaymentItemTier: SetupPaymentItemTier): string;
/** @internal */
declare const SetupPaymentItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentItemTierBehavior>;
/** @internal */
declare const SetupPaymentItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentItemPriceInterval>;
/** @internal */
declare const SetupPaymentItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentItemBillingMethod>;
/** @internal */
type SetupPaymentItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<SetupPaymentItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const SetupPaymentItemPrice$outboundSchema: z$1.ZodMiniType<SetupPaymentItemPrice$Outbound, SetupPaymentItemPrice>;
declare function setupPaymentItemPriceToJSON(setupPaymentItemPrice: SetupPaymentItemPrice): string;
/** @internal */
declare const SetupPaymentItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentItemOnIncrease>;
/** @internal */
declare const SetupPaymentItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentItemOnDecrease>;
/** @internal */
type SetupPaymentItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const SetupPaymentItemProration$outboundSchema: z$1.ZodMiniType<SetupPaymentItemProration$Outbound, SetupPaymentItemProration>;
declare function setupPaymentItemProrationToJSON(setupPaymentItemProration: SetupPaymentItemProration): string;
/** @internal */
declare const SetupPaymentItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentItemExpiryDurationType>;
/** @internal */
type SetupPaymentItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const SetupPaymentItemRollover$outboundSchema: z$1.ZodMiniType<SetupPaymentItemRollover$Outbound, SetupPaymentItemRollover>;
declare function setupPaymentItemRolloverToJSON(setupPaymentItemRollover: SetupPaymentItemRollover): string;
/** @internal */
type SetupPaymentItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: SetupPaymentItemReset$Outbound | undefined;
    price?: SetupPaymentItemPrice$Outbound | undefined;
    proration?: SetupPaymentItemProration$Outbound | undefined;
    rollover?: SetupPaymentItemRollover$Outbound | undefined;
};
/** @internal */
declare const SetupPaymentItemPlanItem$outboundSchema: z$1.ZodMiniType<SetupPaymentItemPlanItem$Outbound, SetupPaymentItemPlanItem>;
declare function setupPaymentItemPlanItemToJSON(setupPaymentItemPlanItem: SetupPaymentItemPlanItem): string;
/** @internal */
declare const SetupPaymentAddItemResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentAddItemResetInterval>;
/** @internal */
type SetupPaymentAddItemReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const SetupPaymentAddItemReset$outboundSchema: z$1.ZodMiniType<SetupPaymentAddItemReset$Outbound, SetupPaymentAddItemReset>;
declare function setupPaymentAddItemResetToJSON(setupPaymentAddItemReset: SetupPaymentAddItemReset): string;
/** @internal */
type SetupPaymentAddItemTo$Outbound = number | string;
/** @internal */
declare const SetupPaymentAddItemTo$outboundSchema: z$1.ZodMiniType<SetupPaymentAddItemTo$Outbound, SetupPaymentAddItemTo>;
declare function setupPaymentAddItemToToJSON(setupPaymentAddItemTo: SetupPaymentAddItemTo): string;
/** @internal */
type SetupPaymentAddItemTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const SetupPaymentAddItemTier$outboundSchema: z$1.ZodMiniType<SetupPaymentAddItemTier$Outbound, SetupPaymentAddItemTier>;
declare function setupPaymentAddItemTierToJSON(setupPaymentAddItemTier: SetupPaymentAddItemTier): string;
/** @internal */
declare const SetupPaymentAddItemTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentAddItemTierBehavior>;
/** @internal */
declare const SetupPaymentAddItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentAddItemPriceInterval>;
/** @internal */
declare const SetupPaymentAddItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentAddItemBillingMethod>;
/** @internal */
type SetupPaymentAddItemPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<SetupPaymentAddItemTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const SetupPaymentAddItemPrice$outboundSchema: z$1.ZodMiniType<SetupPaymentAddItemPrice$Outbound, SetupPaymentAddItemPrice>;
declare function setupPaymentAddItemPriceToJSON(setupPaymentAddItemPrice: SetupPaymentAddItemPrice): string;
/** @internal */
declare const SetupPaymentAddItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentAddItemOnIncrease>;
/** @internal */
declare const SetupPaymentAddItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentAddItemOnDecrease>;
/** @internal */
type SetupPaymentAddItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const SetupPaymentAddItemProration$outboundSchema: z$1.ZodMiniType<SetupPaymentAddItemProration$Outbound, SetupPaymentAddItemProration>;
declare function setupPaymentAddItemProrationToJSON(setupPaymentAddItemProration: SetupPaymentAddItemProration): string;
/** @internal */
declare const SetupPaymentAddItemExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentAddItemExpiryDurationType>;
/** @internal */
type SetupPaymentAddItemRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const SetupPaymentAddItemRollover$outboundSchema: z$1.ZodMiniType<SetupPaymentAddItemRollover$Outbound, SetupPaymentAddItemRollover>;
declare function setupPaymentAddItemRolloverToJSON(setupPaymentAddItemRollover: SetupPaymentAddItemRollover): string;
/** @internal */
type SetupPaymentAddItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: SetupPaymentAddItemReset$Outbound | undefined;
    price?: SetupPaymentAddItemPrice$Outbound | undefined;
    proration?: SetupPaymentAddItemProration$Outbound | undefined;
    rollover?: SetupPaymentAddItemRollover$Outbound | undefined;
};
/** @internal */
declare const SetupPaymentAddItemPlanItem$outboundSchema: z$1.ZodMiniType<SetupPaymentAddItemPlanItem$Outbound, SetupPaymentAddItemPlanItem>;
declare function setupPaymentAddItemPlanItemToJSON(setupPaymentAddItemPlanItem: SetupPaymentAddItemPlanItem): string;
/** @internal */
declare const SetupPaymentRemoveItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentRemoveItemBillingMethod>;
/** @internal */
declare const SetupPaymentIntervalRemoveItemEnum2$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentIntervalRemoveItemEnum2>;
/** @internal */
declare const SetupPaymentIntervalRemoveItemEnum1$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentIntervalRemoveItemEnum1>;
/** @internal */
type SetupPaymentIntervalUnion$Outbound = string | string;
/** @internal */
declare const SetupPaymentIntervalUnion$outboundSchema: z$1.ZodMiniType<SetupPaymentIntervalUnion$Outbound, SetupPaymentIntervalUnion>;
declare function setupPaymentIntervalUnionToJSON(setupPaymentIntervalUnion: SetupPaymentIntervalUnion): string;
/** @internal */
type SetupPaymentPlanItemFilter$Outbound = {
    feature_id?: string | undefined;
    billing_method?: string | undefined;
    interval?: string | string | undefined;
    interval_count?: number | undefined;
};
/** @internal */
declare const SetupPaymentPlanItemFilter$outboundSchema: z$1.ZodMiniType<SetupPaymentPlanItemFilter$Outbound, SetupPaymentPlanItemFilter>;
declare function setupPaymentPlanItemFilterToJSON(setupPaymentPlanItemFilter: SetupPaymentPlanItemFilter): string;
/** @internal */
declare const SetupPaymentDurationType$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentDurationType>;
/** @internal */
declare const SetupPaymentOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentOnEnd>;
/** @internal */
type SetupPaymentFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const SetupPaymentFreeTrialParams$outboundSchema: z$1.ZodMiniType<SetupPaymentFreeTrialParams$Outbound, SetupPaymentFreeTrialParams>;
declare function setupPaymentFreeTrialParamsToJSON(setupPaymentFreeTrialParams: SetupPaymentFreeTrialParams): string;
/** @internal */
declare const SetupPaymentPurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentPurchaseLimitInterval>;
/** @internal */
type SetupPaymentPurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const SetupPaymentPurchaseLimit$outboundSchema: z$1.ZodMiniType<SetupPaymentPurchaseLimit$Outbound, SetupPaymentPurchaseLimit>;
declare function setupPaymentPurchaseLimitToJSON(setupPaymentPurchaseLimit: SetupPaymentPurchaseLimit): string;
/** @internal */
type SetupPaymentAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: SetupPaymentPurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const SetupPaymentAutoTopup$outboundSchema: z$1.ZodMiniType<SetupPaymentAutoTopup$Outbound, SetupPaymentAutoTopup>;
declare function setupPaymentAutoTopupToJSON(setupPaymentAutoTopup: SetupPaymentAutoTopup): string;
/** @internal */
declare const SetupPaymentLimitType$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentLimitType>;
/** @internal */
type SetupPaymentSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const SetupPaymentSpendLimit$outboundSchema: z$1.ZodMiniType<SetupPaymentSpendLimit$Outbound, SetupPaymentSpendLimit>;
declare function setupPaymentSpendLimitToJSON(setupPaymentSpendLimit: SetupPaymentSpendLimit): string;
/** @internal */
declare const SetupPaymentUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentUsageLimitInterval>;
/** @internal */
type SetupPaymentProperties$Outbound = string | number | boolean;
/** @internal */
declare const SetupPaymentProperties$outboundSchema: z$1.ZodMiniType<SetupPaymentProperties$Outbound, SetupPaymentProperties>;
declare function setupPaymentPropertiesToJSON(setupPaymentProperties: SetupPaymentProperties): string;
/** @internal */
type SetupPaymentFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const SetupPaymentFilter$outboundSchema: z$1.ZodMiniType<SetupPaymentFilter$Outbound, SetupPaymentFilter>;
declare function setupPaymentFilterToJSON(setupPaymentFilter: SetupPaymentFilter): string;
/** @internal */
type SetupPaymentUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: SetupPaymentFilter$Outbound | undefined;
};
/** @internal */
declare const SetupPaymentUsageLimit$outboundSchema: z$1.ZodMiniType<SetupPaymentUsageLimit$Outbound, SetupPaymentUsageLimit>;
declare function setupPaymentUsageLimitToJSON(setupPaymentUsageLimit: SetupPaymentUsageLimit): string;
/** @internal */
declare const SetupPaymentThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentThresholdType>;
/** @internal */
type SetupPaymentUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const SetupPaymentUsageAlert$outboundSchema: z$1.ZodMiniType<SetupPaymentUsageAlert$Outbound, SetupPaymentUsageAlert>;
declare function setupPaymentUsageAlertToJSON(setupPaymentUsageAlert: SetupPaymentUsageAlert): string;
/** @internal */
type SetupPaymentOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const SetupPaymentOverageAllowed$outboundSchema: z$1.ZodMiniType<SetupPaymentOverageAllowed$Outbound, SetupPaymentOverageAllowed>;
declare function setupPaymentOverageAllowedToJSON(setupPaymentOverageAllowed: SetupPaymentOverageAllowed): string;
/** @internal */
type SetupPaymentBillingControls$Outbound = {
    auto_topups?: Array<SetupPaymentAutoTopup$Outbound> | undefined;
    spend_limits?: Array<SetupPaymentSpendLimit$Outbound> | undefined;
    usage_limits?: Array<SetupPaymentUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<SetupPaymentUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<SetupPaymentOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const SetupPaymentBillingControls$outboundSchema: z$1.ZodMiniType<SetupPaymentBillingControls$Outbound, SetupPaymentBillingControls>;
declare function setupPaymentBillingControlsToJSON(setupPaymentBillingControls: SetupPaymentBillingControls): string;
/** @internal */
type SetupPaymentCustomize$Outbound = {
    price?: SetupPaymentBasePrice$Outbound | null | undefined;
    items?: Array<SetupPaymentItemPlanItem$Outbound> | undefined;
    add_items?: Array<SetupPaymentAddItemPlanItem$Outbound> | undefined;
    remove_items?: Array<SetupPaymentPlanItemFilter$Outbound> | undefined;
    free_trial?: SetupPaymentFreeTrialParams$Outbound | null | undefined;
    billing_controls?: SetupPaymentBillingControls$Outbound | undefined;
};
/** @internal */
declare const SetupPaymentCustomize$outboundSchema: z$1.ZodMiniType<SetupPaymentCustomize$Outbound, SetupPaymentCustomize>;
declare function setupPaymentCustomizeToJSON(setupPaymentCustomize: SetupPaymentCustomize): string;
/** @internal */
declare const SetupPaymentProrationBehavior$outboundSchema: z$1.ZodMiniEnum<typeof SetupPaymentProrationBehavior>;
/** @internal */
type SetupPaymentAttachDiscount$Outbound = {
    reward_id?: string | undefined;
    promotion_code?: string | undefined;
};
/** @internal */
declare const SetupPaymentAttachDiscount$outboundSchema: z$1.ZodMiniType<SetupPaymentAttachDiscount$Outbound, SetupPaymentAttachDiscount>;
declare function setupPaymentAttachDiscountToJSON(setupPaymentAttachDiscount: SetupPaymentAttachDiscount): string;
/** @internal */
type SetupPaymentCustomLineItem$Outbound = {
    amount: number;
    description: string;
};
/** @internal */
declare const SetupPaymentCustomLineItem$outboundSchema: z$1.ZodMiniType<SetupPaymentCustomLineItem$Outbound, SetupPaymentCustomLineItem>;
declare function setupPaymentCustomLineItemToJSON(setupPaymentCustomLineItem: SetupPaymentCustomLineItem): string;
/** @internal */
type SetupPaymentCarryOverBalances$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const SetupPaymentCarryOverBalances$outboundSchema: z$1.ZodMiniType<SetupPaymentCarryOverBalances$Outbound, SetupPaymentCarryOverBalances>;
declare function setupPaymentCarryOverBalancesToJSON(setupPaymentCarryOverBalances: SetupPaymentCarryOverBalances): string;
/** @internal */
type SetupPaymentCarryOverUsages$Outbound = {
    enabled: boolean;
    feature_ids?: Array<string> | undefined;
};
/** @internal */
declare const SetupPaymentCarryOverUsages$outboundSchema: z$1.ZodMiniType<SetupPaymentCarryOverUsages$Outbound, SetupPaymentCarryOverUsages>;
declare function setupPaymentCarryOverUsagesToJSON(setupPaymentCarryOverUsages: SetupPaymentCarryOverUsages): string;
/** @internal */
type SetupPaymentParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    plan_id?: string | undefined;
    feature_quantities?: Array<SetupPaymentFeatureQuantity$Outbound> | undefined;
    version?: number | undefined;
    customize?: SetupPaymentCustomize$Outbound | undefined;
    proration_behavior?: string | undefined;
    subscription_id?: string | undefined;
    discounts?: Array<SetupPaymentAttachDiscount$Outbound> | undefined;
    success_url?: string | undefined;
    billing_cycle_anchor?: "now" | undefined;
    starts_at?: number | undefined;
    ends_at?: number | undefined;
    checkout_session_params?: {
        [k: string]: any;
    } | undefined;
    custom_line_items?: Array<SetupPaymentCustomLineItem$Outbound> | undefined;
    processor_subscription_id?: string | undefined;
    carry_over_balances?: SetupPaymentCarryOverBalances$Outbound | undefined;
    carry_over_usages?: SetupPaymentCarryOverUsages$Outbound | undefined;
    metadata?: {
        [k: string]: string;
    } | undefined;
    no_billing_changes?: boolean | undefined;
    enable_plan_immediately?: boolean | undefined;
    tax_rate_id?: string | undefined;
};
/** @internal */
declare const SetupPaymentParams$outboundSchema: z$1.ZodMiniType<SetupPaymentParams$Outbound, SetupPaymentParams>;
declare function setupPaymentParamsToJSON(setupPaymentParams: SetupPaymentParams): string;
/** @internal */
declare const SetupPaymentResponse$inboundSchema: z$1.ZodMiniType<SetupPaymentResponse, unknown>;
declare function setupPaymentResponseFromJSON(jsonString: string): Result$1<SetupPaymentResponse, SDKValidationError>;

type SyncRevenueCatGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * "test" and "sandbox" both target the sandbox environment
 */
declare const SyncRevenueCatEnv: {
    readonly Test: "test";
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * "test" and "sandbox" both target the sandbox environment
 */
type SyncRevenueCatEnv = ClosedEnum<typeof SyncRevenueCatEnv>;
type SyncRevenueCatParams = {
    organizationSlug: string;
    /**
     * "test" and "sandbox" both target the sandbox environment
     */
    env: SyncRevenueCatEnv;
    /**
     * Plans to push. Omit to sync every plan in the org/env.
     */
    productIds?: Array<string> | undefined;
};
declare const SyncRevenueCatStatus: {
    readonly Synced: "synced";
    readonly Skipped: "skipped";
    readonly Error: "error";
};
type SyncRevenueCatStatus = OpenEnum<typeof SyncRevenueCatStatus>;
declare const SyncRevenueCatProduct: {
    readonly Created: "created";
    readonly Updated: "updated";
    readonly Exists: "exists";
};
type SyncRevenueCatProduct = OpenEnum<typeof SyncRevenueCatProduct>;
declare const StorePush: {
    readonly Pushed: "pushed";
    readonly Failed: "failed";
    readonly Skipped: "skipped";
};
type StorePush = OpenEnum<typeof StorePush>;
declare const SyncRevenueCatPrice: {
    readonly Set: "set";
    readonly Skipped: "skipped";
    readonly Failed: "failed";
};
type SyncRevenueCatPrice = OpenEnum<typeof SyncRevenueCatPrice>;
type SyncRevenueCatApp = {
    appId: string;
    appType: string;
    product: SyncRevenueCatProduct;
    storePush?: StorePush | undefined;
    price?: SyncRevenueCatPrice | undefined;
    message?: string | undefined;
};
type Result = {
    planId: string;
    status: SyncRevenueCatStatus;
    storeIdentifier?: string | undefined;
    apps?: Array<SyncRevenueCatApp> | undefined;
    message?: string | undefined;
};
/**
 * OK
 */
type SyncRevenueCatResponse = {
    results: Array<Result>;
};
/** @internal */
declare const SyncRevenueCatEnv$outboundSchema: z$1.ZodMiniEnum<typeof SyncRevenueCatEnv>;
/** @internal */
type SyncRevenueCatParams$Outbound = {
    organization_slug: string;
    env: string;
    product_ids?: Array<string> | undefined;
};
/** @internal */
declare const SyncRevenueCatParams$outboundSchema: z$1.ZodMiniType<SyncRevenueCatParams$Outbound, SyncRevenueCatParams>;
declare function syncRevenueCatParamsToJSON(syncRevenueCatParams: SyncRevenueCatParams): string;
/** @internal */
declare const SyncRevenueCatStatus$inboundSchema: z$1.ZodMiniType<SyncRevenueCatStatus, unknown>;
/** @internal */
declare const SyncRevenueCatProduct$inboundSchema: z$1.ZodMiniType<SyncRevenueCatProduct, unknown>;
/** @internal */
declare const StorePush$inboundSchema: z$1.ZodMiniType<StorePush, unknown>;
/** @internal */
declare const SyncRevenueCatPrice$inboundSchema: z$1.ZodMiniType<SyncRevenueCatPrice, unknown>;
/** @internal */
declare const SyncRevenueCatApp$inboundSchema: z$1.ZodMiniType<SyncRevenueCatApp, unknown>;
declare function syncRevenueCatAppFromJSON(jsonString: string): Result$1<SyncRevenueCatApp, SDKValidationError>;
/** @internal */
declare const Result$inboundSchema: z$1.ZodMiniType<Result, unknown>;
declare function resultFromJSON(jsonString: string): Result$1<Result, SDKValidationError>;
/** @internal */
declare const SyncRevenueCatResponse$inboundSchema: z$1.ZodMiniType<SyncRevenueCatResponse, unknown>;
declare function syncRevenueCatResponseFromJSON(jsonString: string): Result$1<SyncRevenueCatResponse, SDKValidationError>;

type TrackGlobals = {
    xApiVersion?: string | undefined;
};
type TrackLock = {
    /**
     * A unique identifier for this lock. Used to finalize the lock later via balances.finalize.
     */
    lockId: string;
    /**
     * Must be true to enable locking.
     */
    enabled: true;
    /**
     * Unix timestamp (ms) when the lock automatically expires and releases the held balance.
     */
    expiresAt?: number | undefined;
};
type TrackParams = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the feature to track usage for. Required if event_name is not provided.
     */
    featureId?: string | undefined;
    /**
     * The ID of the entity for entity-scoped balances (e.g., per-seat limits).
     */
    entityId?: string | undefined;
    /**
     * Event name to track usage for. Use instead of feature_id when multiple features should be tracked from a single event.
     */
    eventName?: string | undefined;
    /**
     * The amount of usage to record. Defaults to 1. Use negative values to credit balance (e.g., when removing a seat).
     */
    value?: number | undefined;
    /**
     * Additional properties to attach to this usage event.
     */
    properties?: {
        [k: string]: any;
    } | undefined;
    /**
     * Unix timestamp in milliseconds to use for the usage event. Defaults to the current time.
     */
    timestamp?: number | undefined;
    /**
     * If true, enqueue the event for asynchronous processing and return 204 immediately. The response will not include balance information.
     */
    async?: boolean | undefined;
    lock?: TrackLock | undefined;
};
declare const TrackIntervalEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type TrackIntervalEnum2 = OpenEnum<typeof TrackIntervalEnum2>;
/**
 * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
 */
type TrackIntervalUnion2 = TrackIntervalEnum2 | string;
type TrackReset2 = {
    /**
     * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
     */
    interval: TrackIntervalEnum2 | string;
    /**
     * Number of intervals between resets (eg. 2 for bi-monthly).
     */
    intervalCount?: number | undefined;
    /**
     * Timestamp when the balance will next reset.
     */
    resetsAt: number | null;
};
type TrackDeduction2 = {
    /**
     * ID of the underlying balance row that was deducted from (customer_entitlement or rollover).
     */
    balanceId: string;
    /**
     * The feature this balance belongs to.
     */
    featureId: string;
    /**
     * ID of the plan/product this balance belongs to. Null when the balance can't be attributed to a single plan (e.g. it spans multiple).
     */
    planId: string | null;
    /**
     * Reset configuration for the balance this deduction came from, or null if the balance doesn't reset.
     */
    reset: TrackReset2 | null;
    /**
     * Amount deducted from this balance. Positive when usage was consumed, negative when credit was restored (e.g. a refund via negative track value).
     */
    value: number;
};
/**
 * Accepted. Autumn is experiencing degraded service from a downstream provider, so the event was accepted for replay and will be tracked as soon as the service is restored.
 */
type TrackResponseBody2 = {
    /**
     * The ID of the customer whose usage was tracked.
     */
    customerId: string;
    /**
     * The ID of the entity, if entity-scoped tracking was performed.
     */
    entityId?: string | undefined;
    /**
     * The event name that was tracked, if event_name was used instead of feature_id.
     */
    eventName?: string | undefined;
    /**
     * The amount of usage that was recorded.
     */
    value: number;
    /**
     * The updated balance for the tracked feature. Null if tracking by event_name that affects multiple features.
     */
    balance: Balance | null;
    /**
     * Map of feature_id to updated balance for the tracked feature and any related features (e.g. linked credit systems). Value is null when the customer has no balance for that feature.
     */
    balances?: {
        [k: string]: Balance | null;
    } | undefined;
    /**
     * Per-balance breakdown of what this event deducted. A single event can consume from multiple balance rows when credit systems or rollovers are involved; this surfaces each one so callers can build per-feature usage views without polling.
     */
    deductions?: Array<TrackDeduction2> | undefined;
};
declare const TrackIntervalEnum1: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type TrackIntervalEnum1 = OpenEnum<typeof TrackIntervalEnum1>;
/**
 * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
 */
type TrackIntervalUnion1 = TrackIntervalEnum1 | string;
type TrackReset1 = {
    /**
     * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
     */
    interval: TrackIntervalEnum1 | string;
    /**
     * Number of intervals between resets (eg. 2 for bi-monthly).
     */
    intervalCount?: number | undefined;
    /**
     * Timestamp when the balance will next reset.
     */
    resetsAt: number | null;
};
type TrackDeduction1 = {
    /**
     * ID of the underlying balance row that was deducted from (customer_entitlement or rollover).
     */
    balanceId: string;
    /**
     * The feature this balance belongs to.
     */
    featureId: string;
    /**
     * ID of the plan/product this balance belongs to. Null when the balance can't be attributed to a single plan (e.g. it spans multiple).
     */
    planId: string | null;
    /**
     * Reset configuration for the balance this deduction came from, or null if the balance doesn't reset.
     */
    reset: TrackReset1 | null;
    /**
     * Amount deducted from this balance. Positive when usage was consumed, negative when credit was restored (e.g. a refund via negative track value).
     */
    value: number;
};
/**
 * OK
 */
type TrackResponseBody1 = {
    /**
     * The ID of the customer whose usage was tracked.
     */
    customerId: string;
    /**
     * The ID of the entity, if entity-scoped tracking was performed.
     */
    entityId?: string | undefined;
    /**
     * The event name that was tracked, if event_name was used instead of feature_id.
     */
    eventName?: string | undefined;
    /**
     * The amount of usage that was recorded.
     */
    value: number;
    /**
     * The updated balance for the tracked feature. Null if tracking by event_name that affects multiple features.
     */
    balance: Balance | null;
    /**
     * Map of feature_id to updated balance for the tracked feature and any related features (e.g. linked credit systems). Value is null when the customer has no balance for that feature.
     */
    balances?: {
        [k: string]: Balance | null;
    } | undefined;
    /**
     * Per-balance breakdown of what this event deducted. A single event can consume from multiple balance rows when credit systems or rollovers are involved; this surfaces each one so callers can build per-feature usage views without polling.
     */
    deductions?: Array<TrackDeduction1> | undefined;
};
type TrackResponse = TrackResponseBody1 | TrackResponseBody2;
/** @internal */
type TrackLock$Outbound = {
    lock_id: string;
    enabled: true;
    expires_at?: number | undefined;
};
/** @internal */
declare const TrackLock$outboundSchema: z$1.ZodMiniType<TrackLock$Outbound, TrackLock>;
declare function trackLockToJSON(trackLock: TrackLock): string;
/** @internal */
type TrackParams$Outbound = {
    customer_id: string;
    feature_id?: string | undefined;
    entity_id?: string | undefined;
    event_name?: string | undefined;
    value?: number | undefined;
    properties?: {
        [k: string]: any;
    } | undefined;
    timestamp?: number | undefined;
    async?: boolean | undefined;
    lock?: TrackLock$Outbound | undefined;
};
/** @internal */
declare const TrackParams$outboundSchema: z$1.ZodMiniType<TrackParams$Outbound, TrackParams>;
declare function trackParamsToJSON(trackParams: TrackParams): string;
/** @internal */
declare const TrackIntervalEnum2$inboundSchema: z$1.ZodMiniType<TrackIntervalEnum2, unknown>;
/** @internal */
declare const TrackIntervalUnion2$inboundSchema: z$1.ZodMiniType<TrackIntervalUnion2, unknown>;
declare function trackIntervalUnion2FromJSON(jsonString: string): Result$1<TrackIntervalUnion2, SDKValidationError>;
/** @internal */
declare const TrackReset2$inboundSchema: z$1.ZodMiniType<TrackReset2, unknown>;
declare function trackReset2FromJSON(jsonString: string): Result$1<TrackReset2, SDKValidationError>;
/** @internal */
declare const TrackDeduction2$inboundSchema: z$1.ZodMiniType<TrackDeduction2, unknown>;
declare function trackDeduction2FromJSON(jsonString: string): Result$1<TrackDeduction2, SDKValidationError>;
/** @internal */
declare const TrackResponseBody2$inboundSchema: z$1.ZodMiniType<TrackResponseBody2, unknown>;
declare function trackResponseBody2FromJSON(jsonString: string): Result$1<TrackResponseBody2, SDKValidationError>;
/** @internal */
declare const TrackIntervalEnum1$inboundSchema: z$1.ZodMiniType<TrackIntervalEnum1, unknown>;
/** @internal */
declare const TrackIntervalUnion1$inboundSchema: z$1.ZodMiniType<TrackIntervalUnion1, unknown>;
declare function trackIntervalUnion1FromJSON(jsonString: string): Result$1<TrackIntervalUnion1, SDKValidationError>;
/** @internal */
declare const TrackReset1$inboundSchema: z$1.ZodMiniType<TrackReset1, unknown>;
declare function trackReset1FromJSON(jsonString: string): Result$1<TrackReset1, SDKValidationError>;
/** @internal */
declare const TrackDeduction1$inboundSchema: z$1.ZodMiniType<TrackDeduction1, unknown>;
declare function trackDeduction1FromJSON(jsonString: string): Result$1<TrackDeduction1, SDKValidationError>;
/** @internal */
declare const TrackResponseBody1$inboundSchema: z$1.ZodMiniType<TrackResponseBody1, unknown>;
declare function trackResponseBody1FromJSON(jsonString: string): Result$1<TrackResponseBody1, SDKValidationError>;
/** @internal */
declare const TrackResponse$inboundSchema: z$1.ZodMiniType<TrackResponse, unknown>;
declare function trackResponseFromJSON(jsonString: string): Result$1<TrackResponse, SDKValidationError>;

type TrackTokensGlobals = {
    xApiVersion?: string | undefined;
};
type TrackTokensParams = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the entity for entity-scoped balances.
     */
    entityId?: string | undefined;
    /**
     * The ID of the AI credit system feature. Auto-detected from the customer's entitlements if omitted — only required when a customer has multiple AI credit systems.
     */
    featureId?: string | undefined;
    /**
     * The AI model as '[provider]/[model]' (e.g. 'anthropic/claude-opus-4-8', 'openrouter/openai/gpt-4o'). The provider is the first path segment and must match a provider + model key in models.dev.
     */
    modelId: string;
    /**
     * Number of non-cached text input tokens consumed. Exclusive of cache and audio token pools.
     */
    inputTokens: number;
    /**
     * Number of text output tokens consumed. Exclusive of the reasoning and audio output pools.
     */
    outputTokens: number;
    /**
     * Number of cached input tokens read.
     */
    cacheReadTokens?: number | undefined;
    /**
     * Number of input tokens written to the cache.
     */
    cacheWriteTokens?: number | undefined;
    /**
     * Number of audio input tokens consumed.
     */
    audioInputTokens?: number | undefined;
    /**
     * Number of audio output tokens generated.
     */
    audioOutputTokens?: number | undefined;
    /**
     * Number of reasoning tokens generated.
     */
    reasoningTokens?: number | undefined;
    /**
     * Additional properties to attach to this usage event.
     */
    properties?: {
        [k: string]: any;
    } | undefined;
    /**
     * Unix timestamp in milliseconds to use for the usage event. Defaults to the current time.
     */
    timestamp?: number | undefined;
    /**
     * If true, enqueue the event for asynchronous processing and return 204 immediately. The response will not include balance information.
     */
    async?: boolean | undefined;
};
declare const TrackTokensIntervalEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type TrackTokensIntervalEnum2 = OpenEnum<typeof TrackTokensIntervalEnum2>;
/**
 * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
 */
type TrackTokensIntervalUnion2 = TrackTokensIntervalEnum2 | string;
type TrackTokensReset2 = {
    /**
     * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
     */
    interval: TrackTokensIntervalEnum2 | string;
    /**
     * Number of intervals between resets (eg. 2 for bi-monthly).
     */
    intervalCount?: number | undefined;
    /**
     * Timestamp when the balance will next reset.
     */
    resetsAt: number | null;
};
type TrackTokensDeduction2 = {
    /**
     * ID of the underlying balance row that was deducted from (customer_entitlement or rollover).
     */
    balanceId: string;
    /**
     * The feature this balance belongs to.
     */
    featureId: string;
    /**
     * ID of the plan/product this balance belongs to. Null when the balance can't be attributed to a single plan (e.g. it spans multiple).
     */
    planId: string | null;
    /**
     * Reset configuration for the balance this deduction came from, or null if the balance doesn't reset.
     */
    reset: TrackTokensReset2 | null;
    /**
     * Amount deducted from this balance. Positive when usage was consumed, negative when credit was restored (e.g. a refund via negative track value).
     */
    value: number;
};
/**
 * Accepted. Autumn is experiencing degraded service from a downstream provider, so the token usage event was accepted for replay and will be tracked as soon as the service is restored.
 */
type TrackTokensResponseBody2 = {
    /**
     * The ID of the customer whose usage was tracked.
     */
    customerId: string;
    /**
     * The ID of the entity, if entity-scoped tracking was performed.
     */
    entityId?: string | undefined;
    /**
     * The event name that was tracked, if event_name was used instead of feature_id.
     */
    eventName?: string | undefined;
    /**
     * The amount of usage that was recorded.
     */
    value: number;
    /**
     * The updated balance for the tracked feature. Null if tracking by event_name that affects multiple features.
     */
    balance: Balance | null;
    /**
     * Map of feature_id to updated balance for the tracked feature and any related features (e.g. linked credit systems). Value is null when the customer has no balance for that feature.
     */
    balances?: {
        [k: string]: Balance | null;
    } | undefined;
    /**
     * Per-balance breakdown of what this event deducted. A single event can consume from multiple balance rows when credit systems or rollovers are involved; this surfaces each one so callers can build per-feature usage views without polling.
     */
    deductions?: Array<TrackTokensDeduction2> | undefined;
};
declare const TrackTokensIntervalEnum1: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type TrackTokensIntervalEnum1 = OpenEnum<typeof TrackTokensIntervalEnum1>;
/**
 * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
 */
type TrackTokensIntervalUnion1 = TrackTokensIntervalEnum1 | string;
type TrackTokensReset1 = {
    /**
     * The reset interval (hour, day, week, month, etc.) or 'multiple' if combined from different intervals.
     */
    interval: TrackTokensIntervalEnum1 | string;
    /**
     * Number of intervals between resets (eg. 2 for bi-monthly).
     */
    intervalCount?: number | undefined;
    /**
     * Timestamp when the balance will next reset.
     */
    resetsAt: number | null;
};
type TrackTokensDeduction1 = {
    /**
     * ID of the underlying balance row that was deducted from (customer_entitlement or rollover).
     */
    balanceId: string;
    /**
     * The feature this balance belongs to.
     */
    featureId: string;
    /**
     * ID of the plan/product this balance belongs to. Null when the balance can't be attributed to a single plan (e.g. it spans multiple).
     */
    planId: string | null;
    /**
     * Reset configuration for the balance this deduction came from, or null if the balance doesn't reset.
     */
    reset: TrackTokensReset1 | null;
    /**
     * Amount deducted from this balance. Positive when usage was consumed, negative when credit was restored (e.g. a refund via negative track value).
     */
    value: number;
};
/**
 * OK
 */
type TrackTokensResponseBody1 = {
    /**
     * The ID of the customer whose usage was tracked.
     */
    customerId: string;
    /**
     * The ID of the entity, if entity-scoped tracking was performed.
     */
    entityId?: string | undefined;
    /**
     * The event name that was tracked, if event_name was used instead of feature_id.
     */
    eventName?: string | undefined;
    /**
     * The amount of usage that was recorded.
     */
    value: number;
    /**
     * The updated balance for the tracked feature. Null if tracking by event_name that affects multiple features.
     */
    balance: Balance | null;
    /**
     * Map of feature_id to updated balance for the tracked feature and any related features (e.g. linked credit systems). Value is null when the customer has no balance for that feature.
     */
    balances?: {
        [k: string]: Balance | null;
    } | undefined;
    /**
     * Per-balance breakdown of what this event deducted. A single event can consume from multiple balance rows when credit systems or rollovers are involved; this surfaces each one so callers can build per-feature usage views without polling.
     */
    deductions?: Array<TrackTokensDeduction1> | undefined;
};
type TrackTokensResponse = TrackTokensResponseBody1 | TrackTokensResponseBody2;
/** @internal */
type TrackTokensParams$Outbound = {
    customer_id: string;
    entity_id?: string | undefined;
    feature_id?: string | undefined;
    model_id: string;
    input_tokens: number;
    output_tokens: number;
    cache_read_tokens?: number | undefined;
    cache_write_tokens?: number | undefined;
    audio_input_tokens?: number | undefined;
    audio_output_tokens?: number | undefined;
    reasoning_tokens?: number | undefined;
    properties?: {
        [k: string]: any;
    } | undefined;
    timestamp?: number | undefined;
    async?: boolean | undefined;
};
/** @internal */
declare const TrackTokensParams$outboundSchema: z$1.ZodMiniType<TrackTokensParams$Outbound, TrackTokensParams>;
declare function trackTokensParamsToJSON(trackTokensParams: TrackTokensParams): string;
/** @internal */
declare const TrackTokensIntervalEnum2$inboundSchema: z$1.ZodMiniType<TrackTokensIntervalEnum2, unknown>;
/** @internal */
declare const TrackTokensIntervalUnion2$inboundSchema: z$1.ZodMiniType<TrackTokensIntervalUnion2, unknown>;
declare function trackTokensIntervalUnion2FromJSON(jsonString: string): Result$1<TrackTokensIntervalUnion2, SDKValidationError>;
/** @internal */
declare const TrackTokensReset2$inboundSchema: z$1.ZodMiniType<TrackTokensReset2, unknown>;
declare function trackTokensReset2FromJSON(jsonString: string): Result$1<TrackTokensReset2, SDKValidationError>;
/** @internal */
declare const TrackTokensDeduction2$inboundSchema: z$1.ZodMiniType<TrackTokensDeduction2, unknown>;
declare function trackTokensDeduction2FromJSON(jsonString: string): Result$1<TrackTokensDeduction2, SDKValidationError>;
/** @internal */
declare const TrackTokensResponseBody2$inboundSchema: z$1.ZodMiniType<TrackTokensResponseBody2, unknown>;
declare function trackTokensResponseBody2FromJSON(jsonString: string): Result$1<TrackTokensResponseBody2, SDKValidationError>;
/** @internal */
declare const TrackTokensIntervalEnum1$inboundSchema: z$1.ZodMiniType<TrackTokensIntervalEnum1, unknown>;
/** @internal */
declare const TrackTokensIntervalUnion1$inboundSchema: z$1.ZodMiniType<TrackTokensIntervalUnion1, unknown>;
declare function trackTokensIntervalUnion1FromJSON(jsonString: string): Result$1<TrackTokensIntervalUnion1, SDKValidationError>;
/** @internal */
declare const TrackTokensReset1$inboundSchema: z$1.ZodMiniType<TrackTokensReset1, unknown>;
declare function trackTokensReset1FromJSON(jsonString: string): Result$1<TrackTokensReset1, SDKValidationError>;
/** @internal */
declare const TrackTokensDeduction1$inboundSchema: z$1.ZodMiniType<TrackTokensDeduction1, unknown>;
declare function trackTokensDeduction1FromJSON(jsonString: string): Result$1<TrackTokensDeduction1, SDKValidationError>;
/** @internal */
declare const TrackTokensResponseBody1$inboundSchema: z$1.ZodMiniType<TrackTokensResponseBody1, unknown>;
declare function trackTokensResponseBody1FromJSON(jsonString: string): Result$1<TrackTokensResponseBody1, SDKValidationError>;
/** @internal */
declare const TrackTokensResponse$inboundSchema: z$1.ZodMiniType<TrackTokensResponse, unknown>;
declare function trackTokensResponseFromJSON(jsonString: string): Result$1<TrackTokensResponse, SDKValidationError>;

type UpdateBalanceGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Target a specific balance by its reset interval. Use when the customer has multiple balances for the same feature with different reset intervals.
 */
declare const UpdateBalanceInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Target a specific balance by its reset interval. Use when the customer has multiple balances for the same feature with different reset intervals.
 */
type UpdateBalanceInterval = ClosedEnum<typeof UpdateBalanceInterval>;
type UpdateBalanceParams = {
    /**
     * The ID of the customer.
     */
    customerId: string;
    /**
     * The ID of the feature.
     */
    featureId: string;
    /**
     * The ID of the entity for entity-scoped balances (e.g., per-seat limits).
     */
    entityId?: string | undefined;
    /**
     * Set the remaining balance to this exact value. Cannot be combined with add_to_balance.
     */
    remaining?: number | undefined;
    /**
     * Add this amount to the current balance. Use negative values to subtract. Cannot be combined with current_balance.
     */
    addToBalance?: number | undefined;
    /**
     * The usage amount to update. Cannot be combined with remaining or add_to_balance.
     */
    usage?: number | undefined;
    /**
     * Target a specific balance by its reset interval. Use when the customer has multiple balances for the same feature with different reset intervals.
     */
    interval?: UpdateBalanceInterval | undefined;
    /**
     * Set the granted balance to this exact value.
     */
    includedGrant?: number | undefined;
    /**
     * Target a specific balance by its ID (set on create). Use when the customer has multiple balances for the same feature.
     */
    balanceId?: string | undefined;
    /**
     * The next reset time for the balance. If there are multiple breakdowns, this will update the breakdown with the next reset time.
     */
    nextResetAt?: number | undefined;
    /**
     * Unix timestamp (milliseconds) when the balance expires. Targets a specific balance via balance_id / interval when the customer has multiple balances for the same feature.
     */
    expiresAt?: number | undefined;
};
/**
 * OK
 */
type UpdateBalanceResponse = {
    success: boolean;
};
/** @internal */
declare const UpdateBalanceInterval$outboundSchema: z$1.ZodMiniEnum<typeof UpdateBalanceInterval>;
/** @internal */
type UpdateBalanceParams$Outbound = {
    customer_id: string;
    feature_id: string;
    entity_id?: string | undefined;
    remaining?: number | undefined;
    add_to_balance?: number | undefined;
    usage?: number | undefined;
    interval?: string | undefined;
    included_grant?: number | undefined;
    balance_id?: string | undefined;
    next_reset_at?: number | undefined;
    expires_at?: number | undefined;
};
/** @internal */
declare const UpdateBalanceParams$outboundSchema: z$1.ZodMiniType<UpdateBalanceParams$Outbound, UpdateBalanceParams>;
declare function updateBalanceParamsToJSON(updateBalanceParams: UpdateBalanceParams): string;
/** @internal */
declare const UpdateBalanceResponse$inboundSchema: z$1.ZodMiniType<UpdateBalanceResponse, unknown>;
declare function updateBalanceResponseFromJSON(jsonString: string): Result$1<UpdateBalanceResponse, SDKValidationError>;

type UpdateCustomerGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const UpdateCustomerPurchaseLimitIntervalRequestBody: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type UpdateCustomerPurchaseLimitIntervalRequestBody = ClosedEnum<typeof UpdateCustomerPurchaseLimitIntervalRequestBody>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type UpdateCustomerPurchaseLimitRequest = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: UpdateCustomerPurchaseLimitIntervalRequestBody;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type UpdateCustomerAutoTopupRequest = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: UpdateCustomerPurchaseLimitRequest | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const UpdateCustomerLimitTypeRequestBody: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type UpdateCustomerLimitTypeRequestBody = ClosedEnum<typeof UpdateCustomerLimitTypeRequestBody>;
type UpdateCustomerSpendLimitRequest = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: UpdateCustomerLimitTypeRequestBody | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const UpdateCustomerUsageLimitIntervalRequestBody: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type UpdateCustomerUsageLimitIntervalRequestBody = ClosedEnum<typeof UpdateCustomerUsageLimitIntervalRequestBody>;
type UpdateCustomerProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type UpdateCustomerFilterRequest = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type UpdateCustomerUsageLimitRequest = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: UpdateCustomerUsageLimitIntervalRequestBody;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: UpdateCustomerFilterRequest | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const UpdateCustomerThresholdTypeRequestBody: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type UpdateCustomerThresholdTypeRequestBody = ClosedEnum<typeof UpdateCustomerThresholdTypeRequestBody>;
type UpdateCustomerUsageAlertRequestBody = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: UpdateCustomerThresholdTypeRequestBody;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type UpdateCustomerOverageAllowedRequest = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Billing controls for the customer (auto top-ups, etc.)
 */
type UpdateCustomerBillingControlsRequest = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<UpdateCustomerAutoTopupRequest> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<UpdateCustomerSpendLimitRequest> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<UpdateCustomerUsageLimitRequest> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<UpdateCustomerUsageAlertRequestBody> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<UpdateCustomerOverageAllowedRequest> | undefined;
};
/**
 * Miscellaneous configurations for the customer.
 */
type UpdateCustomerConfigRequest = {
    /**
     * Whether to disable the shared customer-level pool for entities.
     */
    disablePooledBalance?: boolean | undefined;
    /**
     * Stops Autumn from posting usage-overage line items to Stripe for this customer. Check/track and balance resets still behave normally. When set, this overrides the organization-level disable_overage_billing setting.
     */
    disableOverageBilling?: boolean | undefined;
};
type UpdateCustomerParams = {
    /**
     * ID of the customer to update
     */
    customerId: string;
    /**
     * Customer's name
     */
    name?: string | null | undefined;
    /**
     * Customer's email address
     */
    email?: string | null | undefined;
    /**
     * Unique identifier (eg, serial number) to detect duplicate customers and prevent free trial abuse
     */
    fingerprint?: string | null | undefined;
    /**
     * Additional metadata for the customer
     */
    metadata?: {
        [k: string]: any;
    } | null | undefined;
    /**
     * Stripe customer ID if you already have one
     */
    stripeId?: string | null | undefined;
    /**
     * Whether to send email receipts to this customer
     */
    sendEmailReceipts?: boolean | undefined;
    /**
     * Billing controls for the customer (auto top-ups, etc.)
     */
    billingControls?: UpdateCustomerBillingControlsRequest | undefined;
    /**
     * Miscellaneous configurations for the customer.
     */
    config?: UpdateCustomerConfigRequest | undefined;
    /**
     * Your unique identifier for the customer
     */
    newCustomerId?: string | undefined;
};
/**
 * The environment this customer was created in.
 */
declare const UpdateCustomerEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment this customer was created in.
 */
type UpdateCustomerEnv = OpenEnum<typeof UpdateCustomerEnv>;
/**
 * The time interval for the purchase limit window.
 */
declare const UpdateCustomerPurchaseLimitIntervalResponse2: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type UpdateCustomerPurchaseLimitIntervalResponse2 = OpenEnum<typeof UpdateCustomerPurchaseLimitIntervalResponse2>;
type UpdateCustomerPurchaseLimitResponse2 = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: UpdateCustomerPurchaseLimitIntervalResponse2;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
declare const UpdateCustomerPurchaseLimitIntervalResponse1: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
type UpdateCustomerPurchaseLimitIntervalResponse1 = OpenEnum<typeof UpdateCustomerPurchaseLimitIntervalResponse1>;
type UpdateCustomerPurchaseLimitResponse1 = {
    /**
     * The time interval for the purchase limit window. Null when no purchase limit is configured.
     */
    interval: UpdateCustomerPurchaseLimitIntervalResponse1 | null;
    /**
     * Number of intervals in the purchase limit window. Null when no purchase limit is configured.
     */
    intervalCount: number | null;
    /**
     * Maximum number of auto top-ups allowed within the interval. Null when no purchase limit is configured.
     */
    limit: number | null;
    /**
     * Number of auto top-ups already consumed in the current window.
     */
    count: number;
    /**
     * Unix ms timestamp when the current purchase window ends and the count resets.
     */
    nextResetAt: number;
};
/**
 * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
 */
type UpdateCustomerPurchaseLimitUnion = UpdateCustomerPurchaseLimitResponse1 | UpdateCustomerPurchaseLimitResponse2;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateCustomerAutoTopupSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateCustomerAutoTopupSource = OpenEnum<typeof UpdateCustomerAutoTopupSource>;
type UpdateCustomerAutoTopupResponse = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur. Expand billing_controls.auto_topups.purchase_limit for a count of top ups and the next_reset_at.
     */
    purchaseLimit?: UpdateCustomerPurchaseLimitResponse1 | UpdateCustomerPurchaseLimitResponse2 | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateCustomerAutoTopupSource | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const UpdateCustomerLimitTypeResponse: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type UpdateCustomerLimitTypeResponse = OpenEnum<typeof UpdateCustomerLimitTypeResponse>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateCustomerSpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateCustomerSpendLimitSource = OpenEnum<typeof UpdateCustomerSpendLimitSource>;
type UpdateCustomerSpendLimitResponse = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: UpdateCustomerLimitTypeResponse | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateCustomerSpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const UpdateCustomerUsageLimitIntervalResponse: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type UpdateCustomerUsageLimitIntervalResponse = OpenEnum<typeof UpdateCustomerUsageLimitIntervalResponse>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type UpdateCustomerFilterResponse = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateCustomerUsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateCustomerUsageLimitSource = OpenEnum<typeof UpdateCustomerUsageLimitSource>;
type UpdateCustomerUsageLimitResponse = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: UpdateCustomerUsageLimitIntervalResponse;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: UpdateCustomerFilterResponse | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateCustomerUsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const UpdateCustomerThresholdTypeResponse: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type UpdateCustomerThresholdTypeResponse = OpenEnum<typeof UpdateCustomerThresholdTypeResponse>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateCustomerUsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateCustomerUsageAlertSource = OpenEnum<typeof UpdateCustomerUsageAlertSource>;
type UpdateCustomerUsageAlertResponse = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: UpdateCustomerThresholdTypeResponse;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateCustomerUsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateCustomerOverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateCustomerOverageAllowedSource = OpenEnum<typeof UpdateCustomerOverageAllowedSource>;
type UpdateCustomerOverageAllowedResponse = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateCustomerOverageAllowedSource | undefined;
};
/**
 * Billing controls for the customer (auto top-ups, etc.)
 */
type UpdateCustomerBillingControlsResponse = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<UpdateCustomerAutoTopupResponse> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<UpdateCustomerSpendLimitResponse> | undefined;
    /**
     * List of hard usage caps per feature, with current interval usage.
     */
    usageLimits?: Array<UpdateCustomerUsageLimitResponse> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<UpdateCustomerUsageAlertResponse> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<UpdateCustomerOverageAllowedResponse> | undefined;
};
/**
 * Current status of the subscription.
 */
declare const UpdateCustomerStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type UpdateCustomerStatus = OpenEnum<typeof UpdateCustomerStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const UpdateCustomerSubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type UpdateCustomerSubscriptionScope = OpenEnum<typeof UpdateCustomerSubscriptionScope>;
type UpdateCustomerSubscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: UpdateCustomerStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: UpdateCustomerSubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const UpdateCustomerPurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type UpdateCustomerPurchaseScope = OpenEnum<typeof UpdateCustomerPurchaseScope>;
type UpdateCustomerPurchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: UpdateCustomerPurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const UpdateCustomerType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type UpdateCustomerType = OpenEnum<typeof UpdateCustomerType>;
type UpdateCustomerCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type UpdateCustomerModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type UpdateCustomerProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type UpdateCustomerDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type UpdateCustomerFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: UpdateCustomerType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<UpdateCustomerCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: UpdateCustomerModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: UpdateCustomerProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: UpdateCustomerDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type UpdateCustomerFlags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: UpdateCustomerFeature | undefined;
};
/**
 * Configuration for the customer.
 */
type UpdateCustomerConfigResponse = {
    /**
     * Whether to disable the shared customer-level pool for entities.
     */
    disablePooledBalance?: boolean | undefined;
    /**
     * Stops Autumn from posting usage-overage line items to Stripe for this customer. Check/track and balance resets still behave normally. When set, this overrides the organization-level disable_overage_billing setting.
     */
    disableOverageBilling?: boolean | undefined;
};
/**
 * Stripe processor connection for the customer.
 */
type UpdateCustomerStripe = {
    /**
     * Stripe customer ID.
     */
    id: string;
};
/**
 * Vercel processor connection for the customer (public-safe subset).
 */
type UpdateCustomerVercel = {
    /**
     * Vercel marketplace installation ID for this customer.
     */
    installationId: string;
    /**
     * Vercel account ID associated with the installation.
     */
    accountId: string;
};
/**
 * RevenueCat processor connection for the customer.
 */
type UpdateCustomerRevenuecat = {
    /**
     * Customer's external ID, used as the RevenueCat app user ID. Null if the customer has no external ID set.
     */
    id: string | null;
};
/**
 * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
 */
type UpdateCustomerProcessors = {
    /**
     * Stripe processor connection for the customer.
     */
    stripe?: UpdateCustomerStripe | undefined;
    /**
     * Vercel processor connection for the customer (public-safe subset).
     */
    vercel?: UpdateCustomerVercel | undefined;
    /**
     * RevenueCat processor connection for the customer.
     */
    revenuecat?: UpdateCustomerRevenuecat | undefined;
};
/**
 * OK
 */
type UpdateCustomerResponse = {
    /**
     * Your unique identifier for the customer.
     */
    id: string | null;
    /**
     * The name of the customer.
     */
    name: string | null;
    /**
     * The email address of the customer.
     */
    email: string | null;
    /**
     * Timestamp of customer creation in milliseconds since epoch.
     */
    createdAt: number;
    /**
     * A unique identifier (eg. serial number) to de-duplicate customers across devices or browsers. For example: apple device ID.
     */
    fingerprint: string | null;
    /**
     * Stripe customer ID.
     */
    stripeId: string | null;
    /**
     * The environment this customer was created in.
     */
    env: UpdateCustomerEnv;
    /**
     * The metadata for the customer.
     */
    metadata: {
        [k: string]: any;
    };
    /**
     * Whether to send email receipts to the customer.
     */
    sendEmailReceipts: boolean;
    /**
     * Billing controls for the customer (auto top-ups, etc.)
     */
    billingControls: UpdateCustomerBillingControlsResponse;
    /**
     * Active and scheduled recurring plans that this customer has attached.
     */
    subscriptions: Array<UpdateCustomerSubscription>;
    /**
     * One-time purchases made by the customer.
     */
    purchases: Array<UpdateCustomerPurchase>;
    /**
     * Feature balances keyed by feature ID, showing usage limits and remaining amounts.
     */
    balances: {
        [k: string]: Balance;
    };
    /**
     * Boolean feature flags keyed by feature ID, showing enabled access for on/off features.
     */
    flags: {
        [k: string]: UpdateCustomerFlags;
    };
    /**
     * Configuration for the customer.
     */
    config?: UpdateCustomerConfigResponse | undefined;
    /**
     * Payment processors this customer is connected to (Stripe, Vercel, RevenueCat). Omitted entirely when the customer has not been created in any processor.
     */
    processors?: UpdateCustomerProcessors | undefined;
};
/** @internal */
declare const UpdateCustomerPurchaseLimitIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateCustomerPurchaseLimitIntervalRequestBody>;
/** @internal */
type UpdateCustomerPurchaseLimitRequest$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const UpdateCustomerPurchaseLimitRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerPurchaseLimitRequest$Outbound, UpdateCustomerPurchaseLimitRequest>;
declare function updateCustomerPurchaseLimitRequestToJSON(updateCustomerPurchaseLimitRequest: UpdateCustomerPurchaseLimitRequest): string;
/** @internal */
type UpdateCustomerAutoTopupRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: UpdateCustomerPurchaseLimitRequest$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const UpdateCustomerAutoTopupRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerAutoTopupRequest$Outbound, UpdateCustomerAutoTopupRequest>;
declare function updateCustomerAutoTopupRequestToJSON(updateCustomerAutoTopupRequest: UpdateCustomerAutoTopupRequest): string;
/** @internal */
declare const UpdateCustomerLimitTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateCustomerLimitTypeRequestBody>;
/** @internal */
type UpdateCustomerSpendLimitRequest$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const UpdateCustomerSpendLimitRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerSpendLimitRequest$Outbound, UpdateCustomerSpendLimitRequest>;
declare function updateCustomerSpendLimitRequestToJSON(updateCustomerSpendLimitRequest: UpdateCustomerSpendLimitRequest): string;
/** @internal */
declare const UpdateCustomerUsageLimitIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateCustomerUsageLimitIntervalRequestBody>;
/** @internal */
type UpdateCustomerProperties$Outbound = string | number | boolean;
/** @internal */
declare const UpdateCustomerProperties$outboundSchema: z$1.ZodMiniType<UpdateCustomerProperties$Outbound, UpdateCustomerProperties>;
declare function updateCustomerPropertiesToJSON(updateCustomerProperties: UpdateCustomerProperties): string;
/** @internal */
type UpdateCustomerFilterRequest$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const UpdateCustomerFilterRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerFilterRequest$Outbound, UpdateCustomerFilterRequest>;
declare function updateCustomerFilterRequestToJSON(updateCustomerFilterRequest: UpdateCustomerFilterRequest): string;
/** @internal */
type UpdateCustomerUsageLimitRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: UpdateCustomerFilterRequest$Outbound | undefined;
};
/** @internal */
declare const UpdateCustomerUsageLimitRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerUsageLimitRequest$Outbound, UpdateCustomerUsageLimitRequest>;
declare function updateCustomerUsageLimitRequestToJSON(updateCustomerUsageLimitRequest: UpdateCustomerUsageLimitRequest): string;
/** @internal */
declare const UpdateCustomerThresholdTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateCustomerThresholdTypeRequestBody>;
/** @internal */
type UpdateCustomerUsageAlertRequestBody$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const UpdateCustomerUsageAlertRequestBody$outboundSchema: z$1.ZodMiniType<UpdateCustomerUsageAlertRequestBody$Outbound, UpdateCustomerUsageAlertRequestBody>;
declare function updateCustomerUsageAlertRequestBodyToJSON(updateCustomerUsageAlertRequestBody: UpdateCustomerUsageAlertRequestBody): string;
/** @internal */
type UpdateCustomerOverageAllowedRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const UpdateCustomerOverageAllowedRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerOverageAllowedRequest$Outbound, UpdateCustomerOverageAllowedRequest>;
declare function updateCustomerOverageAllowedRequestToJSON(updateCustomerOverageAllowedRequest: UpdateCustomerOverageAllowedRequest): string;
/** @internal */
type UpdateCustomerBillingControlsRequest$Outbound = {
    auto_topups?: Array<UpdateCustomerAutoTopupRequest$Outbound> | undefined;
    spend_limits?: Array<UpdateCustomerSpendLimitRequest$Outbound> | undefined;
    usage_limits?: Array<UpdateCustomerUsageLimitRequest$Outbound> | undefined;
    usage_alerts?: Array<UpdateCustomerUsageAlertRequestBody$Outbound> | undefined;
    overage_allowed?: Array<UpdateCustomerOverageAllowedRequest$Outbound> | undefined;
};
/** @internal */
declare const UpdateCustomerBillingControlsRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerBillingControlsRequest$Outbound, UpdateCustomerBillingControlsRequest>;
declare function updateCustomerBillingControlsRequestToJSON(updateCustomerBillingControlsRequest: UpdateCustomerBillingControlsRequest): string;
/** @internal */
type UpdateCustomerConfigRequest$Outbound = {
    disable_pooled_balance?: boolean | undefined;
    disable_overage_billing?: boolean | undefined;
};
/** @internal */
declare const UpdateCustomerConfigRequest$outboundSchema: z$1.ZodMiniType<UpdateCustomerConfigRequest$Outbound, UpdateCustomerConfigRequest>;
declare function updateCustomerConfigRequestToJSON(updateCustomerConfigRequest: UpdateCustomerConfigRequest): string;
/** @internal */
type UpdateCustomerParams$Outbound = {
    customer_id: string;
    name?: string | null | undefined;
    email?: string | null | undefined;
    fingerprint?: string | null | undefined;
    metadata?: {
        [k: string]: any;
    } | null | undefined;
    stripe_id?: string | null | undefined;
    send_email_receipts?: boolean | undefined;
    billing_controls?: UpdateCustomerBillingControlsRequest$Outbound | undefined;
    config?: UpdateCustomerConfigRequest$Outbound | undefined;
    new_customer_id?: string | undefined;
};
/** @internal */
declare const UpdateCustomerParams$outboundSchema: z$1.ZodMiniType<UpdateCustomerParams$Outbound, UpdateCustomerParams>;
declare function updateCustomerParamsToJSON(updateCustomerParams: UpdateCustomerParams): string;
/** @internal */
declare const UpdateCustomerEnv$inboundSchema: z$1.ZodMiniType<UpdateCustomerEnv, unknown>;
/** @internal */
declare const UpdateCustomerPurchaseLimitIntervalResponse2$inboundSchema: z$1.ZodMiniType<UpdateCustomerPurchaseLimitIntervalResponse2, unknown>;
/** @internal */
declare const UpdateCustomerPurchaseLimitResponse2$inboundSchema: z$1.ZodMiniType<UpdateCustomerPurchaseLimitResponse2, unknown>;
declare function updateCustomerPurchaseLimitResponse2FromJSON(jsonString: string): Result$1<UpdateCustomerPurchaseLimitResponse2, SDKValidationError>;
/** @internal */
declare const UpdateCustomerPurchaseLimitIntervalResponse1$inboundSchema: z$1.ZodMiniType<UpdateCustomerPurchaseLimitIntervalResponse1, unknown>;
/** @internal */
declare const UpdateCustomerPurchaseLimitResponse1$inboundSchema: z$1.ZodMiniType<UpdateCustomerPurchaseLimitResponse1, unknown>;
declare function updateCustomerPurchaseLimitResponse1FromJSON(jsonString: string): Result$1<UpdateCustomerPurchaseLimitResponse1, SDKValidationError>;
/** @internal */
declare const UpdateCustomerPurchaseLimitUnion$inboundSchema: z$1.ZodMiniType<UpdateCustomerPurchaseLimitUnion, unknown>;
declare function updateCustomerPurchaseLimitUnionFromJSON(jsonString: string): Result$1<UpdateCustomerPurchaseLimitUnion, SDKValidationError>;
/** @internal */
declare const UpdateCustomerAutoTopupSource$inboundSchema: z$1.ZodMiniType<UpdateCustomerAutoTopupSource, unknown>;
/** @internal */
declare const UpdateCustomerAutoTopupResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerAutoTopupResponse, unknown>;
declare function updateCustomerAutoTopupResponseFromJSON(jsonString: string): Result$1<UpdateCustomerAutoTopupResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerLimitTypeResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerLimitTypeResponse, unknown>;
/** @internal */
declare const UpdateCustomerSpendLimitSource$inboundSchema: z$1.ZodMiniType<UpdateCustomerSpendLimitSource, unknown>;
/** @internal */
declare const UpdateCustomerSpendLimitResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerSpendLimitResponse, unknown>;
declare function updateCustomerSpendLimitResponseFromJSON(jsonString: string): Result$1<UpdateCustomerSpendLimitResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerUsageLimitIntervalResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerUsageLimitIntervalResponse, unknown>;
/** @internal */
declare const UpdateCustomerFilterResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerFilterResponse, unknown>;
declare function updateCustomerFilterResponseFromJSON(jsonString: string): Result$1<UpdateCustomerFilterResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerUsageLimitSource$inboundSchema: z$1.ZodMiniType<UpdateCustomerUsageLimitSource, unknown>;
/** @internal */
declare const UpdateCustomerUsageLimitResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerUsageLimitResponse, unknown>;
declare function updateCustomerUsageLimitResponseFromJSON(jsonString: string): Result$1<UpdateCustomerUsageLimitResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerThresholdTypeResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerThresholdTypeResponse, unknown>;
/** @internal */
declare const UpdateCustomerUsageAlertSource$inboundSchema: z$1.ZodMiniType<UpdateCustomerUsageAlertSource, unknown>;
/** @internal */
declare const UpdateCustomerUsageAlertResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerUsageAlertResponse, unknown>;
declare function updateCustomerUsageAlertResponseFromJSON(jsonString: string): Result$1<UpdateCustomerUsageAlertResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerOverageAllowedSource$inboundSchema: z$1.ZodMiniType<UpdateCustomerOverageAllowedSource, unknown>;
/** @internal */
declare const UpdateCustomerOverageAllowedResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerOverageAllowedResponse, unknown>;
declare function updateCustomerOverageAllowedResponseFromJSON(jsonString: string): Result$1<UpdateCustomerOverageAllowedResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerBillingControlsResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerBillingControlsResponse, unknown>;
declare function updateCustomerBillingControlsResponseFromJSON(jsonString: string): Result$1<UpdateCustomerBillingControlsResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerStatus$inboundSchema: z$1.ZodMiniType<UpdateCustomerStatus, unknown>;
/** @internal */
declare const UpdateCustomerSubscriptionScope$inboundSchema: z$1.ZodMiniType<UpdateCustomerSubscriptionScope, unknown>;
/** @internal */
declare const UpdateCustomerSubscription$inboundSchema: z$1.ZodMiniType<UpdateCustomerSubscription, unknown>;
declare function updateCustomerSubscriptionFromJSON(jsonString: string): Result$1<UpdateCustomerSubscription, SDKValidationError>;
/** @internal */
declare const UpdateCustomerPurchaseScope$inboundSchema: z$1.ZodMiniType<UpdateCustomerPurchaseScope, unknown>;
/** @internal */
declare const UpdateCustomerPurchase$inboundSchema: z$1.ZodMiniType<UpdateCustomerPurchase, unknown>;
declare function updateCustomerPurchaseFromJSON(jsonString: string): Result$1<UpdateCustomerPurchase, SDKValidationError>;
/** @internal */
declare const UpdateCustomerType$inboundSchema: z$1.ZodMiniType<UpdateCustomerType, unknown>;
/** @internal */
declare const UpdateCustomerCreditSchema$inboundSchema: z$1.ZodMiniType<UpdateCustomerCreditSchema, unknown>;
declare function updateCustomerCreditSchemaFromJSON(jsonString: string): Result$1<UpdateCustomerCreditSchema, SDKValidationError>;
/** @internal */
declare const UpdateCustomerModelMarkups$inboundSchema: z$1.ZodMiniType<UpdateCustomerModelMarkups, unknown>;
declare function updateCustomerModelMarkupsFromJSON(jsonString: string): Result$1<UpdateCustomerModelMarkups, SDKValidationError>;
/** @internal */
declare const UpdateCustomerProviderMarkups$inboundSchema: z$1.ZodMiniType<UpdateCustomerProviderMarkups, unknown>;
declare function updateCustomerProviderMarkupsFromJSON(jsonString: string): Result$1<UpdateCustomerProviderMarkups, SDKValidationError>;
/** @internal */
declare const UpdateCustomerDisplay$inboundSchema: z$1.ZodMiniType<UpdateCustomerDisplay, unknown>;
declare function updateCustomerDisplayFromJSON(jsonString: string): Result$1<UpdateCustomerDisplay, SDKValidationError>;
/** @internal */
declare const UpdateCustomerFeature$inboundSchema: z$1.ZodMiniType<UpdateCustomerFeature, unknown>;
declare function updateCustomerFeatureFromJSON(jsonString: string): Result$1<UpdateCustomerFeature, SDKValidationError>;
/** @internal */
declare const UpdateCustomerFlags$inboundSchema: z$1.ZodMiniType<UpdateCustomerFlags, unknown>;
declare function updateCustomerFlagsFromJSON(jsonString: string): Result$1<UpdateCustomerFlags, SDKValidationError>;
/** @internal */
declare const UpdateCustomerConfigResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerConfigResponse, unknown>;
declare function updateCustomerConfigResponseFromJSON(jsonString: string): Result$1<UpdateCustomerConfigResponse, SDKValidationError>;
/** @internal */
declare const UpdateCustomerStripe$inboundSchema: z$1.ZodMiniType<UpdateCustomerStripe, unknown>;
declare function updateCustomerStripeFromJSON(jsonString: string): Result$1<UpdateCustomerStripe, SDKValidationError>;
/** @internal */
declare const UpdateCustomerVercel$inboundSchema: z$1.ZodMiniType<UpdateCustomerVercel, unknown>;
declare function updateCustomerVercelFromJSON(jsonString: string): Result$1<UpdateCustomerVercel, SDKValidationError>;
/** @internal */
declare const UpdateCustomerRevenuecat$inboundSchema: z$1.ZodMiniType<UpdateCustomerRevenuecat, unknown>;
declare function updateCustomerRevenuecatFromJSON(jsonString: string): Result$1<UpdateCustomerRevenuecat, SDKValidationError>;
/** @internal */
declare const UpdateCustomerProcessors$inboundSchema: z$1.ZodMiniType<UpdateCustomerProcessors, unknown>;
declare function updateCustomerProcessorsFromJSON(jsonString: string): Result$1<UpdateCustomerProcessors, SDKValidationError>;
/** @internal */
declare const UpdateCustomerResponse$inboundSchema: z$1.ZodMiniType<UpdateCustomerResponse, unknown>;
declare function updateCustomerResponseFromJSON(jsonString: string): Result$1<UpdateCustomerResponse, SDKValidationError>;

type UpdateEntityGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const UpdateEntityLimitTypeRequestBody: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type UpdateEntityLimitTypeRequestBody = ClosedEnum<typeof UpdateEntityLimitTypeRequestBody>;
type UpdateEntitySpendLimitRequest = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: UpdateEntityLimitTypeRequestBody | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const UpdateEntityIntervalRequestBody: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type UpdateEntityIntervalRequestBody = ClosedEnum<typeof UpdateEntityIntervalRequestBody>;
type UpdateEntityProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type UpdateEntityFilterRequest = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type UpdateEntityUsageLimitRequest = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: UpdateEntityIntervalRequestBody;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: UpdateEntityFilterRequest | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const UpdateEntityThresholdTypeRequestBody: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type UpdateEntityThresholdTypeRequestBody = ClosedEnum<typeof UpdateEntityThresholdTypeRequestBody>;
type UpdateEntityUsageAlertRequestBody = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: UpdateEntityThresholdTypeRequestBody;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type UpdateEntityOverageAllowedRequest = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Billing controls to replace on the entity.
 */
type UpdateEntityBillingControlsRequest = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<UpdateEntitySpendLimitRequest> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<UpdateEntityUsageLimitRequest> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<UpdateEntityUsageAlertRequestBody> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<UpdateEntityOverageAllowedRequest> | undefined;
};
type UpdateEntityParams = {
    /**
     * The ID of the customer that owns the entity.
     */
    customerId?: string | undefined;
    /**
     * The ID of the entity.
     */
    entityId: string;
    /**
     * Billing controls to replace on the entity.
     */
    billingControls?: UpdateEntityBillingControlsRequest | undefined;
};
/**
 * The environment (sandbox/live)
 */
declare const UpdateEntityEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * The environment (sandbox/live)
 */
type UpdateEntityEnv = OpenEnum<typeof UpdateEntityEnv>;
/**
 * Current status of the subscription.
 */
declare const UpdateEntityStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * Current status of the subscription.
 */
type UpdateEntityStatus = OpenEnum<typeof UpdateEntityStatus>;
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
declare const UpdateEntitySubscriptionScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this subscription is attached at the customer level or entity level.
 */
type UpdateEntitySubscriptionScope = OpenEnum<typeof UpdateEntitySubscriptionScope>;
type UpdateEntitySubscription = {
    /**
     * The unique identifier of this subscription. If a subscription_id was provided at attach time, it is used; otherwise, falls back to the internal ID.
     */
    id: string;
    plan?: Plan | undefined;
    /**
     * The unique identifier of the subscribed plan.
     */
    planId: string;
    /**
     * Whether the plan was automatically enabled for the customer.
     */
    autoEnable: boolean;
    /**
     * Whether this is an add-on plan rather than a base subscription.
     */
    addOn: boolean;
    /**
     * Current status of the subscription.
     */
    status: UpdateEntityStatus;
    /**
     * Whether the subscription has overdue payments.
     */
    pastDue: boolean;
    /**
     * Timestamp when the subscription was canceled, or null if not canceled.
     */
    canceledAt: number | null;
    /**
     * Timestamp when the subscription will expire, or null if no expiry set.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the trial period ends, or null if not on trial.
     */
    trialEndsAt: number | null;
    /**
     * Timestamp when the subscription started.
     */
    startedAt: number;
    /**
     * Start timestamp of the current billing period.
     */
    currentPeriodStart: number | null;
    /**
     * End timestamp of the current billing period.
     */
    currentPeriodEnd: number | null;
    /**
     * Number of units of this subscription (for per-seat plans).
     */
    quantity: number;
    /**
     * Whether this subscription is attached at the customer level or entity level.
     */
    scope?: UpdateEntitySubscriptionScope | undefined;
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
declare const UpdateEntityPurchaseScope: {
    readonly Customer: "customer";
    readonly Entity: "entity";
};
/**
 * Whether this purchase is attached at the customer level or entity level.
 */
type UpdateEntityPurchaseScope = OpenEnum<typeof UpdateEntityPurchaseScope>;
type UpdateEntityPurchase = {
    plan?: Plan | undefined;
    /**
     * The unique identifier of the purchased plan.
     */
    planId: string;
    /**
     * Timestamp when the purchase expires, or null for lifetime access.
     */
    expiresAt: number | null;
    /**
     * Timestamp when the purchase was made.
     */
    startedAt: number;
    /**
     * Number of units purchased.
     */
    quantity: number;
    /**
     * Whether this purchase is attached at the customer level or entity level.
     */
    scope?: UpdateEntityPurchaseScope | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const UpdateEntityType: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type UpdateEntityType = OpenEnum<typeof UpdateEntityType>;
type UpdateEntityCreditSchema = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type UpdateEntityModelMarkups = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type UpdateEntityProviderMarkups = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type UpdateEntityDisplay = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * The full feature object if expanded.
 */
type UpdateEntityFeature = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: UpdateEntityType;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<UpdateEntityCreditSchema> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: UpdateEntityModelMarkups;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: UpdateEntityProviderMarkups;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: UpdateEntityDisplay | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
type UpdateEntityFlags = {
    /**
     * The unique identifier for this flag.
     */
    id: string;
    /**
     * The plan ID this flag originates from, or null for standalone flags.
     */
    planId: string | null;
    /**
     * Timestamp when this flag expires, or null for no expiration.
     */
    expiresAt: number | null;
    /**
     * The feature ID this flag is for.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: UpdateEntityFeature | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const UpdateEntityLimitTypeResponse: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type UpdateEntityLimitTypeResponse = OpenEnum<typeof UpdateEntityLimitTypeResponse>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateEntitySpendLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateEntitySpendLimitSource = OpenEnum<typeof UpdateEntitySpendLimitSource>;
type UpdateEntitySpendLimitResponse = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: UpdateEntityLimitTypeResponse | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateEntitySpendLimitSource | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const UpdateEntityIntervalResponse: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type UpdateEntityIntervalResponse = OpenEnum<typeof UpdateEntityIntervalResponse>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type UpdateEntityFilterResponse = {
    properties: {
        [k: string]: any;
    };
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateEntityUsageLimitSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateEntityUsageLimitSource = OpenEnum<typeof UpdateEntityUsageLimitSource>;
type UpdateEntityUsageLimitResponse = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: UpdateEntityIntervalResponse;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: UpdateEntityFilterResponse | undefined;
    /**
     * Current usage already consumed in the active interval. Response-only; not stored on billing controls.
     */
    usage?: number | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateEntityUsageLimitSource | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const UpdateEntityThresholdTypeResponse: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type UpdateEntityThresholdTypeResponse = OpenEnum<typeof UpdateEntityThresholdTypeResponse>;
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateEntityUsageAlertSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateEntityUsageAlertSource = OpenEnum<typeof UpdateEntityUsageAlertSource>;
type UpdateEntityUsageAlertResponse = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: UpdateEntityThresholdTypeResponse;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateEntityUsageAlertSource | undefined;
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
declare const UpdateEntityOverageAllowedSource: {
    readonly Customer: "customer";
    readonly Plan: "plan";
};
/**
 * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
 */
type UpdateEntityOverageAllowedSource = OpenEnum<typeof UpdateEntityOverageAllowedSource>;
type UpdateEntityOverageAllowedResponse = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
    /**
     * Response-only: whether the entry is a customer-level override or inherited from an attached plan's defaults.
     */
    source?: UpdateEntityOverageAllowedSource | undefined;
};
/**
 * Billing controls for the entity.
 */
type UpdateEntityBillingControlsResponse = {
    /**
     * List of spend limits per feature. Each entry caps overage (overage_limit) and/or per-interval usage (usage_limit).
     */
    spendLimits?: Array<UpdateEntitySpendLimitResponse> | undefined;
    /**
     * List of hard usage caps per feature for this entity. An entity entry overrides the customer's for that feature.
     */
    usageLimits?: Array<UpdateEntityUsageLimitResponse> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<UpdateEntityUsageAlertResponse> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<UpdateEntityOverageAllowedResponse> | undefined;
};
/**
 * The billing processor that owns this invoice.
 */
declare const UpdateEntityProcessorType: {
    readonly Stripe: "stripe";
    readonly Revenuecat: "revenuecat";
};
/**
 * The billing processor that owns this invoice.
 */
type UpdateEntityProcessorType = OpenEnum<typeof UpdateEntityProcessorType>;
type UpdateEntityInvoice = {
    /**
     * Array of plan IDs included in this invoice
     */
    planIds: Array<string>;
    /**
     * The Stripe invoice ID
     */
    stripeId: string;
    /**
     * The billing processor that owns this invoice.
     */
    processorType: UpdateEntityProcessorType;
    /**
     * The status of the invoice
     */
    status: string;
    /**
     * The total amount of the invoice
     */
    total: number;
    /**
     * The currency code for the invoice
     */
    currency: string;
    /**
     * Timestamp when the invoice was created
     */
    createdAt: number;
    /**
     * URL to the Stripe-hosted invoice page
     */
    hostedInvoiceUrl?: string | null | undefined;
};
/**
 * OK
 */
type UpdateEntityResponse = {
    /**
     * The unique identifier of the entity
     */
    id: string | null;
    /**
     * The name of the entity
     */
    name: string | null;
    /**
     * The customer ID this entity belongs to
     */
    customerId?: string | null | undefined;
    /**
     * The feature ID this entity belongs to
     */
    featureId?: string | null | undefined;
    /**
     * Unix timestamp when the entity was created
     */
    createdAt: number;
    /**
     * The environment (sandbox/live)
     */
    env: UpdateEntityEnv;
    subscriptions: Array<UpdateEntitySubscription>;
    purchases: Array<UpdateEntityPurchase>;
    balances: {
        [k: string]: Balance;
    };
    flags: {
        [k: string]: UpdateEntityFlags;
    };
    /**
     * Billing controls for the entity.
     */
    billingControls?: UpdateEntityBillingControlsResponse | undefined;
    /**
     * Invoices for this entity (only included when expand=invoices)
     */
    invoices?: Array<UpdateEntityInvoice> | undefined;
};
/** @internal */
declare const UpdateEntityLimitTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateEntityLimitTypeRequestBody>;
/** @internal */
type UpdateEntitySpendLimitRequest$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const UpdateEntitySpendLimitRequest$outboundSchema: z$1.ZodMiniType<UpdateEntitySpendLimitRequest$Outbound, UpdateEntitySpendLimitRequest>;
declare function updateEntitySpendLimitRequestToJSON(updateEntitySpendLimitRequest: UpdateEntitySpendLimitRequest): string;
/** @internal */
declare const UpdateEntityIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateEntityIntervalRequestBody>;
/** @internal */
type UpdateEntityProperties$Outbound = string | number | boolean;
/** @internal */
declare const UpdateEntityProperties$outboundSchema: z$1.ZodMiniType<UpdateEntityProperties$Outbound, UpdateEntityProperties>;
declare function updateEntityPropertiesToJSON(updateEntityProperties: UpdateEntityProperties): string;
/** @internal */
type UpdateEntityFilterRequest$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const UpdateEntityFilterRequest$outboundSchema: z$1.ZodMiniType<UpdateEntityFilterRequest$Outbound, UpdateEntityFilterRequest>;
declare function updateEntityFilterRequestToJSON(updateEntityFilterRequest: UpdateEntityFilterRequest): string;
/** @internal */
type UpdateEntityUsageLimitRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: UpdateEntityFilterRequest$Outbound | undefined;
};
/** @internal */
declare const UpdateEntityUsageLimitRequest$outboundSchema: z$1.ZodMiniType<UpdateEntityUsageLimitRequest$Outbound, UpdateEntityUsageLimitRequest>;
declare function updateEntityUsageLimitRequestToJSON(updateEntityUsageLimitRequest: UpdateEntityUsageLimitRequest): string;
/** @internal */
declare const UpdateEntityThresholdTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateEntityThresholdTypeRequestBody>;
/** @internal */
type UpdateEntityUsageAlertRequestBody$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const UpdateEntityUsageAlertRequestBody$outboundSchema: z$1.ZodMiniType<UpdateEntityUsageAlertRequestBody$Outbound, UpdateEntityUsageAlertRequestBody>;
declare function updateEntityUsageAlertRequestBodyToJSON(updateEntityUsageAlertRequestBody: UpdateEntityUsageAlertRequestBody): string;
/** @internal */
type UpdateEntityOverageAllowedRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const UpdateEntityOverageAllowedRequest$outboundSchema: z$1.ZodMiniType<UpdateEntityOverageAllowedRequest$Outbound, UpdateEntityOverageAllowedRequest>;
declare function updateEntityOverageAllowedRequestToJSON(updateEntityOverageAllowedRequest: UpdateEntityOverageAllowedRequest): string;
/** @internal */
type UpdateEntityBillingControlsRequest$Outbound = {
    spend_limits?: Array<UpdateEntitySpendLimitRequest$Outbound> | undefined;
    usage_limits?: Array<UpdateEntityUsageLimitRequest$Outbound> | undefined;
    usage_alerts?: Array<UpdateEntityUsageAlertRequestBody$Outbound> | undefined;
    overage_allowed?: Array<UpdateEntityOverageAllowedRequest$Outbound> | undefined;
};
/** @internal */
declare const UpdateEntityBillingControlsRequest$outboundSchema: z$1.ZodMiniType<UpdateEntityBillingControlsRequest$Outbound, UpdateEntityBillingControlsRequest>;
declare function updateEntityBillingControlsRequestToJSON(updateEntityBillingControlsRequest: UpdateEntityBillingControlsRequest): string;
/** @internal */
type UpdateEntityParams$Outbound = {
    customer_id?: string | undefined;
    entity_id: string;
    billing_controls?: UpdateEntityBillingControlsRequest$Outbound | undefined;
};
/** @internal */
declare const UpdateEntityParams$outboundSchema: z$1.ZodMiniType<UpdateEntityParams$Outbound, UpdateEntityParams>;
declare function updateEntityParamsToJSON(updateEntityParams: UpdateEntityParams): string;
/** @internal */
declare const UpdateEntityEnv$inboundSchema: z$1.ZodMiniType<UpdateEntityEnv, unknown>;
/** @internal */
declare const UpdateEntityStatus$inboundSchema: z$1.ZodMiniType<UpdateEntityStatus, unknown>;
/** @internal */
declare const UpdateEntitySubscriptionScope$inboundSchema: z$1.ZodMiniType<UpdateEntitySubscriptionScope, unknown>;
/** @internal */
declare const UpdateEntitySubscription$inboundSchema: z$1.ZodMiniType<UpdateEntitySubscription, unknown>;
declare function updateEntitySubscriptionFromJSON(jsonString: string): Result$1<UpdateEntitySubscription, SDKValidationError>;
/** @internal */
declare const UpdateEntityPurchaseScope$inboundSchema: z$1.ZodMiniType<UpdateEntityPurchaseScope, unknown>;
/** @internal */
declare const UpdateEntityPurchase$inboundSchema: z$1.ZodMiniType<UpdateEntityPurchase, unknown>;
declare function updateEntityPurchaseFromJSON(jsonString: string): Result$1<UpdateEntityPurchase, SDKValidationError>;
/** @internal */
declare const UpdateEntityType$inboundSchema: z$1.ZodMiniType<UpdateEntityType, unknown>;
/** @internal */
declare const UpdateEntityCreditSchema$inboundSchema: z$1.ZodMiniType<UpdateEntityCreditSchema, unknown>;
declare function updateEntityCreditSchemaFromJSON(jsonString: string): Result$1<UpdateEntityCreditSchema, SDKValidationError>;
/** @internal */
declare const UpdateEntityModelMarkups$inboundSchema: z$1.ZodMiniType<UpdateEntityModelMarkups, unknown>;
declare function updateEntityModelMarkupsFromJSON(jsonString: string): Result$1<UpdateEntityModelMarkups, SDKValidationError>;
/** @internal */
declare const UpdateEntityProviderMarkups$inboundSchema: z$1.ZodMiniType<UpdateEntityProviderMarkups, unknown>;
declare function updateEntityProviderMarkupsFromJSON(jsonString: string): Result$1<UpdateEntityProviderMarkups, SDKValidationError>;
/** @internal */
declare const UpdateEntityDisplay$inboundSchema: z$1.ZodMiniType<UpdateEntityDisplay, unknown>;
declare function updateEntityDisplayFromJSON(jsonString: string): Result$1<UpdateEntityDisplay, SDKValidationError>;
/** @internal */
declare const UpdateEntityFeature$inboundSchema: z$1.ZodMiniType<UpdateEntityFeature, unknown>;
declare function updateEntityFeatureFromJSON(jsonString: string): Result$1<UpdateEntityFeature, SDKValidationError>;
/** @internal */
declare const UpdateEntityFlags$inboundSchema: z$1.ZodMiniType<UpdateEntityFlags, unknown>;
declare function updateEntityFlagsFromJSON(jsonString: string): Result$1<UpdateEntityFlags, SDKValidationError>;
/** @internal */
declare const UpdateEntityLimitTypeResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityLimitTypeResponse, unknown>;
/** @internal */
declare const UpdateEntitySpendLimitSource$inboundSchema: z$1.ZodMiniType<UpdateEntitySpendLimitSource, unknown>;
/** @internal */
declare const UpdateEntitySpendLimitResponse$inboundSchema: z$1.ZodMiniType<UpdateEntitySpendLimitResponse, unknown>;
declare function updateEntitySpendLimitResponseFromJSON(jsonString: string): Result$1<UpdateEntitySpendLimitResponse, SDKValidationError>;
/** @internal */
declare const UpdateEntityIntervalResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityIntervalResponse, unknown>;
/** @internal */
declare const UpdateEntityFilterResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityFilterResponse, unknown>;
declare function updateEntityFilterResponseFromJSON(jsonString: string): Result$1<UpdateEntityFilterResponse, SDKValidationError>;
/** @internal */
declare const UpdateEntityUsageLimitSource$inboundSchema: z$1.ZodMiniType<UpdateEntityUsageLimitSource, unknown>;
/** @internal */
declare const UpdateEntityUsageLimitResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityUsageLimitResponse, unknown>;
declare function updateEntityUsageLimitResponseFromJSON(jsonString: string): Result$1<UpdateEntityUsageLimitResponse, SDKValidationError>;
/** @internal */
declare const UpdateEntityThresholdTypeResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityThresholdTypeResponse, unknown>;
/** @internal */
declare const UpdateEntityUsageAlertSource$inboundSchema: z$1.ZodMiniType<UpdateEntityUsageAlertSource, unknown>;
/** @internal */
declare const UpdateEntityUsageAlertResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityUsageAlertResponse, unknown>;
declare function updateEntityUsageAlertResponseFromJSON(jsonString: string): Result$1<UpdateEntityUsageAlertResponse, SDKValidationError>;
/** @internal */
declare const UpdateEntityOverageAllowedSource$inboundSchema: z$1.ZodMiniType<UpdateEntityOverageAllowedSource, unknown>;
/** @internal */
declare const UpdateEntityOverageAllowedResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityOverageAllowedResponse, unknown>;
declare function updateEntityOverageAllowedResponseFromJSON(jsonString: string): Result$1<UpdateEntityOverageAllowedResponse, SDKValidationError>;
/** @internal */
declare const UpdateEntityBillingControlsResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityBillingControlsResponse, unknown>;
declare function updateEntityBillingControlsResponseFromJSON(jsonString: string): Result$1<UpdateEntityBillingControlsResponse, SDKValidationError>;
/** @internal */
declare const UpdateEntityProcessorType$inboundSchema: z$1.ZodMiniType<UpdateEntityProcessorType, unknown>;
/** @internal */
declare const UpdateEntityInvoice$inboundSchema: z$1.ZodMiniType<UpdateEntityInvoice, unknown>;
declare function updateEntityInvoiceFromJSON(jsonString: string): Result$1<UpdateEntityInvoice, SDKValidationError>;
/** @internal */
declare const UpdateEntityResponse$inboundSchema: z$1.ZodMiniType<UpdateEntityResponse, unknown>;
declare function updateEntityResponseFromJSON(jsonString: string): Result$1<UpdateEntityResponse, SDKValidationError>;

type UpdateFeatureGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system.
 */
declare const UpdateFeatureTypeRequestBody: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system.
 */
type UpdateFeatureTypeRequestBody = ClosedEnum<typeof UpdateFeatureTypeRequestBody>;
/**
 * Singular and plural display names for the feature in your user interface.
 */
type UpdateFeatureDisplayRequestBody = {
    singular: string;
    plural: string;
};
type UpdateFeatureCreditSchemaRequestBody = {
    meteredFeatureId: string;
    creditCost: number;
};
type UpdateFeatureModelMarkupsRequest = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type UpdateFeatureProviderMarkupsRequest = {
    markup: number;
};
type UpdateFeatureParams = {
    /**
     * The name of the feature.
     */
    name?: string | undefined;
    /**
     * The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system.
     */
    type?: UpdateFeatureTypeRequestBody | undefined;
    /**
     * Whether this feature is consumable. A consumable feature is one that periodically resets and is consumed rather than allocated (like credits, API requests, etc.). Applicable only for 'metered' features.
     */
    consumable?: boolean | undefined;
    /**
     * Singular and plural display names for the feature in your user interface.
     */
    display?: UpdateFeatureDisplayRequestBody | undefined;
    /**
     * A schema that maps 'single_use' feature IDs to credit costs. For classic credit systems only — AI credit systems use model_markups instead.
     */
    creditSchema?: Array<UpdateFeatureCreditSchemaRequestBody> | undefined;
    /**
     * Per-model markup overrides for AI credit systems. Maps model IDs to their markup configuration.
     */
    modelMarkups?: {
        [k: string]: UpdateFeatureModelMarkupsRequest;
    } | null | undefined;
    /**
     * Default percentage markup for this AI credit system. Used when no model or provider markup applies. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems. Provider keys match the first segment of model_id.
     */
    providerMarkups?: {
        [k: string]: UpdateFeatureProviderMarkupsRequest;
    } | null | undefined;
    eventNames?: Array<string> | undefined;
    /**
     * Whether the feature is archived. Archived features are hidden from the dashboard.
     */
    archived?: boolean | undefined;
    /**
     * The ID of the feature to update.
     */
    featureId: string;
    /**
     * The new ID of the feature. Feature ID can only be updated if it's not being used by any customers.
     */
    newFeatureId?: string | undefined;
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
declare const UpdateFeatureTypeResponse: {
    readonly Boolean: "boolean";
    readonly Metered: "metered";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
 */
type UpdateFeatureTypeResponse = OpenEnum<typeof UpdateFeatureTypeResponse>;
type UpdateFeatureCreditSchemaResponse = {
    /**
     * ID of the metered feature that draws from this credit system.
     */
    meteredFeatureId: string;
    /**
     * Credits consumed per unit of the metered feature.
     */
    creditCost: number;
};
type UpdateFeatureModelMarkupsResponse = {
    markup?: number | undefined;
    inputCost?: number | undefined;
    outputCost?: number | undefined;
};
type UpdateFeatureProviderMarkupsResponse = {
    markup: number;
};
/**
 * Display names for the feature in billing UI and customer-facing components.
 */
type UpdateFeatureDisplayResponse = {
    /**
     * Singular form for UI display (e.g., 'API call', 'seat').
     */
    singular?: string | null | undefined;
    /**
     * Plural form for UI display (e.g., 'API calls', 'seats').
     */
    plural?: string | null | undefined;
};
/**
 * OK
 */
type UpdateFeatureResponse = {
    /**
     * The unique identifier for this feature, used in /check and /track calls.
     */
    id: string;
    /**
     * Human-readable name displayed in the dashboard and billing UI.
     */
    name: string;
    /**
     * Feature type: 'boolean' for on/off access, 'metered' for usage-tracked features, 'credit_system' for unified credit pools, 'ai_credit_system' for model-based token pricing.
     */
    type: UpdateFeatureTypeResponse;
    /**
     * For metered features: true if usage resets periodically (API calls, credits), false if allocated persistently (seats, storage).
     */
    consumable: boolean;
    /**
     * Event names that trigger this feature's balance. Allows multiple features to respond to a single event.
     */
    eventNames?: Array<string> | undefined;
    /**
     * For credit_system features: maps metered features to their credit costs.
     */
    creditSchema?: Array<UpdateFeatureCreditSchemaResponse> | undefined;
    /**
     * Per-model markup overrides for AI credit systems.
     */
    modelMarkups?: {
        [k: string]: UpdateFeatureModelMarkupsResponse;
    } | null | undefined;
    /**
     * Default percentage markup for AI credit systems. Use -100 to make usage free.
     */
    defaultMarkup?: number | undefined;
    /**
     * Per-provider default markup percentages for AI credit systems.
     */
    providerMarkups?: {
        [k: string]: UpdateFeatureProviderMarkupsResponse;
    } | null | undefined;
    /**
     * Display names for the feature in billing UI and customer-facing components.
     */
    display?: UpdateFeatureDisplayResponse | undefined;
    /**
     * Whether the feature is archived and hidden from the dashboard.
     */
    archived: boolean;
};
/** @internal */
declare const UpdateFeatureTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdateFeatureTypeRequestBody>;
/** @internal */
type UpdateFeatureDisplayRequestBody$Outbound = {
    singular: string;
    plural: string;
};
/** @internal */
declare const UpdateFeatureDisplayRequestBody$outboundSchema: z$1.ZodMiniType<UpdateFeatureDisplayRequestBody$Outbound, UpdateFeatureDisplayRequestBody>;
declare function updateFeatureDisplayRequestBodyToJSON(updateFeatureDisplayRequestBody: UpdateFeatureDisplayRequestBody): string;
/** @internal */
type UpdateFeatureCreditSchemaRequestBody$Outbound = {
    metered_feature_id: string;
    credit_cost: number;
};
/** @internal */
declare const UpdateFeatureCreditSchemaRequestBody$outboundSchema: z$1.ZodMiniType<UpdateFeatureCreditSchemaRequestBody$Outbound, UpdateFeatureCreditSchemaRequestBody>;
declare function updateFeatureCreditSchemaRequestBodyToJSON(updateFeatureCreditSchemaRequestBody: UpdateFeatureCreditSchemaRequestBody): string;
/** @internal */
type UpdateFeatureModelMarkupsRequest$Outbound = {
    markup?: number | undefined;
    input_cost?: number | undefined;
    output_cost?: number | undefined;
};
/** @internal */
declare const UpdateFeatureModelMarkupsRequest$outboundSchema: z$1.ZodMiniType<UpdateFeatureModelMarkupsRequest$Outbound, UpdateFeatureModelMarkupsRequest>;
declare function updateFeatureModelMarkupsRequestToJSON(updateFeatureModelMarkupsRequest: UpdateFeatureModelMarkupsRequest): string;
/** @internal */
type UpdateFeatureProviderMarkupsRequest$Outbound = {
    markup: number;
};
/** @internal */
declare const UpdateFeatureProviderMarkupsRequest$outboundSchema: z$1.ZodMiniType<UpdateFeatureProviderMarkupsRequest$Outbound, UpdateFeatureProviderMarkupsRequest>;
declare function updateFeatureProviderMarkupsRequestToJSON(updateFeatureProviderMarkupsRequest: UpdateFeatureProviderMarkupsRequest): string;
/** @internal */
type UpdateFeatureParams$Outbound = {
    name?: string | undefined;
    type?: string | undefined;
    consumable?: boolean | undefined;
    display?: UpdateFeatureDisplayRequestBody$Outbound | undefined;
    credit_schema?: Array<UpdateFeatureCreditSchemaRequestBody$Outbound> | undefined;
    model_markups?: {
        [k: string]: UpdateFeatureModelMarkupsRequest$Outbound;
    } | null | undefined;
    default_markup?: number | undefined;
    provider_markups?: {
        [k: string]: UpdateFeatureProviderMarkupsRequest$Outbound;
    } | null | undefined;
    event_names?: Array<string> | undefined;
    archived?: boolean | undefined;
    feature_id: string;
    new_feature_id?: string | undefined;
};
/** @internal */
declare const UpdateFeatureParams$outboundSchema: z$1.ZodMiniType<UpdateFeatureParams$Outbound, UpdateFeatureParams>;
declare function updateFeatureParamsToJSON(updateFeatureParams: UpdateFeatureParams): string;
/** @internal */
declare const UpdateFeatureTypeResponse$inboundSchema: z$1.ZodMiniType<UpdateFeatureTypeResponse, unknown>;
/** @internal */
declare const UpdateFeatureCreditSchemaResponse$inboundSchema: z$1.ZodMiniType<UpdateFeatureCreditSchemaResponse, unknown>;
declare function updateFeatureCreditSchemaResponseFromJSON(jsonString: string): Result$1<UpdateFeatureCreditSchemaResponse, SDKValidationError>;
/** @internal */
declare const UpdateFeatureModelMarkupsResponse$inboundSchema: z$1.ZodMiniType<UpdateFeatureModelMarkupsResponse, unknown>;
declare function updateFeatureModelMarkupsResponseFromJSON(jsonString: string): Result$1<UpdateFeatureModelMarkupsResponse, SDKValidationError>;
/** @internal */
declare const UpdateFeatureProviderMarkupsResponse$inboundSchema: z$1.ZodMiniType<UpdateFeatureProviderMarkupsResponse, unknown>;
declare function updateFeatureProviderMarkupsResponseFromJSON(jsonString: string): Result$1<UpdateFeatureProviderMarkupsResponse, SDKValidationError>;
/** @internal */
declare const UpdateFeatureDisplayResponse$inboundSchema: z$1.ZodMiniType<UpdateFeatureDisplayResponse, unknown>;
declare function updateFeatureDisplayResponseFromJSON(jsonString: string): Result$1<UpdateFeatureDisplayResponse, SDKValidationError>;
/** @internal */
declare const UpdateFeatureResponse$inboundSchema: z$1.ZodMiniType<UpdateFeatureResponse, unknown>;
declare function updateFeatureResponseFromJSON(jsonString: string): Result$1<UpdateFeatureResponse, SDKValidationError>;

type UpdatePlanGlobals = {
    xApiVersion?: string | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const UpdatePlanPriceIntervalRequestBody: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type UpdatePlanPriceIntervalRequestBody = ClosedEnum<typeof UpdatePlanPriceIntervalRequestBody>;
/**
 * Base price configuration for a plan.
 */
type UpdatePlanBasePriceRequest = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: UpdatePlanPriceIntervalRequestBody;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const UpdatePlanItemResetIntervalRequestBody: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type UpdatePlanItemResetIntervalRequestBody = ClosedEnum<typeof UpdatePlanItemResetIntervalRequestBody>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type UpdatePlanItemResetRequestBody = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: UpdatePlanItemResetIntervalRequestBody;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type UpdatePlanItemToRequestBody = number | string;
type UpdatePlanItemTierRequestBody = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const UpdatePlanItemTierBehaviorRequestBody: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type UpdatePlanItemTierBehaviorRequestBody = ClosedEnum<typeof UpdatePlanItemTierBehaviorRequestBody>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const UpdatePlanItemPriceIntervalRequestBody: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type UpdatePlanItemPriceIntervalRequestBody = ClosedEnum<typeof UpdatePlanItemPriceIntervalRequestBody>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const UpdatePlanItemBillingMethodRequestBody: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type UpdatePlanItemBillingMethodRequestBody = ClosedEnum<typeof UpdatePlanItemBillingMethodRequestBody>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type UpdatePlanItemPriceRequestBody = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<UpdatePlanItemTierRequestBody> | undefined;
    tierBehavior?: UpdatePlanItemTierBehaviorRequestBody | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: UpdatePlanItemPriceIntervalRequestBody;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: UpdatePlanItemBillingMethodRequestBody;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const UpdatePlanItemOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type UpdatePlanItemOnIncrease = ClosedEnum<typeof UpdatePlanItemOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const UpdatePlanItemOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type UpdatePlanItemOnDecrease = ClosedEnum<typeof UpdatePlanItemOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type UpdatePlanItemProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: UpdatePlanItemOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: UpdatePlanItemOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const UpdatePlanItemExpiryDurationTypeRequestBody: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type UpdatePlanItemExpiryDurationTypeRequestBody = ClosedEnum<typeof UpdatePlanItemExpiryDurationTypeRequestBody>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type UpdatePlanItemRolloverRequestBody = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: UpdatePlanItemExpiryDurationTypeRequestBody;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type UpdatePlanItemPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: UpdatePlanItemResetRequestBody | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: UpdatePlanItemPriceRequestBody | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: UpdatePlanItemProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: UpdatePlanItemRolloverRequestBody | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const UpdatePlanDurationTypeRequest: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type UpdatePlanDurationTypeRequest = ClosedEnum<typeof UpdatePlanDurationTypeRequest>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const UpdatePlanOnEndRequest: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type UpdatePlanOnEndRequest = ClosedEnum<typeof UpdatePlanOnEndRequest>;
/**
 * Free trial configuration for a plan.
 */
type UpdatePlanFreeTrialParamsRequest = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: UpdatePlanDurationTypeRequest | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: UpdatePlanOnEndRequest | undefined;
};
/**
 * Miscellaneous plan-level configuration flags.
 */
type UpdatePlanConfigRequest = {
    /**
     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
     */
    ignorePastDue?: boolean | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const UpdatePlanPurchaseLimitIntervalRequestBody: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type UpdatePlanPurchaseLimitIntervalRequestBody = ClosedEnum<typeof UpdatePlanPurchaseLimitIntervalRequestBody>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type UpdatePlanPurchaseLimitRequest = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: UpdatePlanPurchaseLimitIntervalRequestBody;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type UpdatePlanAutoTopupRequest = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: UpdatePlanPurchaseLimitRequest | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const UpdatePlanLimitTypeRequestBody: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type UpdatePlanLimitTypeRequestBody = ClosedEnum<typeof UpdatePlanLimitTypeRequestBody>;
type UpdatePlanSpendLimitRequest = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: UpdatePlanLimitTypeRequestBody | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const UpdatePlanUsageLimitIntervalRequestBody: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type UpdatePlanUsageLimitIntervalRequestBody = ClosedEnum<typeof UpdatePlanUsageLimitIntervalRequestBody>;
type UpdatePlanProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type UpdatePlanFilterRequest = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type UpdatePlanUsageLimitRequest = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: UpdatePlanUsageLimitIntervalRequestBody;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: UpdatePlanFilterRequest | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const UpdatePlanThresholdTypeRequestBody: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type UpdatePlanThresholdTypeRequestBody = ClosedEnum<typeof UpdatePlanThresholdTypeRequestBody>;
type UpdatePlanUsageAlertRequestBody = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: UpdatePlanThresholdTypeRequestBody;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type UpdatePlanOverageAllowedRequest = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Plan-level billing controls used as customer defaults.
 */
type UpdatePlanBillingControlsRequest = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<UpdatePlanAutoTopupRequest> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<UpdatePlanSpendLimitRequest> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<UpdatePlanUsageLimitRequest> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<UpdatePlanUsageAlertRequestBody> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<UpdatePlanOverageAllowedRequest> | undefined;
};
type Migration = {
    draft?: boolean | undefined;
    includeCustom?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const PriceVariantInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type PriceVariantInterval = ClosedEnum<typeof PriceVariantInterval>;
/**
 * Base price configuration for a plan.
 */
type VariantBasePrice = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: PriceVariantInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const VariantResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type VariantResetInterval = ClosedEnum<typeof VariantResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type VariantReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: VariantResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type VariantTo = number | string;
type VariantTier = {
    to: number | string;
    amount?: number | undefined;
    flatAmount?: number | undefined;
};
declare const VariantTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type VariantTierBehavior = ClosedEnum<typeof VariantTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const VariantAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type VariantAddItemPriceInterval = ClosedEnum<typeof VariantAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const VariantAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type VariantAddItemBillingMethod = ClosedEnum<typeof VariantAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type VariantPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<VariantTier> | undefined;
    tierBehavior?: VariantTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: VariantAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits?: number | undefined;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: VariantAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const VariantOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type VariantOnIncrease = ClosedEnum<typeof VariantOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const VariantOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type VariantOnDecrease = ClosedEnum<typeof VariantOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type VariantProration = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: VariantOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: VariantOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const VariantExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type VariantExpiryDurationType = ClosedEnum<typeof VariantExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type VariantRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: VariantExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type VariantPlanItem = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: VariantReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: VariantPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: VariantProration | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: VariantRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const VariantRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type VariantRemoveItemBillingMethod = ClosedEnum<typeof VariantRemoveItemBillingMethod>;
declare const IntervalVariantRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type IntervalVariantRemoveItemEnum2 = ClosedEnum<typeof IntervalVariantRemoveItemEnum2>;
declare const IntervalVariantRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type IntervalVariantRemoveItemEnum1 = ClosedEnum<typeof IntervalVariantRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type VariantIntervalUnion = IntervalVariantRemoveItemEnum1 | IntervalVariantRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type VariantPlanItemFilter = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: VariantRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: IntervalVariantRemoveItemEnum1 | IntervalVariantRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const VariantDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type VariantDurationType = ClosedEnum<typeof VariantDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const VariantOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type VariantOnEnd = ClosedEnum<typeof VariantOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type VariantFreeTrialParams = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType?: VariantDurationType | undefined;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired?: boolean | undefined;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: VariantOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const VariantPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type VariantPurchaseLimitInterval = ClosedEnum<typeof VariantPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type VariantPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: VariantPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount?: number | undefined;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type VariantAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: VariantPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const VariantLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type VariantLimitType = ClosedEnum<typeof VariantLimitType>;
type VariantSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: VariantLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const VariantUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type VariantUsageLimitInterval = ClosedEnum<typeof VariantUsageLimitInterval>;
type VariantProperties = string | number | boolean;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type VariantFilter = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
type VariantUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: VariantUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: VariantFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const VariantThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type VariantThresholdType = ClosedEnum<typeof VariantThresholdType>;
type VariantUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled?: boolean | undefined;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: VariantThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type VariantOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled?: boolean | undefined;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type VariantBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<VariantAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<VariantSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<VariantUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<VariantUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<VariantOverageAllowed> | undefined;
};
/**
 * The exact customize patch to apply to this variant.
 */
type VariantCustomize = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: VariantBasePrice | null | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<VariantPlanItem> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<VariantPlanItemFilter> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: VariantFreeTrialParams | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: VariantBillingControls | undefined;
};
/**
 * Migration draft options for an in-place direct variant update.
 */
type VariantMigration = {
    draft?: boolean | undefined;
    includeCustom?: boolean | undefined;
};
type Variant = {
    /**
     * The variant plan ID to update or create.
     */
    variantPlanId: string;
    /**
     * Display name to use when creating the variant if it does not exist.
     */
    name?: string | undefined;
    /**
     * The exact customize patch to apply to this variant.
     */
    customize: VariantCustomize;
    /**
     * Edit this variant in place instead of versioning it for this update.
     */
    disableVersion?: boolean | undefined;
    /**
     * Force this variant update to create a new version.
     */
    forceVersion?: boolean | undefined;
    /**
     * Migration draft options for an in-place direct variant update.
     */
    migration?: VariantMigration | undefined;
};
type UpdatePlanParams = {
    /**
     * The ID of the plan to update.
     */
    planId: string;
    group?: string | undefined;
    /**
     * Display name of the plan.
     */
    name?: string | undefined;
    description?: string | undefined;
    /**
     * Whether the plan is an add-on.
     */
    addOn?: boolean | undefined;
    /**
     * Whether the plan is automatically enabled.
     */
    autoEnable?: boolean | undefined;
    /**
     * The price of the plan. Set to null to remove the base price.
     */
    price?: UpdatePlanBasePriceRequest | null | undefined;
    /**
     * Feature configurations for this plan. Each item defines included units, pricing, and reset behavior.
     */
    items?: Array<UpdatePlanItemPlanItem> | undefined;
    /**
     * The free trial of the plan. Set to null to remove the free trial.
     */
    freeTrial?: UpdatePlanFreeTrialParamsRequest | null | undefined;
    /**
     * Miscellaneous plan-level configuration flags.
     */
    config?: UpdatePlanConfigRequest | undefined;
    /**
     * Plan-level billing controls used as customer defaults.
     */
    billingControls?: UpdatePlanBillingControlsRequest | undefined;
    /**
     * Arbitrary key-value metadata defined by you for your own use (e.g. UI copy, feature highlights). Values can be any JSON-serializable value. Shared across all versions of the plan.
     */
    metadata?: {
        [k: string]: any;
    } | undefined;
    createInStripe?: boolean | undefined;
    version?: number | undefined;
    archived?: boolean | undefined;
    /**
     * The base plan this plan should be linked to as a variant. Set to null to detach it from its base plan.
     */
    basePlanId?: string | null | undefined;
    /**
     * The new ID to use for the plan. Can only be updated if the plan has not been used by any customers.
     */
    newPlanId?: string | undefined;
    disableVersion?: boolean | undefined;
    /**
     * Apply the update diff to all versions of this plan. Mutually exclusive with disable_version.
     */
    allVersions?: boolean | undefined;
    migration?: Migration | undefined;
    /**
     * Force versioning even when no customers exist. Mutually exclusive with disable_version.
     */
    forceVersion?: boolean | undefined;
    /**
     * Variant plan IDs to apply this update to. Empty or omitted means no propagation.
     */
    updateVariantIds?: Array<string> | undefined;
    /**
     * Additive variant updates for this base plan. Missing variants are created when name is provided.
     */
    variants?: Array<Variant> | undefined;
    /**
     * Whether this is the org's default plan. Cannot be true on a variant.
     */
    isDefault?: boolean | undefined;
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const UpdatePlanPriceIntervalResponse: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type UpdatePlanPriceIntervalResponse = OpenEnum<typeof UpdatePlanPriceIntervalResponse>;
/**
 * Display text for showing this price in pricing pages.
 */
type UpdatePlanPriceDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
type UpdatePlanPriceResponse = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: UpdatePlanPriceIntervalResponse;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Display text for showing this price in pricing pages.
     */
    display?: UpdatePlanPriceDisplay | undefined;
};
/**
 * The type of the feature
 */
declare const UpdatePlanType: {
    readonly Static: "static";
    readonly Boolean: "boolean";
    readonly SingleUse: "single_use";
    readonly ContinuousUse: "continuous_use";
    readonly CreditSystem: "credit_system";
    readonly AiCreditSystem: "ai_credit_system";
};
/**
 * The type of the feature
 */
type UpdatePlanType = OpenEnum<typeof UpdatePlanType>;
type UpdatePlanFeatureDisplay = {
    /**
     * The singular display name for the feature.
     */
    singular: string;
    /**
     * The plural display name for the feature.
     */
    plural: string;
};
type UpdatePlanCreditSchema = {
    /**
     * The ID of the metered feature (should be a single_use feature).
     */
    meteredFeatureId: string;
    /**
     * The credit cost of the metered feature.
     */
    creditCost: number;
};
/**
 * The full feature object if expanded.
 */
type UpdatePlanFeature = {
    /**
     * The ID of the feature, used to refer to it in other API calls like /track or /check.
     */
    id: string;
    /**
     * The name of the feature.
     */
    name?: string | null | undefined;
    /**
     * The type of the feature
     */
    type: UpdatePlanType;
    /**
     * Singular and plural display names for the feature.
     */
    display?: UpdatePlanFeatureDisplay | null | undefined;
    /**
     * Credit cost schema for credit system features.
     */
    creditSchema?: Array<UpdatePlanCreditSchema> | null | undefined;
    /**
     * Whether or not the feature is archived.
     */
    archived?: boolean | null | undefined;
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
declare const UpdatePlanResetItemIntervalResponse: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
 */
type UpdatePlanResetItemIntervalResponse = OpenEnum<typeof UpdatePlanResetItemIntervalResponse>;
type UpdatePlanItemResetResponse = {
    /**
     * The interval at which the feature balance resets (e.g. 'month', 'year'). For consumable features, usage resets to 0 and included units are restored.
     */
    interval: UpdatePlanResetItemIntervalResponse;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type UpdatePlanItemToResponse = number | string;
type UpdatePlanItemTierResponse = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const UpdatePlanItemTierBehaviorResponse: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type UpdatePlanItemTierBehaviorResponse = OpenEnum<typeof UpdatePlanItemTierBehaviorResponse>;
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
declare const UpdatePlanPriceItemIntervalResponse: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval for this price. For consumable features, should match reset.interval.
 */
type UpdatePlanPriceItemIntervalResponse = OpenEnum<typeof UpdatePlanPriceItemIntervalResponse>;
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
declare const UpdatePlanItemBillingMethodResponse: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
 */
type UpdatePlanItemBillingMethodResponse = OpenEnum<typeof UpdatePlanItemBillingMethodResponse>;
type UpdatePlanItemPriceResponse = {
    /**
     * Price per billing_units after included usage is consumed. Mutually exclusive with tiers.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing configuration. Each tier's 'to' INCLUDES the included amount. Either 'tiers' or 'amount' is required.
     */
    tiers?: Array<UpdatePlanItemTierResponse> | undefined;
    tierBehavior?: UpdatePlanItemTierBehaviorResponse | undefined;
    /**
     * Billing interval for this price. For consumable features, should match reset.interval.
     */
    interval: UpdatePlanPriceItemIntervalResponse;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
    /**
     * Number of units per price increment. Usage is rounded UP to the nearest billing_units when billed (e.g. billing_units=100 means 101 usage rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for features like seats where customers pay upfront, 'usage_based' for pay-as-you-go after included usage.
     */
    billingMethod: UpdatePlanItemBillingMethodResponse;
    /**
     * Maximum units a customer can purchase beyond included. E.g. if included=100 and max_purchase=300, customer can use up to 400 total before usage is capped. Null for no limit.
     */
    maxPurchase: number | null;
};
/**
 * Display text for showing this item in pricing pages.
 */
type UpdatePlanItemDisplay = {
    /**
     * Main display text (e.g. '$10' or '100 messages').
     */
    primaryText: string;
    /**
     * Secondary display text (e.g. 'per month' or 'then $0.5 per 100').
     */
    secondaryText?: string | undefined;
};
/**
 * When rolled over units expire.
 */
declare const UpdatePlanItemExpiryDurationTypeResponse: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type UpdatePlanItemExpiryDurationTypeResponse = OpenEnum<typeof UpdatePlanItemExpiryDurationTypeResponse>;
/**
 * Rollover configuration for unused units. If set, unused included units roll over to the next period.
 */
type UpdatePlanItemRolloverResponse = {
    /**
     * Maximum rollover units. Null for unlimited rollover.
     */
    max: number | null;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | null | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: UpdatePlanItemExpiryDurationTypeResponse;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
type UpdatePlanItem = {
    /**
     * The ID of the feature this item configures.
     */
    featureId: string;
    /**
     * The full feature object if expanded.
     */
    feature?: UpdatePlanFeature | undefined;
    /**
     * Number of free units included. For consumable features, balance resets to this number each interval.
     */
    included: number;
    /**
     * Whether the customer has unlimited access to this feature.
     */
    unlimited: boolean;
    /**
     * Reset configuration for consumable features. Null for non-consumable features like seats where usage persists across billing cycles.
     */
    reset: UpdatePlanItemResetResponse | null;
    /**
     * Pricing configuration for usage beyond included units. Null if feature is entirely free.
     */
    price: UpdatePlanItemPriceResponse | null;
    /**
     * Display text for showing this item in pricing pages.
     */
    display?: UpdatePlanItemDisplay | undefined;
    /**
     * Rollover configuration for unused units. If set, unused included units roll over to the next period.
     */
    rollover?: UpdatePlanItemRolloverResponse | undefined;
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
declare const UpdatePlanDurationTypeResponse: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial duration ('day', 'month', 'year').
 */
type UpdatePlanDurationTypeResponse = OpenEnum<typeof UpdatePlanDurationTypeResponse>;
declare const UpdatePlanOnEndResponse: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
type UpdatePlanOnEndResponse = OpenEnum<typeof UpdatePlanOnEndResponse>;
/**
 * Free trial configuration. If set, new customers can try this plan before being charged.
 */
type UpdatePlanFreeTrial = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial duration ('day', 'month', 'year').
     */
    durationType: UpdatePlanDurationTypeResponse;
    /**
     * Whether a payment method is required to start the trial. If true, customer will be charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: UpdatePlanOnEndResponse | null | undefined;
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
declare const UpdatePlanEnv: {
    readonly Sandbox: "sandbox";
    readonly Live: "live";
};
/**
 * Environment this plan belongs to ('sandbox' or 'live').
 */
type UpdatePlanEnv = OpenEnum<typeof UpdatePlanEnv>;
/**
 * Billing interval (e.g. 'month', 'year').
 */
declare const UpdatePlanPriceVariantDetailsInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval (e.g. 'month', 'year').
 */
type UpdatePlanPriceVariantDetailsInterval = OpenEnum<typeof UpdatePlanPriceVariantDetailsInterval>;
/**
 * Base price configuration for a plan.
 */
type UpdatePlanBasePriceResponse = {
    /**
     * Base price amount for the plan.
     */
    amount: number;
    /**
     * Billing interval (e.g. 'month', 'year').
     */
    interval: UpdatePlanPriceVariantDetailsInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
declare const UpdatePlanVariantDetailsResetInterval: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
 */
type UpdatePlanVariantDetailsResetInterval = OpenEnum<typeof UpdatePlanVariantDetailsResetInterval>;
/**
 * Reset configuration for consumable features. Omit for non-consumable features like seats.
 */
type UpdatePlanVariantDetailsReset = {
    /**
     * Interval at which balance resets (e.g. 'month', 'year'). For consumable features only.
     */
    interval: UpdatePlanVariantDetailsResetInterval;
    /**
     * Number of intervals between resets. Defaults to 1.
     */
    intervalCount?: number | undefined;
};
type UpdatePlanVariantDetailsTo = number | string;
type UpdatePlanVariantDetailsTier = {
    to: number | string;
    amount: number;
    flatAmount?: number | undefined;
};
declare const UpdatePlanVariantDetailsTierBehavior: {
    readonly Graduated: "graduated";
    readonly Volume: "volume";
};
type UpdatePlanVariantDetailsTierBehavior = OpenEnum<typeof UpdatePlanVariantDetailsTierBehavior>;
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
declare const UpdatePlanVariantDetailsAddItemPriceInterval: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
/**
 * Billing interval. For consumable features, should match reset.interval.
 */
type UpdatePlanVariantDetailsAddItemPriceInterval = OpenEnum<typeof UpdatePlanVariantDetailsAddItemPriceInterval>;
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
declare const UpdatePlanVariantDetailsAddItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
 */
type UpdatePlanVariantDetailsAddItemBillingMethod = OpenEnum<typeof UpdatePlanVariantDetailsAddItemBillingMethod>;
/**
 * Pricing for usage beyond included units. Omit for free features.
 */
type UpdatePlanVariantDetailsPrice = {
    /**
     * Price per billing_units after included usage. Either 'amount' or 'tiers' is required.
     */
    amount?: number | undefined;
    /**
     * Tiered pricing.  Either 'amount' or 'tiers' is required.
     */
    tiers?: Array<UpdatePlanVariantDetailsTier> | undefined;
    tierBehavior?: UpdatePlanVariantDetailsTierBehavior | undefined;
    /**
     * Billing interval. For consumable features, should match reset.interval.
     */
    interval: UpdatePlanVariantDetailsAddItemPriceInterval;
    /**
     * Number of intervals per billing cycle. Defaults to 1.
     */
    intervalCount: number;
    /**
     * Units per price increment. Usage is rounded UP when billed (e.g. billing_units=100 means 101 rounds to 200).
     */
    billingUnits: number;
    /**
     * 'prepaid' for upfront payment (seats), 'usage_based' for pay-as-you-go.
     */
    billingMethod: UpdatePlanVariantDetailsAddItemBillingMethod;
    /**
     * Max units purchasable beyond included. E.g. included=100, max_purchase=300 allows 400 total. Null for no limit.
     */
    maxPurchase?: number | null | undefined;
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
declare const UpdatePlanVariantDetailsOnIncrease: {
    readonly BillImmediately: "bill_immediately";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly BillNextCycle: "bill_next_cycle";
};
/**
 * Billing behavior when quantity increases mid-cycle.
 */
type UpdatePlanVariantDetailsOnIncrease = OpenEnum<typeof UpdatePlanVariantDetailsOnIncrease>;
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
declare const UpdatePlanVariantDetailsOnDecrease: {
    readonly Prorate: "prorate";
    readonly ProrateImmediately: "prorate_immediately";
    readonly ProrateNextCycle: "prorate_next_cycle";
    readonly None: "none";
    readonly NoProrations: "no_prorations";
};
/**
 * Credit behavior when quantity decreases mid-cycle.
 */
type UpdatePlanVariantDetailsOnDecrease = OpenEnum<typeof UpdatePlanVariantDetailsOnDecrease>;
/**
 * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
 */
type UpdatePlanProrationResponse = {
    /**
     * Billing behavior when quantity increases mid-cycle.
     */
    onIncrease: UpdatePlanVariantDetailsOnIncrease;
    /**
     * Credit behavior when quantity decreases mid-cycle.
     */
    onDecrease: UpdatePlanVariantDetailsOnDecrease;
};
/**
 * When rolled over units expire.
 */
declare const UpdatePlanVariantDetailsExpiryDurationType: {
    readonly Month: "month";
    readonly Forever: "forever";
};
/**
 * When rolled over units expire.
 */
type UpdatePlanVariantDetailsExpiryDurationType = OpenEnum<typeof UpdatePlanVariantDetailsExpiryDurationType>;
/**
 * Rollover config for unused units. If set, unused included units carry over.
 */
type UpdatePlanVariantDetailsRollover = {
    /**
     * Max rollover units. Omit for unlimited rollover.
     */
    max?: number | undefined;
    /**
     * Maximum rollover as a percentage (0-100) of included + prepaid grant. Mutually exclusive with max.
     */
    maxPercentage?: number | undefined;
    /**
     * When rolled over units expire.
     */
    expiryDurationType: UpdatePlanVariantDetailsExpiryDurationType;
    /**
     * Number of periods before expiry.
     */
    expiryDurationLength?: number | undefined;
};
/**
 * Configuration for a feature item in a plan, including usage limits, pricing, and rollover settings.
 */
type UpdatePlanPlanItemResponse = {
    /**
     * The ID of the feature to configure.
     */
    featureId: string;
    /**
     * Number of free units included. Balance resets to this each interval for consumable features.
     */
    included?: number | undefined;
    /**
     * If true, customer has unlimited access to this feature.
     */
    unlimited?: boolean | undefined;
    /**
     * Reset configuration for consumable features. Omit for non-consumable features like seats.
     */
    reset?: UpdatePlanVariantDetailsReset | undefined;
    /**
     * Pricing for usage beyond included units. Omit for free features.
     */
    price?: UpdatePlanVariantDetailsPrice | undefined;
    /**
     * Proration settings for prepaid features. Controls mid-cycle quantity change billing.
     */
    proration?: UpdatePlanProrationResponse | undefined;
    /**
     * Rollover config for unused units. If set, unused included units carry over.
     */
    rollover?: UpdatePlanVariantDetailsRollover | undefined;
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
declare const UpdatePlanVariantDetailsRemoveItemBillingMethod: {
    readonly Prepaid: "prepaid";
    readonly UsageBased: "usage_based";
};
/**
 * Match items with this billing method (prepaid or usage_based).
 */
type UpdatePlanVariantDetailsRemoveItemBillingMethod = OpenEnum<typeof UpdatePlanVariantDetailsRemoveItemBillingMethod>;
declare const UpdatePlanIntervalVariantDetailsRemoveItemEnum2: {
    readonly OneOff: "one_off";
    readonly Minute: "minute";
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type UpdatePlanIntervalVariantDetailsRemoveItemEnum2 = OpenEnum<typeof UpdatePlanIntervalVariantDetailsRemoveItemEnum2>;
declare const UpdatePlanIntervalVariantDetailsRemoveItemEnum1: {
    readonly OneOff: "one_off";
    readonly Week: "week";
    readonly Month: "month";
    readonly Quarter: "quarter";
    readonly SemiAnnual: "semi_annual";
    readonly Year: "year";
};
type UpdatePlanIntervalVariantDetailsRemoveItemEnum1 = OpenEnum<typeof UpdatePlanIntervalVariantDetailsRemoveItemEnum1>;
/**
 * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
 */
type UpdatePlanVariantDetailsIntervalUnion = UpdatePlanIntervalVariantDetailsRemoveItemEnum1 | UpdatePlanIntervalVariantDetailsRemoveItemEnum2;
/**
 * Filter for matching plan items. All provided fields must match (AND).
 */
type UpdatePlanPlanItemFilterResponse = {
    /**
     * Match items linked to this feature.
     */
    featureId?: string | undefined;
    /**
     * Match items with this billing method (prepaid or usage_based).
     */
    billingMethod?: UpdatePlanVariantDetailsRemoveItemBillingMethod | undefined;
    /**
     * Match items with this interval. Accepts either a BillingInterval (price-side) or a ResetInterval (reset-side, includes day/hour/minute) so price-less items keyed by reset.interval can be disambiguated.
     */
    interval?: UpdatePlanIntervalVariantDetailsRemoveItemEnum1 | UpdatePlanIntervalVariantDetailsRemoveItemEnum2 | undefined;
    /**
     * Match items with this interval_count. Disambiguates between items that share an interval but differ in count.
     */
    intervalCount?: number | undefined;
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
declare const UpdatePlanVariantDetailsDurationType: {
    readonly Day: "day";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Unit of time for the trial ('day', 'month', 'year').
 */
type UpdatePlanVariantDetailsDurationType = OpenEnum<typeof UpdatePlanVariantDetailsDurationType>;
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
declare const UpdatePlanVariantDetailsOnEnd: {
    readonly Bill: "bill";
    readonly Revert: "revert";
};
/**
 * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
 */
type UpdatePlanVariantDetailsOnEnd = OpenEnum<typeof UpdatePlanVariantDetailsOnEnd>;
/**
 * Free trial configuration for a plan.
 */
type UpdatePlanFreeTrialParamsResponse = {
    /**
     * Number of duration_type periods the trial lasts.
     */
    durationLength: number;
    /**
     * Unit of time for the trial ('day', 'month', 'year').
     */
    durationType: UpdatePlanVariantDetailsDurationType;
    /**
     * If true, payment method required to start trial. Customer is charged after trial ends.
     */
    cardRequired: boolean;
    /**
     * Behavior when the trial ends. 'bill' charges the customer (default). 'revert' expires the trial and restores the customer's previous plan.
     */
    onEnd?: UpdatePlanVariantDetailsOnEnd | undefined;
};
/**
 * The time interval for the purchase limit window.
 */
declare const UpdatePlanVariantDetailsPurchaseLimitInterval: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type UpdatePlanVariantDetailsPurchaseLimitInterval = OpenEnum<typeof UpdatePlanVariantDetailsPurchaseLimitInterval>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type UpdatePlanVariantDetailsPurchaseLimit = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: UpdatePlanVariantDetailsPurchaseLimitInterval;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type UpdatePlanVariantDetailsAutoTopup = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: UpdatePlanVariantDetailsPurchaseLimit | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const UpdatePlanVariantDetailsLimitType: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type UpdatePlanVariantDetailsLimitType = OpenEnum<typeof UpdatePlanVariantDetailsLimitType>;
type UpdatePlanVariantDetailsSpendLimit = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: UpdatePlanVariantDetailsLimitType | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const UpdatePlanVariantDetailsUsageLimitInterval: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type UpdatePlanVariantDetailsUsageLimitInterval = OpenEnum<typeof UpdatePlanVariantDetailsUsageLimitInterval>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type UpdatePlanVariantDetailsFilter = {
    properties: {
        [k: string]: any;
    };
};
type UpdatePlanVariantDetailsUsageLimit = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: UpdatePlanVariantDetailsUsageLimitInterval;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: UpdatePlanVariantDetailsFilter | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const UpdatePlanVariantDetailsThresholdType: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type UpdatePlanVariantDetailsThresholdType = OpenEnum<typeof UpdatePlanVariantDetailsThresholdType>;
type UpdatePlanVariantDetailsUsageAlert = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: UpdatePlanVariantDetailsThresholdType;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type UpdatePlanVariantDetailsOverageAllowed = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
 */
type UpdatePlanVariantDetailsBillingControls = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<UpdatePlanVariantDetailsAutoTopup> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<UpdatePlanVariantDetailsSpendLimit> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<UpdatePlanVariantDetailsUsageLimit> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<UpdatePlanVariantDetailsUsageAlert> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<UpdatePlanVariantDetailsOverageAllowed> | undefined;
};
/**
 * The customization that transforms the base plan into this variant.
 */
type UpdatePlanCustomizeResponse = {
    /**
     * Override the base price of the plan. Pass null to remove the base price.
     */
    price?: UpdatePlanBasePriceResponse | null | undefined;
    /**
     * Items to add to the plan.
     */
    addItems?: Array<UpdatePlanPlanItemResponse> | undefined;
    /**
     * Filters selecting items to remove from the plan.
     */
    removeItems?: Array<UpdatePlanPlanItemFilterResponse> | undefined;
    /**
     * Override the plan's default free trial. Pass an object to set a custom trial, or null to remove the trial entirely.
     */
    freeTrial?: UpdatePlanFreeTrialParamsResponse | null | undefined;
    /**
     * Override the plan's billing controls (auto top-ups, spend limits, usage limits, usage alerts, overage allowed) for this customer.
     */
    billingControls?: UpdatePlanVariantDetailsBillingControls | undefined;
};
/**
 * Details about how this variant relates to its latest base plan.
 */
type UpdatePlanVariantDetails = {
    /**
     * The ID of the base plan this variant was derived from.
     */
    basePlanId: string;
    /**
     * The customization that transforms the base plan into this variant.
     */
    customize?: UpdatePlanCustomizeResponse | undefined;
};
/**
 * Miscellaneous plan-level configuration flags.
 */
type UpdatePlanConfigResponse = {
    /**
     * If true, entitlements attached to this plan will still reset on schedule even when the customer's product is in a past_due state.
     */
    ignorePastDue: boolean;
};
/**
 * The time interval for the purchase limit window.
 */
declare const UpdatePlanPurchaseLimitIntervalResponse: {
    readonly Hour: "hour";
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
};
/**
 * The time interval for the purchase limit window.
 */
type UpdatePlanPurchaseLimitIntervalResponse = OpenEnum<typeof UpdatePlanPurchaseLimitIntervalResponse>;
/**
 * Optional rate limit to cap how often auto top-ups occur.
 */
type UpdatePlanPurchaseLimitResponse = {
    /**
     * The time interval for the purchase limit window.
     */
    interval: UpdatePlanPurchaseLimitIntervalResponse;
    /**
     * Number of intervals in the purchase limit window.
     */
    intervalCount: number;
    /**
     * Maximum number of auto top-ups allowed within the interval.
     */
    limit: number;
};
type UpdatePlanAutoTopupResponse = {
    /**
     * The ID of the feature (credit balance) to auto top-up.
     */
    featureId: string;
    /**
     * Whether auto top-up is enabled.
     */
    enabled: boolean;
    /**
     * When the balance drops below this threshold, an auto top-up will be purchased.
     */
    threshold: number;
    /**
     * Amount of credits to add per auto top-up.
     */
    quantity: number;
    /**
     * Optional rate limit to cap how often auto top-ups occur.
     */
    purchaseLimit?: UpdatePlanPurchaseLimitResponse | undefined;
    /**
     * When true, auto top-up creates a send_invoice invoice instead of auto-charging.
     */
    invoiceMode?: boolean | undefined;
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
declare const UpdatePlanLimitTypeResponse: {
    readonly Absolute: "absolute";
    readonly UsagePercentage: "usage_percentage";
};
/**
 * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
 */
type UpdatePlanLimitTypeResponse = OpenEnum<typeof UpdatePlanLimitTypeResponse>;
type UpdatePlanSpendLimitResponse = {
    /**
     * Optional feature ID this spend limit applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether the overage spend limit is enabled.
     */
    enabled: boolean;
    /**
     * How overage_limit is interpreted: an absolute overage cap (default) or a percentage of the main-plan allowance.
     */
    limitType?: UpdatePlanLimitTypeResponse | undefined;
    /**
     * Overage cap for the feature: absolute units, or a percent (e.g. 120) when limit_type is usage_percentage.
     */
    overageLimit?: number | undefined;
    /**
     * When true, overage for this feature is not posted to Stripe. Usage tracking and balance resets still behave normally.
     */
    skipOverageBilling?: boolean | undefined;
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
declare const UpdatePlanUsageLimitIntervalResponse: {
    readonly Day: "day";
    readonly Week: "week";
    readonly Month: "month";
    readonly Year: "year";
};
/**
 * Interval for the cap, aligned to the customer's billing cycle.
 */
type UpdatePlanUsageLimitIntervalResponse = OpenEnum<typeof UpdatePlanUsageLimitIntervalResponse>;
/**
 * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
 */
type UpdatePlanFilterResponse = {
    properties: {
        [k: string]: any;
    };
};
type UpdatePlanUsageLimitResponse = {
    /**
     * The feature this usage limit applies to.
     */
    featureId: string;
    /**
     * Whether this usage limit is enabled.
     */
    enabled: boolean;
    /**
     * Maximum units allowed per interval.
     */
    limit: number;
    /**
     * Interval for the cap, aligned to the customer's billing cycle.
     */
    interval: UpdatePlanUsageLimitIntervalResponse;
    /**
     * When set, only usage from events whose properties match counts toward this cap. Omit to count all usage of the feature.
     */
    filter?: UpdatePlanFilterResponse | undefined;
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
declare const UpdatePlanThresholdTypeResponse: {
    readonly Usage: "usage";
    readonly UsagePercentage: "usage_percentage";
    readonly Remaining: "remaining";
    readonly RemainingPercentage: "remaining_percentage";
};
/**
 * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
 */
type UpdatePlanThresholdTypeResponse = OpenEnum<typeof UpdatePlanThresholdTypeResponse>;
type UpdatePlanUsageAlertResponse = {
    /**
     * The feature ID this alert applies to.
     */
    featureId?: string | undefined;
    /**
     * Whether this usage alert is enabled.
     */
    enabled: boolean;
    /**
     * The threshold value that triggers the alert. For usage or remaining, this is an absolute count. For usage_percentage or remaining_percentage, this is a percentage (0-100).
     */
    threshold: number;
    /**
     * Whether the threshold is an absolute count or a percentage of the usage allowance or remaining balance.
     */
    thresholdType: UpdatePlanThresholdTypeResponse;
    /**
     * Optional user-defined label to distinguish multiple alerts on the same feature.
     */
    name?: string | undefined;
};
type UpdatePlanOverageAllowedResponse = {
    /**
     * The feature ID this overage allowed control applies to.
     */
    featureId: string;
    /**
     * Whether overage is allowed for this feature.
     */
    enabled: boolean;
};
/**
 * Plan-level billing controls used as customer defaults.
 */
type UpdatePlanBillingControlsResponse = {
    /**
     * List of auto top-up configurations per feature.
     */
    autoTopups?: Array<UpdatePlanAutoTopupResponse> | undefined;
    /**
     * List of overage spend limits per feature (caps overage spend).
     */
    spendLimits?: Array<UpdatePlanSpendLimitResponse> | undefined;
    /**
     * List of hard usage caps per feature (max units per interval).
     */
    usageLimits?: Array<UpdatePlanUsageLimitResponse> | undefined;
    /**
     * List of usage alert configurations per feature.
     */
    usageAlerts?: Array<UpdatePlanUsageAlertResponse> | undefined;
    /**
     * List of overage allowed controls per feature. When enabled, usage can exceed balance.
     */
    overageAllowed?: Array<UpdatePlanOverageAllowedResponse> | undefined;
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
declare const UpdatePlanStatus: {
    readonly Active: "active";
    readonly Scheduled: "scheduled";
};
/**
 * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
 */
type UpdatePlanStatus = OpenEnum<typeof UpdatePlanStatus>;
/**
 * The action that would occur if this plan were attached to the customer.
 */
declare const UpdatePlanAttachAction: {
    readonly Activate: "activate";
    readonly Upgrade: "upgrade";
    readonly Downgrade: "downgrade";
    readonly None: "none";
    readonly Purchase: "purchase";
};
/**
 * The action that would occur if this plan were attached to the customer.
 */
type UpdatePlanAttachAction = OpenEnum<typeof UpdatePlanAttachAction>;
type UpdatePlanCustomerEligibility = {
    /**
     * Whether the trial on this plan is available to this customer. For example, if the customer used the trial in the past, this will be false.
     */
    trialAvailable?: boolean | undefined;
    /**
     * The customer's current status with this plan. 'active' if attached, 'scheduled' if pending activation.
     */
    status?: UpdatePlanStatus | undefined;
    /**
     * Whether the customer's active instance of this plan is set to cancel.
     */
    canceling?: boolean | undefined;
    /**
     * Whether the customer is currently on a free trial of this plan.
     */
    trialing?: boolean | undefined;
    /**
     * The action that would occur if this plan were attached to the customer.
     */
    attachAction: UpdatePlanAttachAction;
};
/**
 * A plan defines a set of features, pricing, and entitlements that can be attached to customers.
 */
type UpdatePlanResponse = {
    /**
     * Unique identifier for the plan.
     */
    id: string;
    /**
     * Display name of the plan.
     */
    name: string;
    /**
     * Optional description of the plan.
     */
    description: string | null;
    /**
     * Group identifier for organizing related plans. Plans in the same group are mutually exclusive.
     */
    group: string | null;
    /**
     * Version number of the plan. Incremented when plan configuration changes.
     */
    version: number;
    /**
     * Whether this is an add-on plan that can be attached alongside a main plan.
     */
    addOn: boolean;
    /**
     * If true, this plan is automatically attached when a customer is created. Used for free plans.
     */
    autoEnable: boolean;
    /**
     * Base recurring price for the plan. Null for free plans or usage-only plans.
     */
    price: UpdatePlanPriceResponse | null;
    /**
     * Feature configurations included in this plan. Each item defines included units, pricing, and reset behavior for a feature.
     */
    items: Array<UpdatePlanItem>;
    /**
     * Free trial configuration. If set, new customers can try this plan before being charged.
     */
    freeTrial?: UpdatePlanFreeTrial | undefined;
    /**
     * Unix timestamp (ms) when the plan was created.
     */
    createdAt: number;
    /**
     * Environment this plan belongs to ('sandbox' or 'live').
     */
    env: UpdatePlanEnv;
    /**
     * Whether the plan is archived. Archived plans cannot be attached to new customers.
     */
    archived: boolean;
    /**
     * Deprecated. Use variant_details.base_plan_id instead. If this is a variant, the ID of the base plan it was created from.
     */
    baseVariantId: string | null;
    /**
     * Details about how this variant relates to its latest base plan.
     */
    variantDetails?: UpdatePlanVariantDetails | undefined;
    /**
     * Miscellaneous plan-level configuration flags.
     */
    config: UpdatePlanConfigResponse;
    /**
     * Plan-level billing controls used as customer defaults.
     */
    billingControls?: UpdatePlanBillingControlsResponse | undefined;
    /**
     * Arbitrary key-value metadata defined by you for your own use. Shared across all versions of the plan.
     */
    metadata: {
        [k: string]: any;
    };
    customerEligibility?: UpdatePlanCustomerEligibility | undefined;
};
/** @internal */
declare const UpdatePlanPriceIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanPriceIntervalRequestBody>;
/** @internal */
type UpdatePlanBasePriceRequest$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const UpdatePlanBasePriceRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanBasePriceRequest$Outbound, UpdatePlanBasePriceRequest>;
declare function updatePlanBasePriceRequestToJSON(updatePlanBasePriceRequest: UpdatePlanBasePriceRequest): string;
/** @internal */
declare const UpdatePlanItemResetIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanItemResetIntervalRequestBody>;
/** @internal */
type UpdatePlanItemResetRequestBody$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const UpdatePlanItemResetRequestBody$outboundSchema: z$1.ZodMiniType<UpdatePlanItemResetRequestBody$Outbound, UpdatePlanItemResetRequestBody>;
declare function updatePlanItemResetRequestBodyToJSON(updatePlanItemResetRequestBody: UpdatePlanItemResetRequestBody): string;
/** @internal */
type UpdatePlanItemToRequestBody$Outbound = number | string;
/** @internal */
declare const UpdatePlanItemToRequestBody$outboundSchema: z$1.ZodMiniType<UpdatePlanItemToRequestBody$Outbound, UpdatePlanItemToRequestBody>;
declare function updatePlanItemToRequestBodyToJSON(updatePlanItemToRequestBody: UpdatePlanItemToRequestBody): string;
/** @internal */
type UpdatePlanItemTierRequestBody$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const UpdatePlanItemTierRequestBody$outboundSchema: z$1.ZodMiniType<UpdatePlanItemTierRequestBody$Outbound, UpdatePlanItemTierRequestBody>;
declare function updatePlanItemTierRequestBodyToJSON(updatePlanItemTierRequestBody: UpdatePlanItemTierRequestBody): string;
/** @internal */
declare const UpdatePlanItemTierBehaviorRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanItemTierBehaviorRequestBody>;
/** @internal */
declare const UpdatePlanItemPriceIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanItemPriceIntervalRequestBody>;
/** @internal */
declare const UpdatePlanItemBillingMethodRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanItemBillingMethodRequestBody>;
/** @internal */
type UpdatePlanItemPriceRequestBody$Outbound = {
    amount?: number | undefined;
    tiers?: Array<UpdatePlanItemTierRequestBody$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const UpdatePlanItemPriceRequestBody$outboundSchema: z$1.ZodMiniType<UpdatePlanItemPriceRequestBody$Outbound, UpdatePlanItemPriceRequestBody>;
declare function updatePlanItemPriceRequestBodyToJSON(updatePlanItemPriceRequestBody: UpdatePlanItemPriceRequestBody): string;
/** @internal */
declare const UpdatePlanItemOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanItemOnIncrease>;
/** @internal */
declare const UpdatePlanItemOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanItemOnDecrease>;
/** @internal */
type UpdatePlanItemProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const UpdatePlanItemProration$outboundSchema: z$1.ZodMiniType<UpdatePlanItemProration$Outbound, UpdatePlanItemProration>;
declare function updatePlanItemProrationToJSON(updatePlanItemProration: UpdatePlanItemProration): string;
/** @internal */
declare const UpdatePlanItemExpiryDurationTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanItemExpiryDurationTypeRequestBody>;
/** @internal */
type UpdatePlanItemRolloverRequestBody$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const UpdatePlanItemRolloverRequestBody$outboundSchema: z$1.ZodMiniType<UpdatePlanItemRolloverRequestBody$Outbound, UpdatePlanItemRolloverRequestBody>;
declare function updatePlanItemRolloverRequestBodyToJSON(updatePlanItemRolloverRequestBody: UpdatePlanItemRolloverRequestBody): string;
/** @internal */
type UpdatePlanItemPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: UpdatePlanItemResetRequestBody$Outbound | undefined;
    price?: UpdatePlanItemPriceRequestBody$Outbound | undefined;
    proration?: UpdatePlanItemProration$Outbound | undefined;
    rollover?: UpdatePlanItemRolloverRequestBody$Outbound | undefined;
};
/** @internal */
declare const UpdatePlanItemPlanItem$outboundSchema: z$1.ZodMiniType<UpdatePlanItemPlanItem$Outbound, UpdatePlanItemPlanItem>;
declare function updatePlanItemPlanItemToJSON(updatePlanItemPlanItem: UpdatePlanItemPlanItem): string;
/** @internal */
declare const UpdatePlanDurationTypeRequest$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanDurationTypeRequest>;
/** @internal */
declare const UpdatePlanOnEndRequest$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanOnEndRequest>;
/** @internal */
type UpdatePlanFreeTrialParamsRequest$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const UpdatePlanFreeTrialParamsRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanFreeTrialParamsRequest$Outbound, UpdatePlanFreeTrialParamsRequest>;
declare function updatePlanFreeTrialParamsRequestToJSON(updatePlanFreeTrialParamsRequest: UpdatePlanFreeTrialParamsRequest): string;
/** @internal */
type UpdatePlanConfigRequest$Outbound = {
    ignore_past_due: boolean;
};
/** @internal */
declare const UpdatePlanConfigRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanConfigRequest$Outbound, UpdatePlanConfigRequest>;
declare function updatePlanConfigRequestToJSON(updatePlanConfigRequest: UpdatePlanConfigRequest): string;
/** @internal */
declare const UpdatePlanPurchaseLimitIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanPurchaseLimitIntervalRequestBody>;
/** @internal */
type UpdatePlanPurchaseLimitRequest$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const UpdatePlanPurchaseLimitRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanPurchaseLimitRequest$Outbound, UpdatePlanPurchaseLimitRequest>;
declare function updatePlanPurchaseLimitRequestToJSON(updatePlanPurchaseLimitRequest: UpdatePlanPurchaseLimitRequest): string;
/** @internal */
type UpdatePlanAutoTopupRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: UpdatePlanPurchaseLimitRequest$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const UpdatePlanAutoTopupRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanAutoTopupRequest$Outbound, UpdatePlanAutoTopupRequest>;
declare function updatePlanAutoTopupRequestToJSON(updatePlanAutoTopupRequest: UpdatePlanAutoTopupRequest): string;
/** @internal */
declare const UpdatePlanLimitTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanLimitTypeRequestBody>;
/** @internal */
type UpdatePlanSpendLimitRequest$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const UpdatePlanSpendLimitRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanSpendLimitRequest$Outbound, UpdatePlanSpendLimitRequest>;
declare function updatePlanSpendLimitRequestToJSON(updatePlanSpendLimitRequest: UpdatePlanSpendLimitRequest): string;
/** @internal */
declare const UpdatePlanUsageLimitIntervalRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanUsageLimitIntervalRequestBody>;
/** @internal */
type UpdatePlanProperties$Outbound = string | number | boolean;
/** @internal */
declare const UpdatePlanProperties$outboundSchema: z$1.ZodMiniType<UpdatePlanProperties$Outbound, UpdatePlanProperties>;
declare function updatePlanPropertiesToJSON(updatePlanProperties: UpdatePlanProperties): string;
/** @internal */
type UpdatePlanFilterRequest$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const UpdatePlanFilterRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanFilterRequest$Outbound, UpdatePlanFilterRequest>;
declare function updatePlanFilterRequestToJSON(updatePlanFilterRequest: UpdatePlanFilterRequest): string;
/** @internal */
type UpdatePlanUsageLimitRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: UpdatePlanFilterRequest$Outbound | undefined;
};
/** @internal */
declare const UpdatePlanUsageLimitRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanUsageLimitRequest$Outbound, UpdatePlanUsageLimitRequest>;
declare function updatePlanUsageLimitRequestToJSON(updatePlanUsageLimitRequest: UpdatePlanUsageLimitRequest): string;
/** @internal */
declare const UpdatePlanThresholdTypeRequestBody$outboundSchema: z$1.ZodMiniEnum<typeof UpdatePlanThresholdTypeRequestBody>;
/** @internal */
type UpdatePlanUsageAlertRequestBody$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const UpdatePlanUsageAlertRequestBody$outboundSchema: z$1.ZodMiniType<UpdatePlanUsageAlertRequestBody$Outbound, UpdatePlanUsageAlertRequestBody>;
declare function updatePlanUsageAlertRequestBodyToJSON(updatePlanUsageAlertRequestBody: UpdatePlanUsageAlertRequestBody): string;
/** @internal */
type UpdatePlanOverageAllowedRequest$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const UpdatePlanOverageAllowedRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanOverageAllowedRequest$Outbound, UpdatePlanOverageAllowedRequest>;
declare function updatePlanOverageAllowedRequestToJSON(updatePlanOverageAllowedRequest: UpdatePlanOverageAllowedRequest): string;
/** @internal */
type UpdatePlanBillingControlsRequest$Outbound = {
    auto_topups?: Array<UpdatePlanAutoTopupRequest$Outbound> | undefined;
    spend_limits?: Array<UpdatePlanSpendLimitRequest$Outbound> | undefined;
    usage_limits?: Array<UpdatePlanUsageLimitRequest$Outbound> | undefined;
    usage_alerts?: Array<UpdatePlanUsageAlertRequestBody$Outbound> | undefined;
    overage_allowed?: Array<UpdatePlanOverageAllowedRequest$Outbound> | undefined;
};
/** @internal */
declare const UpdatePlanBillingControlsRequest$outboundSchema: z$1.ZodMiniType<UpdatePlanBillingControlsRequest$Outbound, UpdatePlanBillingControlsRequest>;
declare function updatePlanBillingControlsRequestToJSON(updatePlanBillingControlsRequest: UpdatePlanBillingControlsRequest): string;
/** @internal */
type Migration$Outbound = {
    draft: boolean;
    include_custom?: boolean | undefined;
};
/** @internal */
declare const Migration$outboundSchema: z$1.ZodMiniType<Migration$Outbound, Migration>;
declare function migrationToJSON(migration: Migration): string;
/** @internal */
declare const PriceVariantInterval$outboundSchema: z$1.ZodMiniEnum<typeof PriceVariantInterval>;
/** @internal */
type VariantBasePrice$Outbound = {
    amount: number;
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const VariantBasePrice$outboundSchema: z$1.ZodMiniType<VariantBasePrice$Outbound, VariantBasePrice>;
declare function variantBasePriceToJSON(variantBasePrice: VariantBasePrice): string;
/** @internal */
declare const VariantResetInterval$outboundSchema: z$1.ZodMiniEnum<typeof VariantResetInterval>;
/** @internal */
type VariantReset$Outbound = {
    interval: string;
    interval_count?: number | undefined;
};
/** @internal */
declare const VariantReset$outboundSchema: z$1.ZodMiniType<VariantReset$Outbound, VariantReset>;
declare function variantResetToJSON(variantReset: VariantReset): string;
/** @internal */
type VariantTo$Outbound = number | string;
/** @internal */
declare const VariantTo$outboundSchema: z$1.ZodMiniType<VariantTo$Outbound, VariantTo>;
declare function variantToToJSON(variantTo: VariantTo): string;
/** @internal */
type VariantTier$Outbound = {
    to: number | string;
    amount?: number | undefined;
    flat_amount?: number | undefined;
};
/** @internal */
declare const VariantTier$outboundSchema: z$1.ZodMiniType<VariantTier$Outbound, VariantTier>;
declare function variantTierToJSON(variantTier: VariantTier): string;
/** @internal */
declare const VariantTierBehavior$outboundSchema: z$1.ZodMiniEnum<typeof VariantTierBehavior>;
/** @internal */
declare const VariantAddItemPriceInterval$outboundSchema: z$1.ZodMiniEnum<typeof VariantAddItemPriceInterval>;
/** @internal */
declare const VariantAddItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof VariantAddItemBillingMethod>;
/** @internal */
type VariantPrice$Outbound = {
    amount?: number | undefined;
    tiers?: Array<VariantTier$Outbound> | undefined;
    tier_behavior?: string | undefined;
    interval: string;
    interval_count: number;
    billing_units: number;
    billing_method: string;
    max_purchase?: number | null | undefined;
};
/** @internal */
declare const VariantPrice$outboundSchema: z$1.ZodMiniType<VariantPrice$Outbound, VariantPrice>;
declare function variantPriceToJSON(variantPrice: VariantPrice): string;
/** @internal */
declare const VariantOnIncrease$outboundSchema: z$1.ZodMiniEnum<typeof VariantOnIncrease>;
/** @internal */
declare const VariantOnDecrease$outboundSchema: z$1.ZodMiniEnum<typeof VariantOnDecrease>;
/** @internal */
type VariantProration$Outbound = {
    on_increase: string;
    on_decrease: string;
};
/** @internal */
declare const VariantProration$outboundSchema: z$1.ZodMiniType<VariantProration$Outbound, VariantProration>;
declare function variantProrationToJSON(variantProration: VariantProration): string;
/** @internal */
declare const VariantExpiryDurationType$outboundSchema: z$1.ZodMiniEnum<typeof VariantExpiryDurationType>;
/** @internal */
type VariantRollover$Outbound = {
    max?: number | undefined;
    max_percentage?: number | undefined;
    expiry_duration_type: string;
    expiry_duration_length?: number | undefined;
};
/** @internal */
declare const VariantRollover$outboundSchema: z$1.ZodMiniType<VariantRollover$Outbound, VariantRollover>;
declare function variantRolloverToJSON(variantRollover: VariantRollover): string;
/** @internal */
type VariantPlanItem$Outbound = {
    feature_id: string;
    included?: number | undefined;
    unlimited?: boolean | undefined;
    reset?: VariantReset$Outbound | undefined;
    price?: VariantPrice$Outbound | undefined;
    proration?: VariantProration$Outbound | undefined;
    rollover?: VariantRollover$Outbound | undefined;
};
/** @internal */
declare const VariantPlanItem$outboundSchema: z$1.ZodMiniType<VariantPlanItem$Outbound, VariantPlanItem>;
declare function variantPlanItemToJSON(variantPlanItem: VariantPlanItem): string;
/** @internal */
declare const VariantRemoveItemBillingMethod$outboundSchema: z$1.ZodMiniEnum<typeof VariantRemoveItemBillingMethod>;
/** @internal */
declare const IntervalVariantRemoveItemEnum2$outboundSchema: z$1.ZodMiniEnum<typeof IntervalVariantRemoveItemEnum2>;
/** @internal */
declare const IntervalVariantRemoveItemEnum1$outboundSchema: z$1.ZodMiniEnum<typeof IntervalVariantRemoveItemEnum1>;
/** @internal */
type VariantIntervalUnion$Outbound = string | string;
/** @internal */
declare const VariantIntervalUnion$outboundSchema: z$1.ZodMiniType<VariantIntervalUnion$Outbound, VariantIntervalUnion>;
declare function variantIntervalUnionToJSON(variantIntervalUnion: VariantIntervalUnion): string;
/** @internal */
type VariantPlanItemFilter$Outbound = {
    feature_id?: string | undefined;
    billing_method?: string | undefined;
    interval?: string | string | undefined;
    interval_count?: number | undefined;
};
/** @internal */
declare const VariantPlanItemFilter$outboundSchema: z$1.ZodMiniType<VariantPlanItemFilter$Outbound, VariantPlanItemFilter>;
declare function variantPlanItemFilterToJSON(variantPlanItemFilter: VariantPlanItemFilter): string;
/** @internal */
declare const VariantDurationType$outboundSchema: z$1.ZodMiniEnum<typeof VariantDurationType>;
/** @internal */
declare const VariantOnEnd$outboundSchema: z$1.ZodMiniEnum<typeof VariantOnEnd>;
/** @internal */
type VariantFreeTrialParams$Outbound = {
    duration_length: number;
    duration_type: string;
    card_required: boolean;
    on_end?: string | undefined;
};
/** @internal */
declare const VariantFreeTrialParams$outboundSchema: z$1.ZodMiniType<VariantFreeTrialParams$Outbound, VariantFreeTrialParams>;
declare function variantFreeTrialParamsToJSON(variantFreeTrialParams: VariantFreeTrialParams): string;
/** @internal */
declare const VariantPurchaseLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof VariantPurchaseLimitInterval>;
/** @internal */
type VariantPurchaseLimit$Outbound = {
    interval: string;
    interval_count: number;
    limit: number;
};
/** @internal */
declare const VariantPurchaseLimit$outboundSchema: z$1.ZodMiniType<VariantPurchaseLimit$Outbound, VariantPurchaseLimit>;
declare function variantPurchaseLimitToJSON(variantPurchaseLimit: VariantPurchaseLimit): string;
/** @internal */
type VariantAutoTopup$Outbound = {
    feature_id: string;
    enabled: boolean;
    threshold: number;
    quantity: number;
    purchase_limit?: VariantPurchaseLimit$Outbound | undefined;
    invoice_mode?: boolean | undefined;
};
/** @internal */
declare const VariantAutoTopup$outboundSchema: z$1.ZodMiniType<VariantAutoTopup$Outbound, VariantAutoTopup>;
declare function variantAutoTopupToJSON(variantAutoTopup: VariantAutoTopup): string;
/** @internal */
declare const VariantLimitType$outboundSchema: z$1.ZodMiniEnum<typeof VariantLimitType>;
/** @internal */
type VariantSpendLimit$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    limit_type?: string | undefined;
    overage_limit?: number | undefined;
    skip_overage_billing?: boolean | undefined;
};
/** @internal */
declare const VariantSpendLimit$outboundSchema: z$1.ZodMiniType<VariantSpendLimit$Outbound, VariantSpendLimit>;
declare function variantSpendLimitToJSON(variantSpendLimit: VariantSpendLimit): string;
/** @internal */
declare const VariantUsageLimitInterval$outboundSchema: z$1.ZodMiniEnum<typeof VariantUsageLimitInterval>;
/** @internal */
type VariantProperties$Outbound = string | number | boolean;
/** @internal */
declare const VariantProperties$outboundSchema: z$1.ZodMiniType<VariantProperties$Outbound, VariantProperties>;
declare function variantPropertiesToJSON(variantProperties: VariantProperties): string;
/** @internal */
type VariantFilter$Outbound = {
    properties: {
        [k: string]: string | number | boolean;
    };
};
/** @internal */
declare const VariantFilter$outboundSchema: z$1.ZodMiniType<VariantFilter$Outbound, VariantFilter>;
declare function variantFilterToJSON(variantFilter: VariantFilter): string;
/** @internal */
type VariantUsageLimit$Outbound = {
    feature_id: string;
    enabled: boolean;
    limit: number;
    interval: string;
    filter?: VariantFilter$Outbound | undefined;
};
/** @internal */
declare const VariantUsageLimit$outboundSchema: z$1.ZodMiniType<VariantUsageLimit$Outbound, VariantUsageLimit>;
declare function variantUsageLimitToJSON(variantUsageLimit: VariantUsageLimit): string;
/** @internal */
declare const VariantThresholdType$outboundSchema: z$1.ZodMiniEnum<typeof VariantThresholdType>;
/** @internal */
type VariantUsageAlert$Outbound = {
    feature_id?: string | undefined;
    enabled: boolean;
    threshold: number;
    threshold_type: string;
    name?: string | undefined;
};
/** @internal */
declare const VariantUsageAlert$outboundSchema: z$1.ZodMiniType<VariantUsageAlert$Outbound, VariantUsageAlert>;
declare function variantUsageAlertToJSON(variantUsageAlert: VariantUsageAlert): string;
/** @internal */
type VariantOverageAllowed$Outbound = {
    feature_id: string;
    enabled: boolean;
};
/** @internal */
declare const VariantOverageAllowed$outboundSchema: z$1.ZodMiniType<VariantOverageAllowed$Outbound, VariantOverageAllowed>;
declare function variantOverageAllowedToJSON(variantOverageAllowed: VariantOverageAllowed): string;
/** @internal */
type VariantBillingControls$Outbound = {
    auto_topups?: Array<VariantAutoTopup$Outbound> | undefined;
    spend_limits?: Array<VariantSpendLimit$Outbound> | undefined;
    usage_limits?: Array<VariantUsageLimit$Outbound> | undefined;
    usage_alerts?: Array<VariantUsageAlert$Outbound> | undefined;
    overage_allowed?: Array<VariantOverageAllowed$Outbound> | undefined;
};
/** @internal */
declare const VariantBillingControls$outboundSchema: z$1.ZodMiniType<VariantBillingControls$Outbound, VariantBillingControls>;
declare function variantBillingControlsToJSON(variantBillingControls: VariantBillingControls): string;
/** @internal */
type VariantCustomize$Outbound = {
    price?: VariantBasePrice$Outbound | null | undefined;
    add_items?: Array<VariantPlanItem$Outbound> | undefined;
    remove_items?: Array<VariantPlanItemFilter$Outbound> | undefined;
    free_trial?: VariantFreeTrialParams$Outbound | null | undefined;
    billing_controls?: VariantBillingControls$Outbound | undefined;
};
/** @internal */
declare const VariantCustomize$outboundSchema: z$1.ZodMiniType<VariantCustomize$Outbound, VariantCustomize>;
declare function variantCustomizeToJSON(variantCustomize: VariantCustomize): string;
/** @internal */
type VariantMigration$Outbound = {
    draft: boolean;
    include_custom?: boolean | undefined;
};
/** @internal */
declare const VariantMigration$outboundSchema: z$1.ZodMiniType<VariantMigration$Outbound, VariantMigration>;
declare function variantMigrationToJSON(variantMigration: VariantMigration): string;
/** @internal */
type Variant$Outbound = {
    variant_plan_id: string;
    name?: string | undefined;
    customize: VariantCustomize$Outbound;
    disable_version?: boolean | undefined;
    force_version?: boolean | undefined;
    migration?: VariantMigration$Outbound | undefined;
};
/** @internal */
declare const Variant$outboundSchema: z$1.ZodMiniType<Variant$Outbound, Variant>;
declare function variantToJSON(variant: Variant): string;
/** @internal */
type UpdatePlanParams$Outbound = {
    plan_id: string;
    group?: string | undefined;
    name?: string | undefined;
    description?: string | undefined;
    add_on?: boolean | undefined;
    auto_enable?: boolean | undefined;
    price?: UpdatePlanBasePriceRequest$Outbound | null | undefined;
    items?: Array<UpdatePlanItemPlanItem$Outbound> | undefined;
    free_trial?: UpdatePlanFreeTrialParamsRequest$Outbound | null | undefined;
    config?: UpdatePlanConfigRequest$Outbound | undefined;
    billing_controls?: UpdatePlanBillingControlsRequest$Outbound | undefined;
    metadata?: {
        [k: string]: any;
    } | undefined;
    create_in_stripe: boolean;
    version?: number | undefined;
    archived: boolean;
    base_plan_id?: string | null | undefined;
    new_plan_id?: string | undefined;
    disable_version?: boolean | undefined;
    all_versions?: boolean | undefined;
    migration?: Migration$Outbound | undefined;
    force_version?: boolean | undefined;
    update_variant_ids?: Array<string> | undefined;
    variants?: Array<Variant$Outbound> | undefined;
    is_default?: boolean | undefined;
};
/** @internal */
declare const UpdatePlanParams$outboundSchema: z$1.ZodMiniType<UpdatePlanParams$Outbound, UpdatePlanParams>;
declare function updatePlanParamsToJSON(updatePlanParams: UpdatePlanParams): string;
/** @internal */
declare const UpdatePlanPriceIntervalResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanPriceIntervalResponse, unknown>;
/** @internal */
declare const UpdatePlanPriceDisplay$inboundSchema: z$1.ZodMiniType<UpdatePlanPriceDisplay, unknown>;
declare function updatePlanPriceDisplayFromJSON(jsonString: string): Result$1<UpdatePlanPriceDisplay, SDKValidationError>;
/** @internal */
declare const UpdatePlanPriceResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanPriceResponse, unknown>;
declare function updatePlanPriceResponseFromJSON(jsonString: string): Result$1<UpdatePlanPriceResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanType$inboundSchema: z$1.ZodMiniType<UpdatePlanType, unknown>;
/** @internal */
declare const UpdatePlanFeatureDisplay$inboundSchema: z$1.ZodMiniType<UpdatePlanFeatureDisplay, unknown>;
declare function updatePlanFeatureDisplayFromJSON(jsonString: string): Result$1<UpdatePlanFeatureDisplay, SDKValidationError>;
/** @internal */
declare const UpdatePlanCreditSchema$inboundSchema: z$1.ZodMiniType<UpdatePlanCreditSchema, unknown>;
declare function updatePlanCreditSchemaFromJSON(jsonString: string): Result$1<UpdatePlanCreditSchema, SDKValidationError>;
/** @internal */
declare const UpdatePlanFeature$inboundSchema: z$1.ZodMiniType<UpdatePlanFeature, unknown>;
declare function updatePlanFeatureFromJSON(jsonString: string): Result$1<UpdatePlanFeature, SDKValidationError>;
/** @internal */
declare const UpdatePlanResetItemIntervalResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanResetItemIntervalResponse, unknown>;
/** @internal */
declare const UpdatePlanItemResetResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemResetResponse, unknown>;
declare function updatePlanItemResetResponseFromJSON(jsonString: string): Result$1<UpdatePlanItemResetResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanItemToResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemToResponse, unknown>;
declare function updatePlanItemToResponseFromJSON(jsonString: string): Result$1<UpdatePlanItemToResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanItemTierResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemTierResponse, unknown>;
declare function updatePlanItemTierResponseFromJSON(jsonString: string): Result$1<UpdatePlanItemTierResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanItemTierBehaviorResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemTierBehaviorResponse, unknown>;
/** @internal */
declare const UpdatePlanPriceItemIntervalResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanPriceItemIntervalResponse, unknown>;
/** @internal */
declare const UpdatePlanItemBillingMethodResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemBillingMethodResponse, unknown>;
/** @internal */
declare const UpdatePlanItemPriceResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemPriceResponse, unknown>;
declare function updatePlanItemPriceResponseFromJSON(jsonString: string): Result$1<UpdatePlanItemPriceResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanItemDisplay$inboundSchema: z$1.ZodMiniType<UpdatePlanItemDisplay, unknown>;
declare function updatePlanItemDisplayFromJSON(jsonString: string): Result$1<UpdatePlanItemDisplay, SDKValidationError>;
/** @internal */
declare const UpdatePlanItemExpiryDurationTypeResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemExpiryDurationTypeResponse, unknown>;
/** @internal */
declare const UpdatePlanItemRolloverResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanItemRolloverResponse, unknown>;
declare function updatePlanItemRolloverResponseFromJSON(jsonString: string): Result$1<UpdatePlanItemRolloverResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanItem$inboundSchema: z$1.ZodMiniType<UpdatePlanItem, unknown>;
declare function updatePlanItemFromJSON(jsonString: string): Result$1<UpdatePlanItem, SDKValidationError>;
/** @internal */
declare const UpdatePlanDurationTypeResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanDurationTypeResponse, unknown>;
/** @internal */
declare const UpdatePlanOnEndResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanOnEndResponse, unknown>;
/** @internal */
declare const UpdatePlanFreeTrial$inboundSchema: z$1.ZodMiniType<UpdatePlanFreeTrial, unknown>;
declare function updatePlanFreeTrialFromJSON(jsonString: string): Result$1<UpdatePlanFreeTrial, SDKValidationError>;
/** @internal */
declare const UpdatePlanEnv$inboundSchema: z$1.ZodMiniType<UpdatePlanEnv, unknown>;
/** @internal */
declare const UpdatePlanPriceVariantDetailsInterval$inboundSchema: z$1.ZodMiniType<UpdatePlanPriceVariantDetailsInterval, unknown>;
/** @internal */
declare const UpdatePlanBasePriceResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanBasePriceResponse, unknown>;
declare function updatePlanBasePriceResponseFromJSON(jsonString: string): Result$1<UpdatePlanBasePriceResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsResetInterval$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsResetInterval, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsReset$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsReset, unknown>;
declare function updatePlanVariantDetailsResetFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsReset, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsTo$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsTo, unknown>;
declare function updatePlanVariantDetailsToFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsTo, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsTier$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsTier, unknown>;
declare function updatePlanVariantDetailsTierFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsTier, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsTierBehavior$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsTierBehavior, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsAddItemPriceInterval$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsAddItemPriceInterval, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsAddItemBillingMethod$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsAddItemBillingMethod, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsPrice$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsPrice, unknown>;
declare function updatePlanVariantDetailsPriceFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsPrice, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsOnIncrease$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsOnIncrease, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsOnDecrease$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsOnDecrease, unknown>;
/** @internal */
declare const UpdatePlanProrationResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanProrationResponse, unknown>;
declare function updatePlanProrationResponseFromJSON(jsonString: string): Result$1<UpdatePlanProrationResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsExpiryDurationType$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsExpiryDurationType, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsRollover$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsRollover, unknown>;
declare function updatePlanVariantDetailsRolloverFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsRollover, SDKValidationError>;
/** @internal */
declare const UpdatePlanPlanItemResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanPlanItemResponse, unknown>;
declare function updatePlanPlanItemResponseFromJSON(jsonString: string): Result$1<UpdatePlanPlanItemResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsRemoveItemBillingMethod$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsRemoveItemBillingMethod, unknown>;
/** @internal */
declare const UpdatePlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema: z$1.ZodMiniType<UpdatePlanIntervalVariantDetailsRemoveItemEnum2, unknown>;
/** @internal */
declare const UpdatePlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema: z$1.ZodMiniType<UpdatePlanIntervalVariantDetailsRemoveItemEnum1, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsIntervalUnion$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsIntervalUnion, unknown>;
declare function updatePlanVariantDetailsIntervalUnionFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsIntervalUnion, SDKValidationError>;
/** @internal */
declare const UpdatePlanPlanItemFilterResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanPlanItemFilterResponse, unknown>;
declare function updatePlanPlanItemFilterResponseFromJSON(jsonString: string): Result$1<UpdatePlanPlanItemFilterResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsDurationType$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsDurationType, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsOnEnd$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsOnEnd, unknown>;
/** @internal */
declare const UpdatePlanFreeTrialParamsResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanFreeTrialParamsResponse, unknown>;
declare function updatePlanFreeTrialParamsResponseFromJSON(jsonString: string): Result$1<UpdatePlanFreeTrialParamsResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsPurchaseLimitInterval$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsPurchaseLimitInterval, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsPurchaseLimit$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsPurchaseLimit, unknown>;
declare function updatePlanVariantDetailsPurchaseLimitFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsPurchaseLimit, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsAutoTopup$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsAutoTopup, unknown>;
declare function updatePlanVariantDetailsAutoTopupFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsAutoTopup, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsLimitType$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsLimitType, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsSpendLimit$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsSpendLimit, unknown>;
declare function updatePlanVariantDetailsSpendLimitFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsSpendLimit, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsUsageLimitInterval$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsUsageLimitInterval, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsFilter$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsFilter, unknown>;
declare function updatePlanVariantDetailsFilterFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsFilter, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsUsageLimit$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsUsageLimit, unknown>;
declare function updatePlanVariantDetailsUsageLimitFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsUsageLimit, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsThresholdType$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsThresholdType, unknown>;
/** @internal */
declare const UpdatePlanVariantDetailsUsageAlert$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsUsageAlert, unknown>;
declare function updatePlanVariantDetailsUsageAlertFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsUsageAlert, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsOverageAllowed$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsOverageAllowed, unknown>;
declare function updatePlanVariantDetailsOverageAllowedFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsOverageAllowed, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetailsBillingControls$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetailsBillingControls, unknown>;
declare function updatePlanVariantDetailsBillingControlsFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetailsBillingControls, SDKValidationError>;
/** @internal */
declare const UpdatePlanCustomizeResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanCustomizeResponse, unknown>;
declare function updatePlanCustomizeResponseFromJSON(jsonString: string): Result$1<UpdatePlanCustomizeResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanVariantDetails$inboundSchema: z$1.ZodMiniType<UpdatePlanVariantDetails, unknown>;
declare function updatePlanVariantDetailsFromJSON(jsonString: string): Result$1<UpdatePlanVariantDetails, SDKValidationError>;
/** @internal */
declare const UpdatePlanConfigResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanConfigResponse, unknown>;
declare function updatePlanConfigResponseFromJSON(jsonString: string): Result$1<UpdatePlanConfigResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanPurchaseLimitIntervalResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanPurchaseLimitIntervalResponse, unknown>;
/** @internal */
declare const UpdatePlanPurchaseLimitResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanPurchaseLimitResponse, unknown>;
declare function updatePlanPurchaseLimitResponseFromJSON(jsonString: string): Result$1<UpdatePlanPurchaseLimitResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanAutoTopupResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanAutoTopupResponse, unknown>;
declare function updatePlanAutoTopupResponseFromJSON(jsonString: string): Result$1<UpdatePlanAutoTopupResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanLimitTypeResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanLimitTypeResponse, unknown>;
/** @internal */
declare const UpdatePlanSpendLimitResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanSpendLimitResponse, unknown>;
declare function updatePlanSpendLimitResponseFromJSON(jsonString: string): Result$1<UpdatePlanSpendLimitResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanUsageLimitIntervalResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanUsageLimitIntervalResponse, unknown>;
/** @internal */
declare const UpdatePlanFilterResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanFilterResponse, unknown>;
declare function updatePlanFilterResponseFromJSON(jsonString: string): Result$1<UpdatePlanFilterResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanUsageLimitResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanUsageLimitResponse, unknown>;
declare function updatePlanUsageLimitResponseFromJSON(jsonString: string): Result$1<UpdatePlanUsageLimitResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanThresholdTypeResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanThresholdTypeResponse, unknown>;
/** @internal */
declare const UpdatePlanUsageAlertResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanUsageAlertResponse, unknown>;
declare function updatePlanUsageAlertResponseFromJSON(jsonString: string): Result$1<UpdatePlanUsageAlertResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanOverageAllowedResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanOverageAllowedResponse, unknown>;
declare function updatePlanOverageAllowedResponseFromJSON(jsonString: string): Result$1<UpdatePlanOverageAllowedResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanBillingControlsResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanBillingControlsResponse, unknown>;
declare function updatePlanBillingControlsResponseFromJSON(jsonString: string): Result$1<UpdatePlanBillingControlsResponse, SDKValidationError>;
/** @internal */
declare const UpdatePlanStatus$inboundSchema: z$1.ZodMiniType<UpdatePlanStatus, unknown>;
/** @internal */
declare const UpdatePlanAttachAction$inboundSchema: z$1.ZodMiniType<UpdatePlanAttachAction, unknown>;
/** @internal */
declare const UpdatePlanCustomerEligibility$inboundSchema: z$1.ZodMiniType<UpdatePlanCustomerEligibility, unknown>;
declare function updatePlanCustomerEligibilityFromJSON(jsonString: string): Result$1<UpdatePlanCustomerEligibility, SDKValidationError>;
/** @internal */
declare const UpdatePlanResponse$inboundSchema: z$1.ZodMiniType<UpdatePlanResponse, unknown>;
declare function updatePlanResponseFromJSON(jsonString: string): Result$1<UpdatePlanResponse, SDKValidationError>;

type OAuth2PasswordFlow = {
    username: string;
    password: string;
    clientID?: string | undefined;
    clientSecret?: string | undefined;
    tokenURL: string;
};
type SecurityState = {
    basic: {
        username?: string | undefined;
        password?: string | undefined;
    };
    headers: Record<string, string>;
    queryParams: Record<string, string>;
    cookies: Record<string, string>;
    oauth2: ({
        type: "password";
    } & OAuth2PasswordFlow) | {
        type: "none";
    };
};

type HookContext = {
    baseURL: string | URL;
    operationID: string;
    oAuth2Scopes: string[] | null;
    securitySource?: any | (() => Promise<any>);
    retryConfig: RetryConfig;
    resolvedSecurity: SecurityState | null;
    options: SDKOptions;
};
type Awaitable<T> = T | Promise<T>;
type BeforeCreateRequestContext = HookContext & {};
type BeforeRequestContext = HookContext & {};
type AfterSuccessContext = HookContext & {};
type AfterErrorContext = HookContext & {};
/**
 * SDKInitHook is called when the SDK is initializing. The
 * hook can return a new baseURL and HTTP client to be used by the SDK.
 */
interface SDKInitHook {
    sdkInit: (opts: SDKOptions) => SDKOptions;
}
interface BeforeCreateRequestHook {
    /**
     * A hook that is called before the SDK creates a `Request` object. The hook
     * can modify how a request is constructed since certain modifications, like
     * changing the request URL, cannot be done on a request object directly.
     */
    beforeCreateRequest: (hookCtx: BeforeCreateRequestContext, input: RequestInput) => RequestInput;
}
interface BeforeRequestHook {
    /**
     * A hook that is called before the SDK sends a request. The hook can
     * introduce instrumentation code such as logging, tracing and metrics or
     * replace the request before it is sent or throw an error to stop the
     * request from being sent.
     */
    beforeRequest: (hookCtx: BeforeRequestContext, request: Request) => Awaitable<Request>;
}
interface AfterSuccessHook {
    /**
     * A hook that is called after the SDK receives a response. The hook can
     * introduce instrumentation code such as logging, tracing and metrics or
     * modify the response before it is handled or throw an error to stop the
     * response from being handled.
     */
    afterSuccess: (hookCtx: AfterSuccessContext, response: Response) => Awaitable<Response>;
}
interface AfterErrorHook {
    /**
     * A hook that is called after the SDK encounters an error, or a
     * non-successful response. The hook can introduce instrumentation code such
     * as logging, tracing and metrics or modify the response or error values.
     */
    afterError: (hookCtx: AfterErrorContext, response: Response | null, error: unknown) => Awaitable<{
        response: Response | null;
        error: unknown;
    }>;
}
interface Hooks {
    /** Registers a hook to be used by the SDK for initialization event. */
    registerSDKInitHook(hook: SDKInitHook): void;
    /** Registers a hook to be used by the SDK for to modify `Request` construction. */
    registerBeforeCreateRequestHook(hook: BeforeCreateRequestHook): void;
    /** Registers a hook to be used by the SDK for the before request event. */
    registerBeforeRequestHook(hook: BeforeRequestHook): void;
    /** Registers a hook to be used by the SDK for the after success event. */
    registerAfterSuccessHook(hook: AfterSuccessHook): void;
    /** Registers a hook to be used by the SDK for the after error event. */
    registerAfterErrorHook(hook: AfterErrorHook): void;
}

declare class SDKHooks implements Hooks {
    sdkInitHooks: SDKInitHook[];
    beforeCreateRequestHooks: BeforeCreateRequestHook[];
    beforeRequestHooks: BeforeRequestHook[];
    afterSuccessHooks: AfterSuccessHook[];
    afterErrorHooks: AfterErrorHook[];
    constructor();
    registerSDKInitHook(hook: SDKInitHook): void;
    registerBeforeCreateRequestHook(hook: BeforeCreateRequestHook): void;
    registerBeforeRequestHook(hook: BeforeRequestHook): void;
    registerAfterSuccessHook(hook: AfterSuccessHook): void;
    registerAfterErrorHook(hook: AfterErrorHook): void;
    sdkInit(opts: SDKOptions): SDKOptions;
    beforeCreateRequest(hookCtx: BeforeCreateRequestContext, input: RequestInput): RequestInput;
    beforeRequest(hookCtx: BeforeRequestContext, request: Request): Promise<Request>;
    afterSuccess(hookCtx: AfterSuccessContext, response: Response): Promise<Response>;
    afterError(hookCtx: AfterErrorContext, response: Response | null, error: unknown): Promise<{
        response: Response | null;
        error: unknown;
    }>;
}

type RequestOptions = {
    /**
     * Sets a timeout, in milliseconds, on HTTP requests made by an SDK method. If
     * `fetchOptions.signal` is set then it will take precedence over this option.
     */
    timeoutMs?: number;
    /**
     * Set or override a retry policy on HTTP calls.
     */
    retries?: RetryConfig;
    /**
     * Specifies the status codes which should be retried using the given retry policy.
     */
    retryCodes?: string[];
    /**
     * Overrides the base server URL that will be used by an operation.
     */
    serverURL?: string | URL;
    /**
     * @deprecated `fetchOptions` has been flattened into `RequestOptions`.
     *
     * Sets various request options on the `fetch` call made by an SDK method.
     *
     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}
     */
    fetchOptions?: Omit<RequestInit, "method" | "body">;
} & Omit<RequestInit, "method" | "body">;
type RequestConfig = {
    method: string;
    path: string;
    baseURL?: string | URL | undefined;
    query?: string;
    body?: RequestInit["body"];
    headers?: HeadersInit;
    security?: SecurityState | null;
    uaHeader?: string;
    userAgent?: string | undefined;
    timeoutMs?: number;
};
declare class ClientSDK {
    #private;
    readonly _baseURL: URL | null;
    readonly _options: SDKOptions & {
        hooks?: SDKHooks;
    };
    constructor(options?: SDKOptions);
    _createRequest(context: HookContext, conf: RequestConfig, options?: RequestOptions): Result$1<Request, InvalidRequestError | UnexpectedClientError>;
    _do(request: Request, options: {
        context: HookContext;
        isErrorStatusCode: (statusCode: number) => boolean;
        retryConfig: RetryConfig;
        retryCodes: string[];
    }): Promise<Result$1<Response, RequestAbortedError | RequestTimeoutError | ConnectionError | UnexpectedClientError>>;
}

declare class Balances extends ClientSDK {
    /**
     * Create a balance for a customer feature.
     */
    create(request: CreateBalanceParams, options?: RequestOptions): Promise<CreateBalanceResponse>;
    /**
     * Update a customer balance.
     */
    update(request: UpdateBalanceParams, options?: RequestOptions): Promise<UpdateBalanceResponse>;
    /**
     * Delete a balance for a customer feature. Can only delete a balance that is not attached to a price (eg. you cannot delete messages that have an overage price).
     */
    delete(request: DeleteBalanceParams, options?: RequestOptions): Promise<DeleteBalanceResponse>;
    /**
     * Finalize a previously locked balance. Use 'confirm' to commit the deduction, or 'release' to return the held balance.
     */
    finalize(request: FinalizeBalanceParams, options?: RequestOptions): Promise<FinalizeLockResponse>;
}

declare class Billing extends ClientSDK {
    /**
     * Attaches a plan to a customer. Handles new subscriptions, upgrades and downgrades.
     *
     * Use this endpoint to subscribe a customer to a plan, upgrade/downgrade between plans, or add an add-on product.
     *
     * @example
     * ```typescript
     * // Attach a plan to a customer
     * const response = await client.billing.attach({ customerId: "cus_123", planId: "pro_plan" });
     * ```
     *
     * @example
     * ```typescript
     * // Attach with a free trial
     * const response = await client.billing.attach({ customerId: "cus_123", planId: "pro_plan", freeTrial: {"durationLength":14,"durationType":"day"} });
     * ```
     *
     * @example
     * ```typescript
     * // Attach with custom pricing
     * const response = await client.billing.attach({ customerId: "cus_123", planId: "pro_plan", customize: {"price":{"amount":4900,"interval":"month"}} });
     * ```
     *
     * @param customerId - The ID of the customer to attach the plan to.
     * @param entityId - The ID of the entity to attach the plan to. (optional)
     * @param planId - The ID of the plan.
     * @param featureQuantities - If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan. (optional)
     * @param version - The version of the plan to attach. (optional)
     * @param customize - Customize the plan to attach. Can override the price, items, free trial, or a combination. (optional)
     * @param invoiceMode - Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method. (optional)
     * @param prorationBehavior - How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges. (optional)
     * @param redirectMode - Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects. (optional)
     * @param subscriptionId - A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan. (optional)
     * @param discounts - List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code. (optional)
     * @param successUrl - URL to redirect to after successful checkout. (optional)
     * @param newBillingSubscription - Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one. (optional)
     * @param billingCycleAnchor - Reset the billing cycle anchor immediately with 'now'. (optional)
     * @param planSchedule - When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled. (optional)
     * @param startsAt - Unix timestamp in milliseconds for when the attached plan should start. Future dates create a scheduled subscription. (optional)
     * @param endsAt - Unix timestamp in milliseconds for when the attached plan should end. (optional)
     * @param checkoutSessionParams - Additional parameters to pass into the creation of the Stripe checkout session. (optional)
     * @param longLivedCheckout - If true, returns an Autumn-hosted checkout link that can create a fresh Stripe checkout session when opened. (optional)
     * @param customLineItems - Custom line items that override the auto-generated proration invoice. Only valid for immediate plan changes (eg. upgrades or one off plans). (optional)
     * @param processorSubscriptionId - The processor subscription ID to link. Use this to attach an existing Stripe subscription instead of creating a new one. (optional)
     * @param carryOverBalances - Whether to carry over balances from the previous plan. (optional)
     * @param carryOverUsages - Whether to carry over usages from the previous plan. (optional)
     * @param metadata - Key-value metadata to attach to the Stripe subscription, invoice, and checkout session created during this attach flow. Keys prefixed with 'autumn_' are reserved and will be stripped. (optional)
     * @param noBillingChanges - If true, skips any billing changes for the attach operation. (optional)
     * @param enablePlanImmediately - If true, the customer's plan is activated immediately even when payment is deferred (invoice mode) or pending (Stripe checkout). For Stripe checkout, the customer_product is inserted before the customer completes the hosted form. (optional)
     * @param taxRateId - Stripe tax rate ID (txr_...) to apply as the default tax rate on the created subscription, invoice, or checkout session line items. (optional)
     *
     * @returns A billing response with customer ID, invoice details, and payment URL (if checkout required).
     */
    attach(request: AttachParams, options?: RequestOptions): Promise<AttachResponse>;
    /**
     * Creates a multi-phase subscription schedule for a customer. The first phase starts immediately and subsequent phases automatically transition at their scheduled start times.
     *
     * Use this endpoint to schedule future plan changes (e.g. switch from a trial plan to a paid plan on a specific date) or to define a sequence of plans that should activate over time.
     *
     * @example
     * ```typescript
     * // Schedule a transition from a trial plan to a paid plan
     * const response = await client.billing.createSchedule({ customerId: "cus_123", phases: [{"startsAt":1783704557304,"plans":[{"planId":"trial_plan"}]},{"startsAt":1784914157304,"plans":[{"planId":"pro_plan"}]}] });
     * ```
     *
     * @param customerId - The ID of the customer to create the schedule for.
     * @param entityId - Optional entity ID for an entity-scoped schedule. (optional)
     * @param invoiceMode - Invoice mode creates and sends an invoice instead of charging the customer's payment method immediately for the first phase. (optional)
     * @param discounts - List of discounts to apply to the immediate phase. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code. (optional)
     * @param successUrl - URL to redirect to after successful checkout. (optional)
     * @param checkoutSessionParams - Additional parameters to pass into the creation of the Stripe checkout session. (optional)
     * @param redirectMode - Controls when to return a checkout URL for the immediate phase. 'always' forces a confirmation or checkout flow, 'if_required' only redirects when needed, and 'never' disables redirects. (optional)
     * @param billingBehavior - Whether to prorate the immediate phase. 'none' skips proration charges and credits. (optional)
     * @param billingCycleAnchor - Pass 'now' to reset the billing cycle anchor of the immediate phase to the current time. (optional)
     * @param enablePlanImmediately - If true, the immediate-phase cusProducts are activated immediately (and scheduled-phase cusProducts pre-inserted) even when payment is pending via Stripe checkout. The Autumn schedule rows are persisted on checkout.session.completed. (optional)
     * @param phases - Ordered phase definitions for the schedule.
     *
     * @returns A create-schedule response with the schedule ID, persisted phases, and any required payment or checkout URL.
     */
    createSchedule(request: CreateScheduleParams, options?: RequestOptions): Promise<CreateScheduleResponse>;
    /**
     * Attaches multiple plans to a customer in a single request. Creates a single Stripe subscription with all plans consolidated.
     *
     * Use this endpoint when you need to subscribe a customer to multiple plans at once, such as a base plan plus add-ons, or to create a bundle of products.
     *
     * @example
     * ```typescript
     * // Attach multiple plans to a customer
     * const response = await client.billing.multiAttach({ customerId: "cus_123", plans: [{"planId":"pro_plan"},{"planId":"addon_seats","featureQuantities":[{"featureId":"seats","quantity":5}]}] });
     * ```
     *
     * @example
     * ```typescript
     * // Attach with free trial applied to all plans
     * const response = await client.billing.multiAttach({ customerId: "cus_123", plans: [{"planId":"pro_plan"},{"planId":"addon_storage"}], freeTrial: {"durationLength":14,"durationType":"day"} });
     * ```
     *
     * @example
     * ```typescript
     * // Attach with custom pricing on one plan
     * const response = await client.billing.multiAttach({ customerId: "cus_123", plans: [{"planId":"pro_plan","customize":{"price":{"amount":4900,"interval":"month"}}},{"planId":"addon_support"}] });
     * ```
     *
     * @param customerId - The ID of the customer to attach the plans to.
     * @param entityId - The ID of the entity to attach the plans to. (optional)
     * @param plans - The list of plans to attach to the customer.
     * @param freeTrial - Free trial configuration applied to all plans. Pass an object to set a custom trial, or null to remove any trial. (optional)
     * @param invoiceMode - Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. (optional)
     * @param discounts - List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code. (optional)
     * @param successUrl - URL to redirect to after successful checkout. (optional)
     * @param checkoutSessionParams - Additional parameters to pass into the creation of the Stripe checkout session. (optional)
     * @param redirectMode - Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects. (optional)
     * @param newBillingSubscription - Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one. (optional)
     * @param enablePlanImmediately - If true, the cusProducts are activated immediately even when payment is pending via Stripe checkout. (optional)
     *
     * @returns A billing response with customer ID, invoice details, and payment URL (if checkout required).
     */
    multiAttach(request: MultiAttachParams, options?: RequestOptions): Promise<MultiAttachResponse>;
    /**
     * Previews the billing changes that would occur when attaching a plan, without actually making any changes.
     *
     * Use this endpoint to show customers what they will be charged before confirming a subscription change.
     *
     * @example
     * ```typescript
     * // Preview attaching a plan
     * const response = await client.billing.previewAttach({ customerId: "cus_123", planId: "pro_plan" });
     * ```
     *
     * @param customerId - The ID of the customer to attach the plan to.
     * @param entityId - The ID of the entity to attach the plan to. (optional)
     * @param planId - The ID of the plan.
     * @param featureQuantities - If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan. (optional)
     * @param version - The version of the plan to attach. (optional)
     * @param customize - Customize the plan to attach. Can override the price, items, free trial, or a combination. (optional)
     * @param invoiceMode - Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method. (optional)
     * @param prorationBehavior - How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges. (optional)
     * @param redirectMode - Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects. (optional)
     * @param subscriptionId - A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan. (optional)
     * @param discounts - List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code. (optional)
     * @param successUrl - URL to redirect to after successful checkout. (optional)
     * @param newBillingSubscription - Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one. (optional)
     * @param billingCycleAnchor - Reset the billing cycle anchor immediately with 'now'. (optional)
     * @param planSchedule - When the plan change should take effect. 'immediate' applies now, 'end_of_cycle' schedules for the end of the current billing cycle. By default, upgrades are immediate and downgrades are scheduled. (optional)
     * @param startsAt - Unix timestamp in milliseconds for when the attached plan should start. Future dates create a scheduled subscription. (optional)
     * @param endsAt - Unix timestamp in milliseconds for when the attached plan should end. (optional)
     * @param checkoutSessionParams - Additional parameters to pass into the creation of the Stripe checkout session. (optional)
     * @param longLivedCheckout - If true, returns an Autumn-hosted checkout link that can create a fresh Stripe checkout session when opened. (optional)
     * @param customLineItems - Custom line items that override the auto-generated proration invoice. Only valid for immediate plan changes (eg. upgrades or one off plans). (optional)
     * @param processorSubscriptionId - The processor subscription ID to link. Use this to attach an existing Stripe subscription instead of creating a new one. (optional)
     * @param carryOverBalances - Whether to carry over balances from the previous plan. (optional)
     * @param carryOverUsages - Whether to carry over usages from the previous plan. (optional)
     * @param metadata - Key-value metadata to attach to the Stripe subscription, invoice, and checkout session created during this attach flow. Keys prefixed with 'autumn_' are reserved and will be stripped. (optional)
     * @param noBillingChanges - If true, skips any billing changes for the attach operation. (optional)
     * @param enablePlanImmediately - If true, the customer's plan is activated immediately even when payment is deferred (invoice mode) or pending (Stripe checkout). For Stripe checkout, the customer_product is inserted before the customer completes the hosted form. (optional)
     * @param taxRateId - Stripe tax rate ID (txr_...) to apply as the default tax rate on the created subscription, invoice, or checkout session line items. (optional)
     *
     * @returns A preview response with line items, totals, and effective dates for the proposed changes.
     */
    previewAttach(request: PreviewAttachParams, options?: RequestOptions): Promise<PreviewAttachResponse>;
    /**
     * Previews the billing changes that would occur when attaching multiple plans, without actually making any changes.
     *
     * Use this endpoint to show customers what they will be charged before confirming a multi-plan subscription.
     *
     * @example
     * ```typescript
     * // Preview attaching multiple plans
     * const response = await client.billing.previewMultiAttach({ customerId: "cus_123", plans: [{"planId":"pro_plan"},{"planId":"addon_seats","featureQuantities":[{"featureId":"seats","quantity":5}]}] });
     * ```
     *
     * @param customerId - The ID of the customer to attach the plans to.
     * @param entityId - The ID of the entity to attach the plans to. (optional)
     * @param plans - The list of plans to attach to the customer.
     * @param freeTrial - Free trial configuration applied to all plans. Pass an object to set a custom trial, or null to remove any trial. (optional)
     * @param invoiceMode - Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. (optional)
     * @param discounts - List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code. (optional)
     * @param successUrl - URL to redirect to after successful checkout. (optional)
     * @param checkoutSessionParams - Additional parameters to pass into the creation of the Stripe checkout session. (optional)
     * @param redirectMode - Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects. (optional)
     * @param newBillingSubscription - Only applicable when the customer has an existing Stripe subscription. If true, creates a new separate subscription instead of merging into the existing one. (optional)
     * @param enablePlanImmediately - If true, the cusProducts are activated immediately even when payment is pending via Stripe checkout. (optional)
     *
     * @returns A preview response with line items, totals, and effective dates for the proposed multi-plan attachment.
     */
    previewMultiAttach(request: PreviewMultiAttachParams, options?: RequestOptions): Promise<PreviewMultiAttachResponse>;
    /**
     * Updates an existing subscription. Use to modify feature quantities, cancel, or change plan configuration.
     *
     * Use this endpoint to update prepaid quantities, cancel a subscription (immediately or at end of cycle), or modify subscription settings.
     *
     * @example
     * ```typescript
     * // Update prepaid feature quantity
     * const response = await client.billing.update({ customerId: "cus_123", planId: "pro_plan", featureQuantities: [{"featureId":"seats","quantity":10}] });
     * ```
     *
     * @example
     * ```typescript
     * // Cancel a subscription at end of billing cycle
     * const response = await client.billing.update({ customerId: "cus_123", planId: "pro_plan", cancelAction: "cancel_end_of_cycle" });
     * ```
     *
     * @example
     * ```typescript
     * // Uncancel a subscription at the end of the billing cycle
     * const response = await client.billing.update({ customerId: "cus_123", planId: "pro_plan", cancelAction: "uncancel" });
     * ```
     *
     * @param customerId - The ID of the customer to attach the plan to.
     * @param entityId - The ID of the entity to attach the plan to. (optional)
     * @param planId - The ID of the plan to update. Optional if subscription_id is provided, or if the customer has only one product. (optional)
     * @param featureQuantities - If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan. (optional)
     * @param version - The version of the plan to attach. (optional)
     * @param customize - Customize the plan to attach. Can override the price, items, free trial, or a combination. (optional)
     * @param invoiceMode - Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method. (optional)
     * @param prorationBehavior - How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges. (optional)
     * @param redirectMode - Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects. (optional)
     * @param subscriptionId - A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan. (optional)
     * @param discounts - List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code. (optional)
     * @param cancelAction - Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation. (optional)
     * @param billingCycleAnchor - Reset the billing cycle anchor immediately with 'now' (optional)
     * @param noBillingChanges - If true, the subscription is updated internally without applying billing changes in Stripe. (optional)
     * @param refundLastPayment - Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment. (optional)
     * @param recalculateBalances - Controls whether balances should be recalculated during the subscription update. (optional)
     * @param carryOverUsages - Whether to carry over usages from the previous plan. (optional)
     *
     * @returns A billing response with customer ID, invoice details, and payment URL (if next action is required).
     */
    update(request: UpdateSubscriptionParams, options?: RequestOptions): Promise<BillingUpdateResponse>;
    /**
     * Previews the billing changes that would occur when updating a subscription, without actually making any changes.
     *
     * Use this endpoint to show customers prorated charges or refunds before confirming subscription modifications.
     *
     * @example
     * ```typescript
     * // Preview updating seat quantity
     * const response = await client.billing.previewUpdate({ customerId: "cus_123", planId: "pro_plan", featureQuantities: [{"featureId":"seats","quantity":15}] });
     * ```
     *
     * @param customerId - The ID of the customer to attach the plan to.
     * @param entityId - The ID of the entity to attach the plan to. (optional)
     * @param planId - The ID of the plan to update. Optional if subscription_id is provided, or if the customer has only one product. (optional)
     * @param featureQuantities - If this plan contains prepaid features, use this field to specify the quantity of each prepaid feature. This quantity includes the included amount and billing units defined when setting up the plan. (optional)
     * @param version - The version of the plan to attach. (optional)
     * @param customize - Customize the plan to attach. Can override the price, items, free trial, or a combination. (optional)
     * @param invoiceMode - Invoice mode creates a draft or open invoice and sends it to the customer, instead of charging their card immediately. This uses Stripe's send_invoice collection method. (optional)
     * @param prorationBehavior - How to handle proration when updating an existing subscription. 'prorate_immediately' charges/credits prorated amounts now, 'none' skips creating any charges. (optional)
     * @param redirectMode - Controls when to return a checkout URL. 'always' returns a URL even if payment succeeds, 'if_required' only when payment action is needed, 'never' disables redirects. (optional)
     * @param subscriptionId - A unique ID to identify this subscription. Can be used to target specific subscriptions in update operations when a customer has multiple products with the same plan. (optional)
     * @param discounts - List of discounts to apply. Each discount can be an Autumn reward ID, Stripe coupon ID, or Stripe promotion code. (optional)
     * @param cancelAction - Action to perform for cancellation. 'cancel_immediately' cancels now with prorated refund, 'cancel_end_of_cycle' cancels at period end, 'uncancel' reverses a pending cancellation. (optional)
     * @param billingCycleAnchor - Reset the billing cycle anchor immediately with 'now' (optional)
     * @param noBillingChanges - If true, the subscription is updated internally without applying billing changes in Stripe. (optional)
     * @param refundLastPayment - Controls how the last payment is refunded on immediate cancellation. 'prorated' refunds the unused portion, 'full' refunds the entire last payment. (optional)
     * @param recalculateBalances - Controls whether balances should be recalculated during the subscription update. (optional)
     * @param carryOverUsages - Whether to carry over usages from the previous plan. (optional)
     *
     * @returns A preview response with line items showing prorated charges or credits for the proposed changes.
     */
    previewUpdate(request: PreviewUpdateParams, options?: RequestOptions): Promise<PreviewUpdateResponse>;
    /**
     * Updates multiple plans on a customer in a single request. Currently supports cancel actions (immediately, end of cycle, or uncancel) across one or more subscriptions.
     *
     * Use this endpoint to cancel or uncancel several plans atomically in one call — for example canceling a main plan together with its add-ons, or plans across multiple entities.
     *
     * @example
     * ```typescript
     * // Cancel a plan and an add-on at end of cycle
     * const response = await client.billing.multiUpdate({ customerId: "cus_123", updates: [{"planId":"pro_plan","cancelAction":"cancel_end_of_cycle"},{"planId":"addon_seats","cancelAction":"cancel_end_of_cycle"}] });
     * ```
     *
     * @example
     * ```typescript
     * // Uncancel one plan and cancel another immediately
     * const response = await client.billing.multiUpdate({ customerId: "cus_123", updates: [{"planId":"pro_plan","cancelAction":"uncancel"},{"planId":"addon_seats","cancelAction":"cancel_immediately"}] });
     * ```
     *
     * @param customerId - The ID of the customer to update plans for.
     * @param entityId - The ID of the entity to update plans for. Individual updates can override this with their own entity_id. (optional)
     * @param updates - The list of plan updates to apply to the customer.
     *
     * @returns A billing response with the resulting invoice summary (one credit invoice per affected subscription for immediate cancels).
     */
    multiUpdate(request: MultiUpdateParams, options?: RequestOptions): Promise<MultiUpdateResponse>;
    /**
     * Previews the billing changes of a multi-plan update without making any changes. Returns one core preview per affected subscription.
     *
     * Use this endpoint to show customers the credits and next-cycle changes of canceling multiple plans before confirming.
     *
     * @example
     * ```typescript
     * // Preview canceling two plans immediately
     * const response = await client.billing.previewMultiUpdate({ customerId: "cus_123", updates: [{"planId":"pro_plan","cancelAction":"cancel_immediately"},{"planId":"addon_seats","cancelAction":"cancel_immediately"}] });
     * ```
     *
     * @param customerId - The ID of the customer to update plans for.
     * @param entityId - The ID of the entity to update plans for. Individual updates can override this with their own entity_id. (optional)
     * @param updates - The list of plan updates to apply to the customer.
     *
     * @returns A preview with the combined total plus one entry per subscription, each with its own line items, totals, and next-cycle preview.
     */
    previewMultiUpdate(request: PreviewMultiUpdateParams, options?: RequestOptions): Promise<MultiUpdatePreviewResponse>;
    /**
     * Create a billing portal session for a customer to manage their subscription.
     */
    openCustomerPortal(request: OpenCustomerPortalParams, options?: RequestOptions): Promise<OpenCustomerPortalResponse>;
    /**
     * Create a payment setup session for a customer to add or update their payment method.
     */
    setupPayment(request: SetupPaymentParams, options?: RequestOptions): Promise<SetupPaymentResponse>;
    /**
     * Import
     *
     * @remarks
     * Image a customer into Autumn for live migration. Read-only against processors.
     */
    import(request: DfuFlashParams, options?: RequestOptions): Promise<DfuFlashResult>;
}

declare class Customers extends ClientSDK {
    /**
     * Creates a customer if they do not exist, or returns the existing customer by your external customer ID.
     *
     * Use this as the primary entrypoint before billing operations so the customer record is always present and up to date.
     *
     * @example
     * ```typescript
     * // Create or fetch a customer by external ID
     * const response = await client.getOrCreate({ customerId: "cus_123", name: "John Doe", email: "john@example.com" });
     * ```
     *
     * @param id - Your unique identifier for the customer (optional)
     * @param name - Customer's name (optional)
     * @param email - Customer's email address (optional)
     * @param fingerprint - Unique identifier (eg, serial number) to detect duplicate customers and prevent free trial abuse (optional)
     * @param metadata - Additional metadata for the customer (optional)
     * @param stripeId - Stripe customer ID if you already have one (optional)
     * @param createInStripe - Whether to create the customer in Stripe (optional)
     * @param autoEnablePlanId - The ID of the free plan to auto-enable for the customer (optional)
     * @param sendEmailReceipts - Whether to send email receipts to this customer (optional)
     * @param billingControls - Billing controls for the customer (auto top-ups, etc.) (optional)
     * @param config - Miscellaneous configurations for the customer. (optional)
     * @param expand - Fields to expand in the returned customer response, such as subscriptions.plan, purchases.plan, balances.feature, or flags.feature. (optional)
     */
    getOrCreate(request: GetOrCreateCustomerParams, options?: RequestOptions): Promise<Customer>;
    /**
     * Fetches a customer by ID, optionally expanding related data such as invoices or entities.
     *
     * Use this when you know the customer exists or assert they exist without creating them.
     *
     * @example
     * ```typescript
     * // Fetch a customer by external ID
     * const response = await client.get({ customerId: "cus_123" });
     * ```
     *
     * @example
     * ```typescript
     * // Fetch a customer with expanded invoices and entities
     * const response = await client.get({ customerId: "cus_123", expand: ["invoices","entities"] });
     * ```
     *
     * @param customerId - ID of the customer to fetch
     * @param expand - Expand related customer data like invoices or entities, or expand nested objects like balances.feature, flags.feature, subscriptions.plan, and purchases.plan. (optional)
     */
    get(request: GetCustomerParams, options?: RequestOptions): Promise<GetCustomerResponse>;
    /**
     * Lists customers with cursor pagination and optional filters. Pass `start_cursor: ""` (or omit) for the first page; use `next_cursor` from a prior response for subsequent pages.
     */
    list(request: ListCustomersParams, options?: RequestOptions): Promise<ListCustomersResponse>;
    /**
     * Updates an existing customer by ID.
     */
    update(request: UpdateCustomerParams, options?: RequestOptions): Promise<UpdateCustomerResponse>;
    /**
     * Deletes a customer by ID.
     */
    delete(request: DeleteCustomerParams, options?: RequestOptions): Promise<DeleteCustomerResponse>;
}

declare class Entities extends ClientSDK {
    /**
     * Creates an entity for a customer and feature, then returns the entity with balances and subscriptions.
     *
     * Use entities when usage and access must be scoped to sub-resources (for example seats, projects, or workspaces) instead of only the customer.
     *
     * @example
     * ```typescript
     * // Create a seat entity
     * const response = await client.entities.create({
     *
     *   customerId: "cus_123",
     *   entityId: "seat_42",
     *   featureId: "seats",
     *   name: "Seat 42",
     * });
     * ```
     *
     * @param name - The name of the entity (optional)
     * @param featureId - The ID of the feature this entity is associated with
     * @param billingControls - Billing controls for the entity. (optional)
     * @param customerData - Customer attributes used to resolve the customer when customer_id is not provided. (optional)
     * @param customerId - The ID of the customer to create the entity for.
     * @param entityId - The ID of the entity.
     *
     * @returns The created entity object including its current subscriptions, purchases, and balances.
     */
    create(request: CreateEntityParams, options?: RequestOptions): Promise<CreateEntityResponse>;
    /**
     * Fetches an entity by its ID.
     *
     * Use this to read one entity's current state. Pass customerId when you want to scope the lookup to a specific customer.
     *
     * @example
     * ```typescript
     * // Fetch a seat entity
     * const response = await client.entities.get({ entityId: "seat_42" });
     * ```
     *
     * @example
     * ```typescript
     * // Fetch a seat entity for a specific customer
     * const response = await client.entities.get({ customerId: "cus_123", entityId: "seat_42" });
     * ```
     *
     * @param customerId - The ID of the customer to create the entity for. (optional)
     * @param entityId - The ID of the entity.
     *
     * @returns The entity object including its current subscriptions, purchases, and balances.
     */
    get(request: GetEntityParams, options?: RequestOptions): Promise<GetEntityResponse>;
    /**
     * Lists entities across the organization with pagination and optional filters.
     *
     * Use this to page through entities globally, including filtering by plans inherited from parent customers or attached directly to entities.
     *
     * @example
     * ```typescript
     * // List entities on a plan
     * const response = await client.entities.list({ plans: [{"id":"pro_plan"}], limit: 10, offset: 0 });
     * ```
     *
     * @example
     * ```typescript
     * // Search entities by ID or name
     * const response = await client.entities.list({ search: "workspace" });
     * ```
     *
     * @param offset - Number of items to skip (optional)
     * @param limit - Number of items to return. Default 10, max 1000. (optional)
     * @param plans - Filter by plan ID and version. Returns entities with active subscriptions to this plan, including plans inherited from the parent customer. (optional)
     * @param subscriptionStatus - Filter customer products used for entity hydration and plan matching. Defaults to active and scheduled. (optional)
     * @param search - Search entities by id or name. (optional)
     * @param processors - Filter by parent customer processor type (stripe, revenuecat, vercel). (optional)
     * @param customerId - Restrict the response to entities owned by this customer id. Use to bulk-fetch all entities for one customer in a single paginated call instead of iterating entities.get. (optional)
     *
     * @returns A paginated list of entity objects including their current subscriptions, purchases, balances, and flags.
     */
    list(request: ListEntitiesParams, options?: RequestOptions): Promise<ListEntitiesResponse>;
    /**
     * Updates an existing entity and returns the refreshed entity object.
     *
     * Use this to change entity billing controls or other mutable entity fields after the entity has already been created.
     *
     * @example
     * ```typescript
     * // Update a seat entity's billing controls
     * const response = await client.entities.update({ customerId: "cus_123", entityId: "seat_42", billingControls: {"spendLimits":[{"featureId":"messages","enabled":true,"overageLimit":25}]} });
     * ```
     *
     * @param customerId - The ID of the customer that owns the entity. (optional)
     * @param entityId - The ID of the entity.
     * @param billingControls - Billing controls to replace on the entity. (optional)
     *
     * @returns The updated entity object including its current subscriptions, purchases, and balances.
     */
    update(request: UpdateEntityParams, options?: RequestOptions): Promise<UpdateEntityResponse>;
    /**
     * Deletes an entity by entity ID.
     *
     * Use this when the underlying resource is removed and you no longer want entity-scoped balances or subscriptions tracked for it.
     *
     * @example
     * ```typescript
     * // Delete a seat entity
     * const response = await client.entities.delete({ entityId: "seat_42" });
     * ```
     *
     * @param customerId - The ID of the customer. (optional)
     * @param entityId - The ID of the entity.
     *
     * @returns A success flag indicating the entity was deleted.
     */
    delete(request: DeleteEntityParams, options?: RequestOptions): Promise<DeleteEntityResponse>;
}

declare class Events extends ClientSDK {
    /**
     * List usage events for your organization. Filter by customer, feature, or time range.
     */
    list(request: EventsListParams, options?: RequestOptions): Promise<ListEventsResponse>;
    /**
     * Aggregate usage events by time period. Returns usage totals grouped by feature and optionally by a custom property.
     */
    aggregate(request: EventsAggregateParams, options?: RequestOptions): Promise<AggregateEventsResponse>;
}

declare class Features extends ClientSDK {
    /**
     * Creates a new feature.
     *
     * Use this to programmatically create features for metering usage, managing access, or building credit systems.
     *
     * @example
     * ```typescript
     * // Create a metered feature for API calls
     * const response = await client.features.create({
     *
     *   featureId: "api-calls",
     *   name: "API Calls",
     *   type: "metered",
     *   consumable: true,
     * });
     * ```
     *
     * @example
     * ```typescript
     * // Create a boolean feature for a premium feature flag
     * const response = await client.features.create({ featureId: "advanced-analytics", name: "Advanced Analytics", type: "boolean" });
     * ```
     *
     * @param name - The name of the feature.
     * @param type - The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system.
     * @param consumable - Whether this feature is consumable. A consumable feature is one that periodically resets and is consumed rather than allocated (like credits, API requests, etc.). Applicable only for 'metered' features. (optional)
     * @param display - Singular and plural display names for the feature in your user interface. (optional)
     * @param creditSchema - A schema that maps 'single_use' feature IDs to credit costs. For classic credit systems only — AI credit systems use model_markups instead. (optional)
     * @param modelMarkups - Per-model markup overrides for AI credit systems. Maps model IDs to their markup configuration. (optional)
     * @param defaultMarkup - Default percentage markup for this AI credit system. Used when no model or provider markup applies. Use -100 to make usage free. (optional)
     * @param providerMarkups - Per-provider default markup percentages for AI credit systems. Provider keys match the first segment of model_id. (optional)
     * @param featureId - The ID of the feature to create.
     *
     * @returns The created feature object.
     */
    create(request: CreateFeatureParams, options?: RequestOptions): Promise<CreateFeatureResponse>;
    /**
     * Retrieves a single feature by its ID.
     *
     * Use this when you need to fetch the details of a specific feature.
     *
     * @example
     * ```typescript
     * // Get a feature by ID
     * const response = await client.features.get({ featureId: "api-calls" });
     * ```
     *
     * @param featureId - The ID of the feature.
     *
     * @returns The feature object with its full configuration.
     */
    get(request: GetFeatureParams, options?: RequestOptions): Promise<GetFeatureResponse>;
    /**
     * Lists all features in the current environment.
     *
     * Use this to retrieve all features configured for your organization to display in dashboards or for feature management.
     *
     * @returns A list of all features with their configuration and metadata.
     */
    list(request?: ListFeaturesRequest | undefined, options?: RequestOptions): Promise<ListFeaturesResponse>;
    /**
     * Updates an existing feature.
     *
     * Use this to modify feature properties like name, display settings, or to archive a feature.
     *
     * @example
     * ```typescript
     * // Update a feature's display name
     * const response = await client.features.update({ featureId: "api-calls", name: "API Requests", display: {"singular":"API request","plural":"API requests"} });
     * ```
     *
     * @example
     * ```typescript
     * // Archive a feature
     * const response = await client.features.update({ featureId: "deprecated-feature", archived: true });
     * ```
     *
     * @param name - The name of the feature. (optional)
     * @param type - The type of the feature. 'single_use' features are consumed, like API calls, tokens, or messages. 'continuous_use' features are allocated, like seats, workspaces, or projects. 'credit_system' features are schemas that unify multiple 'single_use' features into a single credit system. (optional)
     * @param consumable - Whether this feature is consumable. A consumable feature is one that periodically resets and is consumed rather than allocated (like credits, API requests, etc.). Applicable only for 'metered' features. (optional)
     * @param display - Singular and plural display names for the feature in your user interface. (optional)
     * @param creditSchema - A schema that maps 'single_use' feature IDs to credit costs. For classic credit systems only — AI credit systems use model_markups instead. (optional)
     * @param modelMarkups - Per-model markup overrides for AI credit systems. Maps model IDs to their markup configuration. (optional)
     * @param defaultMarkup - Default percentage markup for this AI credit system. Used when no model or provider markup applies. Use -100 to make usage free. (optional)
     * @param providerMarkups - Per-provider default markup percentages for AI credit systems. Provider keys match the first segment of model_id. (optional)
     * @param archived - Whether the feature is archived. Archived features are hidden from the dashboard. (optional)
     * @param featureId - The ID of the feature to update.
     * @param newFeatureId - The new ID of the feature. Feature ID can only be updated if it's not being used by any customers. (optional)
     *
     * @returns The updated feature object.
     */
    update(request: UpdateFeatureParams, options?: RequestOptions): Promise<UpdateFeatureResponse>;
    /**
     * Deletes a feature by its ID.
     *
     * Use this to permanently remove a feature. Note: features that are used in products cannot be deleted - archive them instead.
     *
     * @example
     * ```typescript
     * // Delete an unused feature
     * const response = await client.features.delete({ featureId: "old-feature" });
     * ```
     *
     * @param featureId - The ID of the feature to delete.
     *
     * @returns A success flag indicating the feature was deleted.
     */
    delete(request: DeleteFeatureParams, options?: RequestOptions): Promise<DeleteFeatureResponse>;
}

declare class Keys extends ClientSDK {
    /**
     * Mints a per-customer token (a scoped `am_jwt_` credential) so a downstream / self-hosted app can call Autumn directly without your secret key. Returns a short-lived access token plus a rotating refresh token, both bound to the given customer. Authenticated with your secret key.
     */
    mint(request: MintKeyParams, options?: RequestOptions): Promise<MintKeyResponse>;
    /**
     * Exchanges a refresh token (sent as the Bearer credential) for a freshly rotated access + refresh pair. Self-service for the token holder — no secret key required. The previous refresh token is honored for one rotation as a grace window; replaying an older one revokes the customer's tokens.
     */
    refresh(request: RefreshKeyParams, options?: RequestOptions): Promise<RefreshKeyResponse>;
    /**
     * Revokes every outstanding token (access and refresh) for a customer. Authenticated with your secret key. New tokens can be issued afterwards with `keys.mint`.
     */
    revoke(request: RevokeKeyParams, options?: RequestOptions): Promise<RevokeKeyResponse>;
}

declare class Plans extends ClientSDK {
    /**
     * Create a plan
     *
     * @remarks
     * Creates a new plan with optional base price and feature configurations.
     *
     * Use this to programmatically create pricing plans. See [How plans work](/documentation/pricing/plans) for concepts.
     *
     * @example
     * ```typescript
     * // Create a free plan with limited features
     * const response = await client.plans.create({
     *   planId: "free_plan",
     *   name: "Free",
     *   autoEnable: true,
     *   items: [{"featureId":"messages","included":100,"reset":{"interval":"month"}}],
     * });
     * ```
     *
     * @example
     * ```typescript
     * // Create a paid plan with base price and usage-based feature
     * const response = await client.plans.create({
     *   planId: "pro_plan",
     *   name: "Pro Plan",
     *   price: {"amount":10,"interval":"month"},
     *   items: [{"featureId":"messages","included":1000,"reset":{"interval":"month"},"price":{"amount":0.01,"interval":"month","billingUnits":1,"billingMethod":"usage_based"}}],
     * });
     * ```
     *
     * @example
     * ```typescript
     * // Create a plan with prepaid seats
     * const response = await client.plans.create({
     *   planId: "team_plan",
     *   name: "Team Plan",
     *   price: {"amount":49,"interval":"month"},
     *   items: [{"featureId":"seats","included":5,"price":{"amount":10,"interval":"month","billingUnits":1,"billingMethod":"prepaid"}}],
     * });
     * ```
     *
     * @example
     * ```typescript
     * // Create an add-on plan
     * const response = await client.plans.create({
     *   planId: "analytics_addon",
     *   name: "Advanced Analytics",
     *   addOn: true,
     *   price: {"amount":20,"interval":"month"},
     * });
     * ```
     *
     * @example
     * ```typescript
     * // Create a plan with tiered pricing
     * const response = await client.plans.create({ planId: "api_plan", name: "API Plan", items: [{"featureId":"api_calls","included":1000,"reset":{"interval":"month"},"price":{"tiers":[{"to":10000,"amount":0.001},{"to":100000,"amount":0.0005},{"to":"inf","amount":0.0001}],"interval":"month","billingUnits":1,"billingMethod":"usage_based"}}] });
     * ```
     *
     * @example
     * ```typescript
     * // Create a plan with free trial
     * const response = await client.plans.create({
     *   planId: "premium_plan",
     *   name: "Premium",
     *   price: {"amount":99,"interval":"month"},
     *   freeTrial: {"durationLength":14,"durationType":"day","cardRequired":true},
     * });
     * ```
     *
     * @param planId - The ID of the plan to create.
     * @param group - Group identifier for organizing related plans. Plans in the same group are mutually exclusive. (optional)
     * @param name - Display name of the plan.
     * @param description - Optional description of the plan. (optional)
     * @param addOn - If true, this plan can be attached alongside other plans. Otherwise, attaching replaces existing plans in the same group. (optional)
     * @param autoEnable - If true, plan is automatically attached when a customer is created. Use for free tiers. (optional)
     * @param price - Base recurring price for the plan. Omit for free or usage-only plans. (optional)
     * @param items - Feature configurations for this plan. Each item defines included units, pricing, and reset behavior. (optional)
     * @param freeTrial - Free trial configuration. Customers can try this plan before being charged. (optional)
     * @param config - Miscellaneous plan-level configuration flags. (optional)
     * @param billingControls - Plan-level billing controls used as customer defaults. (optional)
     * @param metadata - Arbitrary key-value metadata defined by you for your own use (e.g. UI copy, feature highlights). Values can be any JSON-serializable value. Shared across all versions of the plan. (optional)
     *
     * @returns The created plan object.
     */
    create(request: CreatePlanParams, options?: RequestOptions): Promise<CreatePlanResponse>;
    /**
     * Get a plan
     *
     * @remarks
     * Retrieves a single plan by its ID.
     *
     * Use this to fetch the full configuration of a specific plan, including its features and pricing.
     *
     * @example
     * ```typescript
     * // Get a plan by ID
     * const response = await client.plans.get({ planId: "pro_plan" });
     * ```
     *
     * @example
     * ```typescript
     * // Get a specific version of a plan
     * const response = await client.plans.get({ planId: "pro_plan", version: 2 });
     * ```
     *
     * @param planId - The ID of the plan to retrieve.
     * @param version - The version of the plan to get. Defaults to the latest version. (optional)
     *
     * @returns The plan object with its full configuration.
     */
    get(request: GetPlanParams, options?: RequestOptions): Promise<GetPlanResponse>;
    /**
     * List all plans
     *
     * @remarks
     * Lists all plans in the current environment.
     *
     * Use this to retrieve all plans for displaying pricing pages or managing plan configurations.
     *
     * @returns A list of all plans with their pricing and feature configurations.
     */
    list(request?: ListPlansParams | undefined, options?: RequestOptions): Promise<ListPlansResponse>;
    /**
     * Update a plan
     *
     * @remarks
     * Updates an existing plan. Creates a new version unless `disableVersion` is set.
     *
     * Use this to modify plan properties, pricing, or feature configurations. See [Adding features to plans](/documentation/pricing/plan-features) for item configuration.
     *
     * @example
     * ```typescript
     * // Update plan name and price
     * const response = await client.plans.update({ planId: "pro_plan", name: "Pro Plan (Updated)", price: {"amount":15,"interval":"month"} });
     * ```
     *
     * @example
     * ```typescript
     * // Add a feature to an existing plan
     * const response = await client.plans.update({ planId: "pro_plan", items: [{"featureId":"messages","included":1000,"reset":{"interval":"month"}},{"featureId":"storage","included":10,"reset":{"interval":"month"}}] });
     * ```
     *
     * @example
     * ```typescript
     * // Remove the base price (make usage-only)
     * const response = await client.plans.update({ planId: "pro_plan", price: null });
     * ```
     *
     * @example
     * ```typescript
     * // Archive a plan
     * const response = await client.plans.update({ planId: "old_plan", archived: true });
     * ```
     *
     * @example
     * ```typescript
     * // Update feature's included amount
     * const response = await client.plans.update({ planId: "pro_plan", items: [{"featureId":"messages","included":2000,"reset":{"interval":"month"}}] });
     * ```
     *
     * @param planId - The ID of the plan to update.
     * @param name - Display name of the plan. (optional)
     * @param addOn - Whether the plan is an add-on. (optional)
     * @param autoEnable - Whether the plan is automatically enabled. (optional)
     * @param price - The price of the plan. Set to null to remove the base price. (optional)
     * @param items - Feature configurations for this plan. Each item defines included units, pricing, and reset behavior. (optional)
     * @param freeTrial - The free trial of the plan. Set to null to remove the free trial. (optional)
     * @param config - Miscellaneous plan-level configuration flags. (optional)
     * @param billingControls - Plan-level billing controls used as customer defaults. (optional)
     * @param metadata - Arbitrary key-value metadata defined by you for your own use (e.g. UI copy, feature highlights). Values can be any JSON-serializable value. Shared across all versions of the plan. (optional)
     * @param basePlanId - The base plan this plan should be linked to as a variant. Set to null to detach it from its base plan. (optional)
     * @param newPlanId - The new ID to use for the plan. Can only be updated if the plan has not been used by any customers. (optional)
     * @param allVersions - Apply the update diff to all versions of this plan. Mutually exclusive with disable_version. (optional)
     * @param forceVersion - Force versioning even when no customers exist. Mutually exclusive with disable_version. (optional)
     * @param updateVariantIds - Variant plan IDs to apply this update to. Empty or omitted means no propagation. (optional)
     * @param variants - Additive variant updates for this base plan. Missing variants are created when name is provided. (optional)
     * @param isDefault - Whether this is the org's default plan. Cannot be true on a variant. (optional)
     *
     * @returns The updated plan object.
     */
    update(request: UpdatePlanParams, options?: RequestOptions): Promise<UpdatePlanResponse>;
    /**
     * Delete a plan
     *
     * @remarks
     * Deletes a plan by its ID.
     *
     * Use this to permanently remove a plan. Plans with active customers cannot be deleted - archive them instead.
     *
     * @example
     * ```typescript
     * // Delete a plan
     * const response = await client.plans.delete({ planId: "unused_plan" });
     * ```
     *
     * @example
     * ```typescript
     * // Delete all versions of a plan
     * const response = await client.plans.delete({ planId: "legacy_plan", allVersions: true });
     * ```
     *
     * @param planId - The ID of the plan to delete.
     * @param allVersions - If true, deletes all versions of the plan. Otherwise, only deletes the latest version. (optional)
     *
     * @returns A success flag indicating the plan was deleted.
     */
    delete(request: DeletePlanParams, options?: RequestOptions): Promise<DeletePlanResponse>;
}

declare class Platform extends ClientSDK {
    /**
     * Generate a RevenueCat OAuth URL for linking a project to an organization.
     */
    linkRevenueCat(request: LinkRevenueCatParams, options?: RequestOptions): Promise<LinkRevenueCatResponse>;
    /**
     * Push an organization's plans into RevenueCat as products (creating or renaming them across the project's apps) and set test-store prices from each plan's price. Requires the org to have linked RevenueCat via OAuth.
     */
    syncRevenueCat(request: SyncRevenueCatParams, options?: RequestOptions): Promise<SyncRevenueCatResponse>;
    /**
     * Retrieve a managed organization's RevenueCat public (SDK) API keys, grouped by app — for the test store, App Store, and Google Play Store. Use these to configure the RevenueCat SDK in the org's mobile app.
     */
    getRevenueCatKeys(request: GetRevenueCatKeysParams, options?: RequestOptions): Promise<GetRevenueCatKeysResponse>;
}

declare class Referrals extends ClientSDK {
    /**
     * Create or fetch a referral code for a customer in a referral program.
     */
    createCode(request: CreateReferralCodeParams, options?: RequestOptions): Promise<CreateReferralCodeResponse>;
    /**
     * Redeem a referral code for a customer.
     */
    redeemCode(request: RedeemReferralCodeParams, options?: RequestOptions): Promise<RedeemReferralCodeResponse>;
}

declare class Rewards extends ClientSDK {
    /**
     * List the coupons and feature grants configured for the org.
     */
    list(request?: RewardsListParams | undefined, options?: RequestOptions): Promise<ListRewardsResponse>;
    /**
     * Redeem a reward promo code for a customer.
     */
    redeemCode(request: RedeemRewardCodeParams, options?: RequestOptions): Promise<RedeemRewardCodeResponse>;
}

declare class Autumn extends ClientSDK {
    private _customers?;
    get customers(): Customers;
    private _plans?;
    get plans(): Plans;
    private _features?;
    get features(): Features;
    private _billing?;
    get billing(): Billing;
    private _balances?;
    get balances(): Balances;
    private _events?;
    get events(): Events;
    private _entities?;
    get entities(): Entities;
    private _referrals?;
    get referrals(): Referrals;
    private _rewards?;
    get rewards(): Rewards;
    private _platform?;
    get platform(): Platform;
    private _keys?;
    get keys(): Keys;
    /**
     * Checks whether a customer currently has enough balance to use a feature.
     *
     * Use this to gate access before a feature action. Enable sendEvent when you want to check and consume balance atomically in one request.
     *
     * @example
     * ```typescript
     * // Check access for a feature
     * const response = await client.check({ customerId: "cus_123", featureId: "messages" });
     * ```
     *
     * @example
     * ```typescript
     * // Check and consume 3 units in one call
     * const response = await client.check({
     *
     *   customerId: "cus_123",
     *   featureId: "messages",
     *   requiredBalance: 3,
     *   sendEvent: true,
     * });
     * ```
     *
     * @param customerId - The ID of the customer.
     * @param featureId - The ID of the feature.
     * @param entityId - The ID of the entity for entity-scoped balances (e.g., per-seat limits). (optional)
     * @param requiredBalance - Minimum balance required for access. Returns allowed: false if the customer's balance is below this value. Defaults to 1. (optional)
     * @param properties - Additional properties to attach to the usage event if send_event is true. (optional)
     * @param sendEvent - If true, atomically records a usage event while checking access. The required_balance value is used as the usage amount. Combines check + track in one call. (optional)
     * @param lock - Reserve units of a feature upfront by passing a lock_id, then call balances.finalize to confirm or release the hold. (optional)
     * @param withPreview - If true, includes upgrade/upsell information in the response when access is denied. Useful for displaying paywalls. (optional)
     *
     * @returns Whether access is allowed, plus the current balance for that feature. If Autumn is experiencing degraded service from a downstream provider, the API may return 202 and allow access fail-open.
     */
    check(request: CheckParams, options?: RequestOptions): Promise<CheckResponse>;
    /**
     * Records usage for a customer feature and returns updated balances.
     *
     * Use this after an action happens to decrement usage, or send a negative value to credit balance back.
     *
     * @example
     * ```typescript
     * // Track one message event
     * const response = await client.track({ customerId: "cus_123", featureId: "messages", value: 1 });
     * ```
     *
     * @example
     * ```typescript
     * // Track an event mapped to multiple features
     * const response = await client.track({ customerId: "cus_123", eventName: "ai_chat_request", value: 1 });
     * ```
     *
     * @param customerId - The ID of the customer.
     * @param featureId - The ID of the feature to track usage for. Required if event_name is not provided. (optional)
     * @param entityId - The ID of the entity for entity-scoped balances (e.g., per-seat limits). (optional)
     * @param eventName - Event name to track usage for. Use instead of feature_id when multiple features should be tracked from a single event. (optional)
     * @param value - The amount of usage to record. Defaults to 1. Use negative values to credit balance (e.g., when removing a seat). (optional)
     * @param properties - Additional properties to attach to this usage event. (optional)
     * @param timestamp - Unix timestamp in milliseconds to use for the usage event. Defaults to the current time. (optional)
     * @param async - If true, enqueue the event for asynchronous processing and return 204 immediately. The response will not include balance information. (optional)
     *
     * @returns The usage value recorded, with either a single updated balance or a map of updated balances. If Autumn is experiencing degraded service from a downstream provider, the API may return 202 after accepting the event for replay so it can be tracked as soon as the service is restored.
     */
    track(request: TrackParams, options?: RequestOptions): Promise<TrackResponse>;
    /**
     * Records AI token usage for a customer and returns the updated AI credit balance.
     *
     * Use this after an LLM request when you have input and output token counts. Autumn converts token usage to a dollar amount using the configured model pricing and markup, then tracks that value against the customer's AI credit system.
     *
     * @example
     * ```typescript
     * // Track one LLM response
     * const response = await client.trackTokens({
     *
     *   customerId: "cus_123",
     *   featureId: "ai_credits",
     *   modelId: "anthropic/claude-sonnet-4-20250514",
     *   inputTokens: 1000,
     *   outputTokens: 500,
     * });
     * ```
     *
     * @param customerId - The ID of the customer.
     * @param entityId - The ID of the entity for entity-scoped balances. (optional)
     * @param featureId - The ID of the AI credit system feature. Auto-detected from the customer's entitlements if omitted — only required when a customer has multiple AI credit systems. (optional)
     * @param modelId - The AI model as '[provider]/[model]' (e.g. 'anthropic/claude-opus-4-8', 'openrouter/openai/gpt-4o'). The provider is the first path segment and must match a provider + model key in models.dev.
     * @param inputTokens - Number of non-cached text input tokens consumed. Exclusive of cache and audio token pools.
     * @param outputTokens - Number of text output tokens consumed. Exclusive of the reasoning and audio output pools.
     * @param cacheReadTokens - Number of cached input tokens read. (optional)
     * @param cacheWriteTokens - Number of input tokens written to the cache. (optional)
     * @param audioInputTokens - Number of audio input tokens consumed. (optional)
     * @param audioOutputTokens - Number of audio output tokens generated. (optional)
     * @param reasoningTokens - Number of reasoning tokens generated. (optional)
     * @param properties - Additional properties to attach to this usage event. (optional)
     * @param timestamp - Unix timestamp in milliseconds to use for the usage event. Defaults to the current time. (optional)
     * @param async - If true, enqueue the event for asynchronous processing and return 204 immediately. The response will not include balance information. (optional)
     *
     * @returns The dollar value recorded and the updated AI credit system balance. If Autumn is experiencing degraded service from a downstream provider, the API may return 202 after accepting the token usage event for replay so it can be tracked as soon as the service is restored.
     */
    trackTokens(request: TrackTokensParams, options?: RequestOptions): Promise<TrackTokensResponse>;
    /**
     * Enqueue up to 1000 usage events for asynchronous processing. Items are validated synchronously up front; validated items are then enqueued via SQS for background deduction by workers. The response returns 202 immediately and does not include balance information. On partial enqueue failure (some items fail to enqueue, others succeed), the endpoint still returns 202 and logs the failures server-side; clients should NOT retry, because retrying re-enqueues the already-succeeded items. A 503 is returned only when zero items were successfully enqueued (queue entirely unavailable) — that case is safe to retry.
     */
    batchTrack(request: Array<RequestBody>, options?: RequestOptions): Promise<BatchTrackResponse>;
}

declare const blobLikeSchema: z$1.ZodMiniType<Blob, Blob>;
declare function isBlobLike(val: unknown): val is Blob;

declare function defaultToZeroValue<T>(value: T): Unrecognized<T>;
declare function startCountingDefaultToZeroValue(): {
    /**
     * Ends counting and returns the delta.
     * @param delta - If provided, only this amount is added to the parent counter
     *   (used for nested unions where we only want to record the winning option's count).
     *   If not provided, records all counts since start().
     */
    end: (delta?: number) => number;
};

type Paginator<V> = () => Promise<V & {
    next: Paginator<V>;
}> | null;
type PageIterator<V, PageState = unknown> = V & {
    next: Paginator<V>;
    [Symbol.asyncIterator]: () => AsyncIterableIterator<V>;
    "~next"?: PageState | undefined;
};
declare function createPageIterator<V>(page: V & {
    next: Paginator<V>;
}, halt: (v: V) => boolean): {
    [Symbol.asyncIterator]: () => AsyncIterableIterator<V>;
};

declare function string(): z$1.ZodMiniType<string>;
declare function boolean(): z$1.ZodMiniType<boolean>;
declare function number(): z$1.ZodMiniType<number>;
declare function bigint(): z$1.ZodMiniType<bigint>;
declare function date(): z$1.ZodMiniType<Date>;
declare function literal<T extends string | number | boolean>(value: T): z$1.ZodMiniType<T>;
declare function literalBigInt<T extends bigint>(value: T): z$1.ZodMiniType<T>;
declare function optional<T extends z$1.ZodMiniType>(t: T): z$1.ZodMiniOptional<z$1.ZodMiniUnion<readonly [z$1.ZodMiniPipe<z$1.ZodMiniNull, z$1.ZodMiniTransform<never, null>>, T]>>;
declare function nullable<T extends z$1.ZodMiniType>(t: T): z$1.ZodMiniUnion<readonly [z$1.ZodMiniNull, z$1.ZodMiniPipe<z$1.ZodMiniUndefined, z$1.ZodMiniTransform<never, undefined>>, T]>;

declare class RFCDate {
    private serialized;
    /**
     * Creates a new RFCDate instance using today's date.
     */
    static today(): RFCDate;
    /**
     * Creates a new RFCDate instance using the provided input.
     * If a string is used then in must be in the format YYYY-MM-DD.
     *
     * @param date A Date object or a date string in YYYY-MM-DD format
     * @example
     * new RFCDate("2022-01-01")
     * @example
     * new RFCDate(new Date())
     */
    constructor(date: Date | string);
    toJSON(): string;
    toString(): string;
}

type index_ClosedEnum<T extends Readonly<Record<string, string | number>>> = ClosedEnum<T>;
type index_OpenEnum<T extends Readonly<Record<string, string | number>>> = OpenEnum<T>;
type index_PageIterator<V, PageState = unknown> = PageIterator<V, PageState>;
type index_Paginator<V> = Paginator<V>;
type index_RFCDate = RFCDate;
declare const index_RFCDate: typeof RFCDate;
type index_Unrecognized<T> = Unrecognized<T>;
declare const index_bigint: typeof bigint;
declare const index_blobLikeSchema: typeof blobLikeSchema;
declare const index_boolean: typeof boolean;
declare const index_createPageIterator: typeof createPageIterator;
declare const index_date: typeof date;
declare const index_defaultToZeroValue: typeof defaultToZeroValue;
declare const index_isBlobLike: typeof isBlobLike;
declare const index_literal: typeof literal;
declare const index_literalBigInt: typeof literalBigInt;
declare const index_nullable: typeof nullable;
declare const index_number: typeof number;
declare const index_optional: typeof optional;
declare const index_startCountingDefaultToZeroValue: typeof startCountingDefaultToZeroValue;
declare const index_startCountingUnrecognized: typeof startCountingUnrecognized;
declare const index_string: typeof string;
declare const index_unrecognized: typeof unrecognized;
declare namespace index {
  export { type index_ClosedEnum as ClosedEnum, type index_OpenEnum as OpenEnum, type index_PageIterator as PageIterator, type index_Paginator as Paginator, index_RFCDate as RFCDate, type Result$1 as Result, type index_Unrecognized as Unrecognized, index_bigint as bigint, index_blobLikeSchema as blobLikeSchema, index_boolean as boolean, index_createPageIterator as createPageIterator, index_date as date, index_defaultToZeroValue as defaultToZeroValue, index_isBlobLike as isBlobLike, index_literal as literal, index_literalBigInt as literalBigInt, index_nullable as nullable, index_number as number, index_optional as optional, index_startCountingDefaultToZeroValue as startCountingDefaultToZeroValue, index_startCountingUnrecognized as startCountingUnrecognized, index_string as string, index_unrecognized as unrecognized };
}

export { type AggregateEventsCustomRange, type AggregateEventsCustomRange$Outbound, AggregateEventsCustomRange$outboundSchema, type AggregateEventsFeatureId, type AggregateEventsFeatureId$Outbound, AggregateEventsFeatureId$outboundSchema, type AggregateEventsGlobals, type AggregateEventsList, AggregateEventsList$inboundSchema, type AggregateEventsResponse, AggregateEventsResponse$inboundSchema, type ApiKey, ApiKey$inboundSchema, AttachAction, AttachAction$inboundSchema, AttachAddItemBillingMethod, AttachAddItemBillingMethod$outboundSchema, AttachAddItemExpiryDurationType, AttachAddItemExpiryDurationType$outboundSchema, AttachAddItemOnDecrease, AttachAddItemOnDecrease$outboundSchema, AttachAddItemOnIncrease, AttachAddItemOnIncrease$outboundSchema, type AttachAddItemPlanItem, type AttachAddItemPlanItem$Outbound, AttachAddItemPlanItem$outboundSchema, type AttachAddItemPrice, type AttachAddItemPrice$Outbound, AttachAddItemPrice$outboundSchema, AttachAddItemPriceInterval, AttachAddItemPriceInterval$outboundSchema, type AttachAddItemProration, type AttachAddItemProration$Outbound, AttachAddItemProration$outboundSchema, type AttachAddItemReset, type AttachAddItemReset$Outbound, AttachAddItemReset$outboundSchema, AttachAddItemResetInterval, AttachAddItemResetInterval$outboundSchema, type AttachAddItemRollover, type AttachAddItemRollover$Outbound, AttachAddItemRollover$outboundSchema, type AttachAddItemTier, type AttachAddItemTier$Outbound, AttachAddItemTier$outboundSchema, AttachAddItemTierBehavior, AttachAddItemTierBehavior$outboundSchema, type AttachAddItemTo, type AttachAddItemTo$Outbound, AttachAddItemTo$outboundSchema, type AttachAttachDiscount, type AttachAttachDiscount$Outbound, AttachAttachDiscount$outboundSchema, type AttachAutoTopup, type AttachAutoTopup$Outbound, AttachAutoTopup$outboundSchema, type AttachBasePrice, type AttachBasePrice$Outbound, AttachBasePrice$outboundSchema, type AttachBillingControls, type AttachBillingControls$Outbound, AttachBillingControls$outboundSchema, type AttachCarryOverBalances, type AttachCarryOverBalances$Outbound, AttachCarryOverBalances$outboundSchema, type AttachCarryOverUsages, type AttachCarryOverUsages$Outbound, AttachCarryOverUsages$outboundSchema, AttachCode, AttachCode$inboundSchema, type AttachCustomLineItem, type AttachCustomLineItem$Outbound, AttachCustomLineItem$outboundSchema, type AttachCustomize, type AttachCustomize$Outbound, AttachCustomize$outboundSchema, AttachDurationType, AttachDurationType$outboundSchema, type AttachFeatureQuantity, type AttachFeatureQuantity$Outbound, AttachFeatureQuantity$outboundSchema, type AttachFilter, type AttachFilter$Outbound, AttachFilter$outboundSchema, type AttachFreeTrialParams, type AttachFreeTrialParams$Outbound, AttachFreeTrialParams$outboundSchema, type AttachGlobals, AttachIntervalRemoveItemEnum1, AttachIntervalRemoveItemEnum1$outboundSchema, AttachIntervalRemoveItemEnum2, AttachIntervalRemoveItemEnum2$outboundSchema, type AttachIntervalUnion, type AttachIntervalUnion$Outbound, AttachIntervalUnion$outboundSchema, type AttachInvoice, AttachInvoice$inboundSchema, type AttachInvoiceMode, type AttachInvoiceMode$Outbound, AttachInvoiceMode$outboundSchema, AttachItemBillingMethod, AttachItemBillingMethod$outboundSchema, AttachItemExpiryDurationType, AttachItemExpiryDurationType$outboundSchema, AttachItemOnDecrease, AttachItemOnDecrease$outboundSchema, AttachItemOnIncrease, AttachItemOnIncrease$outboundSchema, type AttachItemPlanItem, type AttachItemPlanItem$Outbound, AttachItemPlanItem$outboundSchema, type AttachItemPrice, type AttachItemPrice$Outbound, AttachItemPrice$outboundSchema, AttachItemPriceInterval, AttachItemPriceInterval$outboundSchema, type AttachItemProration, type AttachItemProration$Outbound, AttachItemProration$outboundSchema, type AttachItemReset, type AttachItemReset$Outbound, AttachItemReset$outboundSchema, AttachItemResetInterval, AttachItemResetInterval$outboundSchema, type AttachItemRollover, type AttachItemRollover$Outbound, AttachItemRollover$outboundSchema, type AttachItemTier, type AttachItemTier$Outbound, AttachItemTier$outboundSchema, AttachItemTierBehavior, AttachItemTierBehavior$outboundSchema, type AttachItemTo, type AttachItemTo$Outbound, AttachItemTo$outboundSchema, AttachLimitType, AttachLimitType$outboundSchema, AttachOnEnd, AttachOnEnd$outboundSchema, type AttachOverageAllowed, type AttachOverageAllowed$Outbound, AttachOverageAllowed$outboundSchema, type AttachParams, type AttachParams$Outbound, AttachParams$outboundSchema, type AttachPlanItemFilter, type AttachPlanItemFilter$Outbound, AttachPlanItemFilter$outboundSchema, AttachPlanSchedule, AttachPlanSchedule$outboundSchema, AttachPriceInterval, AttachPriceInterval$outboundSchema, type AttachProperties, type AttachProperties$Outbound, AttachProperties$outboundSchema, AttachProrationBehavior, AttachProrationBehavior$outboundSchema, type AttachPurchaseLimit, type AttachPurchaseLimit$Outbound, AttachPurchaseLimit$outboundSchema, AttachPurchaseLimitInterval, AttachPurchaseLimitInterval$outboundSchema, AttachRedirectMode, AttachRedirectMode$outboundSchema, AttachRemoveItemBillingMethod, AttachRemoveItemBillingMethod$outboundSchema, type AttachRequiredAction, AttachRequiredAction$inboundSchema, type AttachResponse, AttachResponse$inboundSchema, type AttachSpendLimit, type AttachSpendLimit$Outbound, AttachSpendLimit$outboundSchema, AttachThresholdType, AttachThresholdType$outboundSchema, type AttachUsageAlert, type AttachUsageAlert$Outbound, AttachUsageAlert$outboundSchema, type AttachUsageLimit, type AttachUsageLimit$Outbound, AttachUsageLimit$outboundSchema, AttachUsageLimitInterval, AttachUsageLimitInterval$outboundSchema, AutoTopupSource, AutoTopupSource$inboundSchema, Autumn, AutumnDefaultError, AutumnError, type Balance, Balance$inboundSchema, BalanceBillingMethod, BalanceBillingMethod$inboundSchema, type BalanceCreditSchema, BalanceCreditSchema$inboundSchema, type BalanceDisplay, BalanceDisplay$inboundSchema, type BalanceFeature, BalanceFeature$inboundSchema, BalanceIntervalEnum, BalanceIntervalEnum$inboundSchema, type BalanceIntervalUnion, BalanceIntervalUnion$inboundSchema, type BalanceModelMarkups, BalanceModelMarkups$inboundSchema, type BalancePrice, BalancePrice$inboundSchema, type BalanceProviderMarkups, BalanceProviderMarkups$inboundSchema, type BalanceReset, BalanceReset$inboundSchema, type BalanceRollover, BalanceRollover$inboundSchema, type BalanceTier, BalanceTier$inboundSchema, BalanceTierBehavior, BalanceTierBehavior$inboundSchema, type BalanceTo, BalanceTo$inboundSchema, BalanceType, BalanceType$inboundSchema, type BasePrice, BasePrice$inboundSchema, type BatchTrackGlobals, type BatchTrackLock, type BatchTrackLock$Outbound, BatchTrackLock$outboundSchema, type BatchTrackResponse, BatchTrackResponse$inboundSchema, type Billable, type Billable$Outbound, Billable$outboundSchema, BillableProcessor, BillableProcessor$outboundSchema, BillingCycleAnchor2, BillingCycleAnchor2$outboundSchema, BillingUpdateAddItemBillingMethod, BillingUpdateAddItemBillingMethod$outboundSchema, BillingUpdateAddItemExpiryDurationType, BillingUpdateAddItemExpiryDurationType$outboundSchema, BillingUpdateAddItemOnDecrease, BillingUpdateAddItemOnDecrease$outboundSchema, BillingUpdateAddItemOnIncrease, BillingUpdateAddItemOnIncrease$outboundSchema, type BillingUpdateAddItemPlanItem, type BillingUpdateAddItemPlanItem$Outbound, BillingUpdateAddItemPlanItem$outboundSchema, type BillingUpdateAddItemPrice, type BillingUpdateAddItemPrice$Outbound, BillingUpdateAddItemPrice$outboundSchema, BillingUpdateAddItemPriceInterval, BillingUpdateAddItemPriceInterval$outboundSchema, type BillingUpdateAddItemProration, type BillingUpdateAddItemProration$Outbound, BillingUpdateAddItemProration$outboundSchema, type BillingUpdateAddItemReset, type BillingUpdateAddItemReset$Outbound, BillingUpdateAddItemReset$outboundSchema, BillingUpdateAddItemResetInterval, BillingUpdateAddItemResetInterval$outboundSchema, type BillingUpdateAddItemRollover, type BillingUpdateAddItemRollover$Outbound, BillingUpdateAddItemRollover$outboundSchema, type BillingUpdateAddItemTier, type BillingUpdateAddItemTier$Outbound, BillingUpdateAddItemTier$outboundSchema, BillingUpdateAddItemTierBehavior, BillingUpdateAddItemTierBehavior$outboundSchema, type BillingUpdateAddItemTo, type BillingUpdateAddItemTo$Outbound, BillingUpdateAddItemTo$outboundSchema, type BillingUpdateAttachDiscount, type BillingUpdateAttachDiscount$Outbound, BillingUpdateAttachDiscount$outboundSchema, type BillingUpdateAutoTopup, type BillingUpdateAutoTopup$Outbound, BillingUpdateAutoTopup$outboundSchema, type BillingUpdateBasePrice, type BillingUpdateBasePrice$Outbound, BillingUpdateBasePrice$outboundSchema, type BillingUpdateBillingControls, type BillingUpdateBillingControls$Outbound, BillingUpdateBillingControls$outboundSchema, BillingUpdateCancelAction, BillingUpdateCancelAction$outboundSchema, type BillingUpdateCarryOverUsages, type BillingUpdateCarryOverUsages$Outbound, BillingUpdateCarryOverUsages$outboundSchema, BillingUpdateCode, BillingUpdateCode$inboundSchema, type BillingUpdateCustomize, type BillingUpdateCustomize$Outbound, BillingUpdateCustomize$outboundSchema, BillingUpdateDurationType, BillingUpdateDurationType$outboundSchema, type BillingUpdateFeatureQuantity, type BillingUpdateFeatureQuantity$Outbound, BillingUpdateFeatureQuantity$outboundSchema, type BillingUpdateFilter, type BillingUpdateFilter$Outbound, BillingUpdateFilter$outboundSchema, type BillingUpdateFreeTrialParams, type BillingUpdateFreeTrialParams$Outbound, BillingUpdateFreeTrialParams$outboundSchema, type BillingUpdateGlobals, BillingUpdateIntervalRemoveItemEnum1, BillingUpdateIntervalRemoveItemEnum1$outboundSchema, BillingUpdateIntervalRemoveItemEnum2, BillingUpdateIntervalRemoveItemEnum2$outboundSchema, type BillingUpdateIntervalUnion, type BillingUpdateIntervalUnion$Outbound, BillingUpdateIntervalUnion$outboundSchema, type BillingUpdateInvoice, BillingUpdateInvoice$inboundSchema, type BillingUpdateInvoiceMode, type BillingUpdateInvoiceMode$Outbound, BillingUpdateInvoiceMode$outboundSchema, BillingUpdateItemBillingMethod, BillingUpdateItemBillingMethod$outboundSchema, BillingUpdateItemExpiryDurationType, BillingUpdateItemExpiryDurationType$outboundSchema, BillingUpdateItemOnDecrease, BillingUpdateItemOnDecrease$outboundSchema, BillingUpdateItemOnIncrease, BillingUpdateItemOnIncrease$outboundSchema, type BillingUpdateItemPlanItem, type BillingUpdateItemPlanItem$Outbound, BillingUpdateItemPlanItem$outboundSchema, type BillingUpdateItemPrice, type BillingUpdateItemPrice$Outbound, BillingUpdateItemPrice$outboundSchema, BillingUpdateItemPriceInterval, BillingUpdateItemPriceInterval$outboundSchema, type BillingUpdateItemProration, type BillingUpdateItemProration$Outbound, BillingUpdateItemProration$outboundSchema, type BillingUpdateItemReset, type BillingUpdateItemReset$Outbound, BillingUpdateItemReset$outboundSchema, BillingUpdateItemResetInterval, BillingUpdateItemResetInterval$outboundSchema, type BillingUpdateItemRollover, type BillingUpdateItemRollover$Outbound, BillingUpdateItemRollover$outboundSchema, type BillingUpdateItemTier, type BillingUpdateItemTier$Outbound, BillingUpdateItemTier$outboundSchema, BillingUpdateItemTierBehavior, BillingUpdateItemTierBehavior$outboundSchema, type BillingUpdateItemTo, type BillingUpdateItemTo$Outbound, BillingUpdateItemTo$outboundSchema, BillingUpdateLimitType, BillingUpdateLimitType$outboundSchema, BillingUpdateOnEnd, BillingUpdateOnEnd$outboundSchema, type BillingUpdateOverageAllowed, type BillingUpdateOverageAllowed$Outbound, BillingUpdateOverageAllowed$outboundSchema, type BillingUpdatePlanItemFilter, type BillingUpdatePlanItemFilter$Outbound, BillingUpdatePlanItemFilter$outboundSchema, BillingUpdatePriceInterval, BillingUpdatePriceInterval$outboundSchema, type BillingUpdateProperties, type BillingUpdateProperties$Outbound, BillingUpdateProperties$outboundSchema, BillingUpdateProrationBehavior, BillingUpdateProrationBehavior$outboundSchema, type BillingUpdatePurchaseLimit, type BillingUpdatePurchaseLimit$Outbound, BillingUpdatePurchaseLimit$outboundSchema, BillingUpdatePurchaseLimitInterval, BillingUpdatePurchaseLimitInterval$outboundSchema, type BillingUpdateRecalculateBalances, type BillingUpdateRecalculateBalances$Outbound, BillingUpdateRecalculateBalances$outboundSchema, BillingUpdateRedirectMode, BillingUpdateRedirectMode$outboundSchema, BillingUpdateRefundLastPayment, BillingUpdateRefundLastPayment$outboundSchema, BillingUpdateRemoveItemBillingMethod, BillingUpdateRemoveItemBillingMethod$outboundSchema, type BillingUpdateRequiredAction, BillingUpdateRequiredAction$inboundSchema, type BillingUpdateResponse, BillingUpdateResponse$inboundSchema, type BillingUpdateSpendLimit, type BillingUpdateSpendLimit$Outbound, BillingUpdateSpendLimit$outboundSchema, BillingUpdateThresholdType, BillingUpdateThresholdType$outboundSchema, type BillingUpdateUsageAlert, type BillingUpdateUsageAlert$Outbound, BillingUpdateUsageAlert$outboundSchema, type BillingUpdateUsageLimit, type BillingUpdateUsageLimit$Outbound, BillingUpdateUsageLimit$outboundSchema, BillingUpdateUsageLimitInterval, BillingUpdateUsageLimitInterval$outboundSchema, BinSize, BinSize$outboundSchema, type Breakdown, Breakdown$inboundSchema, type CheckAutoTopup1, CheckAutoTopup1$inboundSchema, type CheckAutoTopup2, CheckAutoTopup2$inboundSchema, type CheckBillingControls1, CheckBillingControls1$inboundSchema, type CheckBillingControls2, CheckBillingControls2$inboundSchema, type CheckConfig1, CheckConfig1$inboundSchema, type CheckConfig2, CheckConfig2$inboundSchema, type CheckCreditSchema1, CheckCreditSchema1$inboundSchema, type CheckCreditSchema2, CheckCreditSchema2$inboundSchema, CheckEnv1, CheckEnv1$inboundSchema, CheckEnv2, CheckEnv2$inboundSchema, type CheckFeature1, CheckFeature1$inboundSchema, type CheckFeature2, CheckFeature2$inboundSchema, type CheckFilter1, CheckFilter1$inboundSchema, type CheckFilter2, CheckFilter2$inboundSchema, type CheckFreeTrial1, CheckFreeTrial1$inboundSchema, type CheckFreeTrial2, CheckFreeTrial2$inboundSchema, type CheckGlobals, type CheckItem1, CheckItem1$inboundSchema, type CheckItem2, CheckItem2$inboundSchema, CheckItemInterval1, CheckItemInterval1$inboundSchema, CheckItemInterval2, CheckItemInterval2$inboundSchema, CheckLimitType1, CheckLimitType1$inboundSchema, CheckLimitType2, CheckLimitType2$inboundSchema, type CheckLock, type CheckLock$Outbound, CheckLock$outboundSchema, type CheckModelMarkups1, CheckModelMarkups1$inboundSchema, type CheckModelMarkups2, CheckModelMarkups2$inboundSchema, CheckOnDecrease1, CheckOnDecrease1$inboundSchema, CheckOnDecrease2, CheckOnDecrease2$inboundSchema, CheckOnEnd1, CheckOnEnd1$inboundSchema, CheckOnEnd2, CheckOnEnd2$inboundSchema, CheckOnIncrease1, CheckOnIncrease1$inboundSchema, CheckOnIncrease2, CheckOnIncrease2$inboundSchema, type CheckOverageAllowed1, CheckOverageAllowed1$inboundSchema, type CheckOverageAllowed2, CheckOverageAllowed2$inboundSchema, type CheckParams, type CheckParams$Outbound, CheckParams$outboundSchema, type CheckProduct1, CheckProduct1$inboundSchema, type CheckProduct2, CheckProduct2$inboundSchema, type CheckProperties1, CheckProperties1$inboundSchema, type CheckProperties2, CheckProperties2$inboundSchema, type CheckProviderMarkups1, CheckProviderMarkups1$inboundSchema, type CheckProviderMarkups2, CheckProviderMarkups2$inboundSchema, type CheckPurchaseLimit1, CheckPurchaseLimit1$inboundSchema, type CheckPurchaseLimit2, CheckPurchaseLimit2$inboundSchema, CheckPurchaseLimitInterval1, CheckPurchaseLimitInterval1$inboundSchema, CheckPurchaseLimitInterval2, CheckPurchaseLimitInterval2$inboundSchema, type CheckResponse, CheckResponse$inboundSchema, type CheckResponseBody1, CheckResponseBody1$inboundSchema, type CheckResponseBody2, CheckResponseBody2$inboundSchema, type CheckRollover1, CheckRollover1$inboundSchema, type CheckRollover2, CheckRollover2$inboundSchema, type CheckSpendLimit1, CheckSpendLimit1$inboundSchema, type CheckSpendLimit2, CheckSpendLimit2$inboundSchema, CheckThresholdType1, CheckThresholdType1$inboundSchema, CheckThresholdType2, CheckThresholdType2$inboundSchema, CheckTierBehavior1, CheckTierBehavior1$inboundSchema, CheckTierBehavior2, CheckTierBehavior2$inboundSchema, type CheckUsageAlert1, CheckUsageAlert1$inboundSchema, type CheckUsageAlert2, CheckUsageAlert2$inboundSchema, type CheckUsageLimit1, CheckUsageLimit1$inboundSchema, type CheckUsageLimit2, CheckUsageLimit2$inboundSchema, CheckUsageLimitInterval1, CheckUsageLimitInterval1$inboundSchema, CheckUsageLimitInterval2, CheckUsageLimitInterval2$inboundSchema, ConfigDuration1, ConfigDuration1$inboundSchema, ConfigDuration2, ConfigDuration2$inboundSchema, ConnectionError, type Coupon, Coupon$inboundSchema, type CouponPromoCode, CouponPromoCode$inboundSchema, CouponType, CouponType$inboundSchema, CreateBalanceDuration, CreateBalanceDuration$outboundSchema, type CreateBalanceGlobals, CreateBalanceInterval, CreateBalanceInterval$outboundSchema, type CreateBalanceParams, type CreateBalanceParams$Outbound, CreateBalanceParams$outboundSchema, type CreateBalanceReset, type CreateBalanceReset$Outbound, CreateBalanceReset$outboundSchema, type CreateBalanceResponse, CreateBalanceResponse$inboundSchema, type CreateBalanceRollover, type CreateBalanceRollover$Outbound, CreateBalanceRollover$outboundSchema, type CreateEntityBillingControlsRequest, type CreateEntityBillingControlsRequest$Outbound, CreateEntityBillingControlsRequest$outboundSchema, type CreateEntityBillingControlsResponse, CreateEntityBillingControlsResponse$inboundSchema, type CreateEntityCreditSchema, CreateEntityCreditSchema$inboundSchema, type CreateEntityDisplay, CreateEntityDisplay$inboundSchema, CreateEntityEnv, CreateEntityEnv$inboundSchema, type CreateEntityFeature, CreateEntityFeature$inboundSchema, type CreateEntityFilterRequest, type CreateEntityFilterRequest$Outbound, CreateEntityFilterRequest$outboundSchema, type CreateEntityFilterResponse, CreateEntityFilterResponse$inboundSchema, type CreateEntityFlags, CreateEntityFlags$inboundSchema, type CreateEntityGlobals, CreateEntityIntervalRequestBody, CreateEntityIntervalRequestBody$outboundSchema, CreateEntityIntervalResponse, CreateEntityIntervalResponse$inboundSchema, type CreateEntityInvoice, CreateEntityInvoice$inboundSchema, CreateEntityLimitTypeRequestBody, CreateEntityLimitTypeRequestBody$outboundSchema, CreateEntityLimitTypeResponse, CreateEntityLimitTypeResponse$inboundSchema, type CreateEntityModelMarkups, CreateEntityModelMarkups$inboundSchema, type CreateEntityOverageAllowedRequest, type CreateEntityOverageAllowedRequest$Outbound, CreateEntityOverageAllowedRequest$outboundSchema, type CreateEntityOverageAllowedResponse, CreateEntityOverageAllowedResponse$inboundSchema, CreateEntityOverageAllowedSource, CreateEntityOverageAllowedSource$inboundSchema, type CreateEntityParams, type CreateEntityParams$Outbound, CreateEntityParams$outboundSchema, CreateEntityProcessorType, CreateEntityProcessorType$inboundSchema, type CreateEntityProperties, type CreateEntityProperties$Outbound, CreateEntityProperties$outboundSchema, type CreateEntityProviderMarkups, CreateEntityProviderMarkups$inboundSchema, type CreateEntityPurchase, CreateEntityPurchase$inboundSchema, CreateEntityPurchaseScope, CreateEntityPurchaseScope$inboundSchema, type CreateEntityResponse, CreateEntityResponse$inboundSchema, type CreateEntitySpendLimitRequest, type CreateEntitySpendLimitRequest$Outbound, CreateEntitySpendLimitRequest$outboundSchema, type CreateEntitySpendLimitResponse, CreateEntitySpendLimitResponse$inboundSchema, CreateEntitySpendLimitSource, CreateEntitySpendLimitSource$inboundSchema, CreateEntityStatus, CreateEntityStatus$inboundSchema, type CreateEntitySubscription, CreateEntitySubscription$inboundSchema, CreateEntitySubscriptionScope, CreateEntitySubscriptionScope$inboundSchema, CreateEntityThresholdTypeRequestBody, CreateEntityThresholdTypeRequestBody$outboundSchema, CreateEntityThresholdTypeResponse, CreateEntityThresholdTypeResponse$inboundSchema, CreateEntityType, CreateEntityType$inboundSchema, type CreateEntityUsageAlertRequestBody, type CreateEntityUsageAlertRequestBody$Outbound, CreateEntityUsageAlertRequestBody$outboundSchema, type CreateEntityUsageAlertResponse, CreateEntityUsageAlertResponse$inboundSchema, CreateEntityUsageAlertSource, CreateEntityUsageAlertSource$inboundSchema, type CreateEntityUsageLimitRequest, type CreateEntityUsageLimitRequest$Outbound, CreateEntityUsageLimitRequest$outboundSchema, type CreateEntityUsageLimitResponse, CreateEntityUsageLimitResponse$inboundSchema, CreateEntityUsageLimitSource, CreateEntityUsageLimitSource$inboundSchema, type CreateFeatureCreditSchemaRequestBody, type CreateFeatureCreditSchemaRequestBody$Outbound, CreateFeatureCreditSchemaRequestBody$outboundSchema, type CreateFeatureCreditSchemaResponse, CreateFeatureCreditSchemaResponse$inboundSchema, type CreateFeatureDisplayRequestBody, type CreateFeatureDisplayRequestBody$Outbound, CreateFeatureDisplayRequestBody$outboundSchema, type CreateFeatureDisplayResponse, CreateFeatureDisplayResponse$inboundSchema, type CreateFeatureGlobals, type CreateFeatureModelMarkupsRequest, type CreateFeatureModelMarkupsRequest$Outbound, CreateFeatureModelMarkupsRequest$outboundSchema, type CreateFeatureModelMarkupsResponse, CreateFeatureModelMarkupsResponse$inboundSchema, type CreateFeatureParams, type CreateFeatureParams$Outbound, CreateFeatureParams$outboundSchema, type CreateFeatureProviderMarkupsRequest, type CreateFeatureProviderMarkupsRequest$Outbound, CreateFeatureProviderMarkupsRequest$outboundSchema, type CreateFeatureProviderMarkupsResponse, CreateFeatureProviderMarkupsResponse$inboundSchema, type CreateFeatureResponse, CreateFeatureResponse$inboundSchema, CreateFeatureTypeRequestBody, CreateFeatureTypeRequestBody$outboundSchema, CreateFeatureTypeResponse, CreateFeatureTypeResponse$inboundSchema, CreatePlanAddItemBillingMethod, CreatePlanAddItemBillingMethod$inboundSchema, CreatePlanAddItemPriceInterval, CreatePlanAddItemPriceInterval$inboundSchema, CreatePlanAddItemResetInterval, CreatePlanAddItemResetInterval$inboundSchema, CreatePlanAttachAction, CreatePlanAttachAction$inboundSchema, type CreatePlanAutoTopupRequest, type CreatePlanAutoTopupRequest$Outbound, CreatePlanAutoTopupRequest$outboundSchema, type CreatePlanAutoTopupResponse, CreatePlanAutoTopupResponse$inboundSchema, type CreatePlanBasePrice, CreatePlanBasePrice$inboundSchema, type CreatePlanBillingControlsRequest, type CreatePlanBillingControlsRequest$Outbound, CreatePlanBillingControlsRequest$outboundSchema, type CreatePlanBillingControlsResponse, CreatePlanBillingControlsResponse$inboundSchema, CreatePlanBillingMethodRequestBody, CreatePlanBillingMethodRequestBody$outboundSchema, type CreatePlanConfigRequest, type CreatePlanConfigRequest$Outbound, CreatePlanConfigRequest$outboundSchema, type CreatePlanConfigResponse, CreatePlanConfigResponse$inboundSchema, type CreatePlanCreditSchema, CreatePlanCreditSchema$inboundSchema, type CreatePlanCustomerEligibility, CreatePlanCustomerEligibility$inboundSchema, type CreatePlanCustomize, CreatePlanCustomize$inboundSchema, CreatePlanDurationTypeRequest, CreatePlanDurationTypeRequest$outboundSchema, CreatePlanDurationTypeResponse, CreatePlanDurationTypeResponse$inboundSchema, CreatePlanEnv, CreatePlanEnv$inboundSchema, CreatePlanExpiryDurationTypeRequestBody, CreatePlanExpiryDurationTypeRequestBody$outboundSchema, type CreatePlanFeature, CreatePlanFeature$inboundSchema, type CreatePlanFeatureDisplay, CreatePlanFeatureDisplay$inboundSchema, type CreatePlanFilterRequest, type CreatePlanFilterRequest$Outbound, CreatePlanFilterRequest$outboundSchema, type CreatePlanFilterResponse, CreatePlanFilterResponse$inboundSchema, type CreatePlanFreeTrialParams, CreatePlanFreeTrialParams$inboundSchema, type CreatePlanFreeTrialResponse, CreatePlanFreeTrialResponse$inboundSchema, type CreatePlanGlobals, CreatePlanIntervalRemoveItemEnum1, CreatePlanIntervalRemoveItemEnum1$inboundSchema, CreatePlanIntervalRemoveItemEnum2, CreatePlanIntervalRemoveItemEnum2$inboundSchema, type CreatePlanIntervalUnion, CreatePlanIntervalUnion$inboundSchema, type CreatePlanItem, CreatePlanItem$inboundSchema, CreatePlanItemBillingMethodResponse, CreatePlanItemBillingMethodResponse$inboundSchema, type CreatePlanItemDisplay, CreatePlanItemDisplay$inboundSchema, CreatePlanItemExpiryDurationTypeResponse, CreatePlanItemExpiryDurationTypeResponse$inboundSchema, CreatePlanItemOnDecrease, CreatePlanItemOnDecrease$outboundSchema, CreatePlanItemOnIncrease, CreatePlanItemOnIncrease$outboundSchema, type CreatePlanItemPlanItem, type CreatePlanItemPlanItem$Outbound, CreatePlanItemPlanItem$outboundSchema, CreatePlanItemPriceIntervalRequestBody, CreatePlanItemPriceIntervalRequestBody$outboundSchema, type CreatePlanItemPriceRequestBody, type CreatePlanItemPriceRequestBody$Outbound, CreatePlanItemPriceRequestBody$outboundSchema, type CreatePlanItemPriceResponse, CreatePlanItemPriceResponse$inboundSchema, type CreatePlanItemProration, type CreatePlanItemProration$Outbound, CreatePlanItemProration$outboundSchema, type CreatePlanItemResetResponse, CreatePlanItemResetResponse$inboundSchema, type CreatePlanItemRolloverResponse, CreatePlanItemRolloverResponse$inboundSchema, CreatePlanItemTierBehaviorResponse, CreatePlanItemTierBehaviorResponse$inboundSchema, type CreatePlanItemTierResponse, CreatePlanItemTierResponse$inboundSchema, type CreatePlanItemToResponse, CreatePlanItemToResponse$inboundSchema, CreatePlanLimitTypeRequestBody, CreatePlanLimitTypeRequestBody$outboundSchema, CreatePlanLimitTypeResponse, CreatePlanLimitTypeResponse$inboundSchema, CreatePlanOnEndRequest, CreatePlanOnEndRequest$outboundSchema, CreatePlanOnEndResponse, CreatePlanOnEndResponse$inboundSchema, type CreatePlanOverageAllowedRequest, type CreatePlanOverageAllowedRequest$Outbound, CreatePlanOverageAllowedRequest$outboundSchema, type CreatePlanOverageAllowedResponse, CreatePlanOverageAllowedResponse$inboundSchema, type CreatePlanParams, type CreatePlanParams$Outbound, CreatePlanParams$outboundSchema, type CreatePlanPlanItemFilter, CreatePlanPlanItemFilter$inboundSchema, type CreatePlanPlanItemResponse, CreatePlanPlanItemResponse$inboundSchema, type CreatePlanPriceDisplay, CreatePlanPriceDisplay$inboundSchema, CreatePlanPriceIntervalRequestBody, CreatePlanPriceIntervalRequestBody$outboundSchema, CreatePlanPriceIntervalResponse, CreatePlanPriceIntervalResponse$inboundSchema, CreatePlanPriceItemIntervalResponse, CreatePlanPriceItemIntervalResponse$inboundSchema, type CreatePlanPriceRequestBody, type CreatePlanPriceRequestBody$Outbound, CreatePlanPriceRequestBody$outboundSchema, type CreatePlanPriceResponse, CreatePlanPriceResponse$inboundSchema, CreatePlanPriceVariantDetailsInterval, CreatePlanPriceVariantDetailsInterval$inboundSchema, type CreatePlanProperties, type CreatePlanProperties$Outbound, CreatePlanProperties$outboundSchema, type CreatePlanProrationResponse, CreatePlanProrationResponse$inboundSchema, CreatePlanPurchaseLimitIntervalRequestBody, CreatePlanPurchaseLimitIntervalRequestBody$outboundSchema, CreatePlanPurchaseLimitIntervalResponse, CreatePlanPurchaseLimitIntervalResponse$inboundSchema, type CreatePlanPurchaseLimitRequest, type CreatePlanPurchaseLimitRequest$Outbound, CreatePlanPurchaseLimitRequest$outboundSchema, type CreatePlanPurchaseLimitResponse, CreatePlanPurchaseLimitResponse$inboundSchema, CreatePlanRemoveItemBillingMethod, CreatePlanRemoveItemBillingMethod$inboundSchema, CreatePlanResetIntervalRequestBody, CreatePlanResetIntervalRequestBody$outboundSchema, CreatePlanResetItemIntervalResponse, CreatePlanResetItemIntervalResponse$inboundSchema, type CreatePlanResetRequestBody, type CreatePlanResetRequestBody$Outbound, CreatePlanResetRequestBody$outboundSchema, type CreatePlanResponse, CreatePlanResponse$inboundSchema, type CreatePlanRolloverRequestBody, type CreatePlanRolloverRequestBody$Outbound, CreatePlanRolloverRequestBody$outboundSchema, type CreatePlanSpendLimitRequest, type CreatePlanSpendLimitRequest$Outbound, CreatePlanSpendLimitRequest$outboundSchema, type CreatePlanSpendLimitResponse, CreatePlanSpendLimitResponse$inboundSchema, CreatePlanStatus, CreatePlanStatus$inboundSchema, CreatePlanThresholdTypeRequestBody, CreatePlanThresholdTypeRequestBody$outboundSchema, CreatePlanThresholdTypeResponse, CreatePlanThresholdTypeResponse$inboundSchema, CreatePlanTierBehaviorRequestBody, CreatePlanTierBehaviorRequestBody$outboundSchema, type CreatePlanTierRequestBody, type CreatePlanTierRequestBody$Outbound, CreatePlanTierRequestBody$outboundSchema, type CreatePlanToRequestBody, type CreatePlanToRequestBody$Outbound, CreatePlanToRequestBody$outboundSchema, CreatePlanType, CreatePlanType$inboundSchema, type CreatePlanUsageAlertRequestBody, type CreatePlanUsageAlertRequestBody$Outbound, CreatePlanUsageAlertRequestBody$outboundSchema, type CreatePlanUsageAlertResponse, CreatePlanUsageAlertResponse$inboundSchema, CreatePlanUsageLimitIntervalRequestBody, CreatePlanUsageLimitIntervalRequestBody$outboundSchema, CreatePlanUsageLimitIntervalResponse, CreatePlanUsageLimitIntervalResponse$inboundSchema, type CreatePlanUsageLimitRequest, type CreatePlanUsageLimitRequest$Outbound, CreatePlanUsageLimitRequest$outboundSchema, type CreatePlanUsageLimitResponse, CreatePlanUsageLimitResponse$inboundSchema, type CreatePlanVariantDetails, CreatePlanVariantDetails$inboundSchema, type CreatePlanVariantDetailsAutoTopup, CreatePlanVariantDetailsAutoTopup$inboundSchema, type CreatePlanVariantDetailsBillingControls, CreatePlanVariantDetailsBillingControls$inboundSchema, CreatePlanVariantDetailsDurationType, CreatePlanVariantDetailsDurationType$inboundSchema, CreatePlanVariantDetailsExpiryDurationType, CreatePlanVariantDetailsExpiryDurationType$inboundSchema, type CreatePlanVariantDetailsFilter, CreatePlanVariantDetailsFilter$inboundSchema, CreatePlanVariantDetailsLimitType, CreatePlanVariantDetailsLimitType$inboundSchema, CreatePlanVariantDetailsOnDecrease, CreatePlanVariantDetailsOnDecrease$inboundSchema, CreatePlanVariantDetailsOnEnd, CreatePlanVariantDetailsOnEnd$inboundSchema, CreatePlanVariantDetailsOnIncrease, CreatePlanVariantDetailsOnIncrease$inboundSchema, type CreatePlanVariantDetailsOverageAllowed, CreatePlanVariantDetailsOverageAllowed$inboundSchema, type CreatePlanVariantDetailsPrice, CreatePlanVariantDetailsPrice$inboundSchema, type CreatePlanVariantDetailsPurchaseLimit, CreatePlanVariantDetailsPurchaseLimit$inboundSchema, CreatePlanVariantDetailsPurchaseLimitInterval, CreatePlanVariantDetailsPurchaseLimitInterval$inboundSchema, type CreatePlanVariantDetailsReset, CreatePlanVariantDetailsReset$inboundSchema, type CreatePlanVariantDetailsRollover, CreatePlanVariantDetailsRollover$inboundSchema, type CreatePlanVariantDetailsSpendLimit, CreatePlanVariantDetailsSpendLimit$inboundSchema, CreatePlanVariantDetailsThresholdType, CreatePlanVariantDetailsThresholdType$inboundSchema, type CreatePlanVariantDetailsTier, CreatePlanVariantDetailsTier$inboundSchema, CreatePlanVariantDetailsTierBehavior, CreatePlanVariantDetailsTierBehavior$inboundSchema, type CreatePlanVariantDetailsTo, CreatePlanVariantDetailsTo$inboundSchema, type CreatePlanVariantDetailsUsageAlert, CreatePlanVariantDetailsUsageAlert$inboundSchema, type CreatePlanVariantDetailsUsageLimit, CreatePlanVariantDetailsUsageLimit$inboundSchema, CreatePlanVariantDetailsUsageLimitInterval, CreatePlanVariantDetailsUsageLimitInterval$inboundSchema, type CreateReferralCodeGlobals, type CreateReferralCodeParams, type CreateReferralCodeParams$Outbound, CreateReferralCodeParams$outboundSchema, type CreateReferralCodeResponse, CreateReferralCodeResponse$inboundSchema, CreateScheduleAddItemBillingMethod2, CreateScheduleAddItemBillingMethod2$outboundSchema, CreateScheduleAddItemExpiryDurationType2, CreateScheduleAddItemExpiryDurationType2$outboundSchema, CreateScheduleAddItemOnDecrease2, CreateScheduleAddItemOnDecrease2$outboundSchema, CreateScheduleAddItemOnIncrease2, CreateScheduleAddItemOnIncrease2$outboundSchema, type CreateScheduleAddItemPlanItem2, type CreateScheduleAddItemPlanItem2$Outbound, CreateScheduleAddItemPlanItem2$outboundSchema, type CreateScheduleAddItemPrice2, type CreateScheduleAddItemPrice2$Outbound, CreateScheduleAddItemPrice2$outboundSchema, CreateScheduleAddItemPriceInterval2, CreateScheduleAddItemPriceInterval2$outboundSchema, type CreateScheduleAddItemProration2, type CreateScheduleAddItemProration2$Outbound, CreateScheduleAddItemProration2$outboundSchema, type CreateScheduleAddItemReset2, type CreateScheduleAddItemReset2$Outbound, CreateScheduleAddItemReset2$outboundSchema, CreateScheduleAddItemResetInterval2, CreateScheduleAddItemResetInterval2$outboundSchema, type CreateScheduleAddItemRollover2, type CreateScheduleAddItemRollover2$Outbound, CreateScheduleAddItemRollover2$outboundSchema, type CreateScheduleAddItemTier2, type CreateScheduleAddItemTier2$Outbound, CreateScheduleAddItemTier2$outboundSchema, CreateScheduleAddItemTierBehavior2, CreateScheduleAddItemTierBehavior2$outboundSchema, type CreateScheduleAttachDiscount, type CreateScheduleAttachDiscount$Outbound, CreateScheduleAttachDiscount$outboundSchema, type CreateScheduleAutoTopup2, type CreateScheduleAutoTopup2$Outbound, CreateScheduleAutoTopup2$outboundSchema, type CreateScheduleBasePrice2, type CreateScheduleBasePrice2$Outbound, CreateScheduleBasePrice2$outboundSchema, CreateScheduleBillingBehavior, CreateScheduleBillingBehavior$outboundSchema, type CreateScheduleBillingControls2, type CreateScheduleBillingControls2$Outbound, CreateScheduleBillingControls2$outboundSchema, CreateScheduleCode, CreateScheduleCode$inboundSchema, type CreateScheduleCustomize2, type CreateScheduleCustomize2$Outbound, CreateScheduleCustomize2$outboundSchema, CreateScheduleDurationType2, CreateScheduleDurationType2$outboundSchema, type CreateScheduleFeatureQuantity2, type CreateScheduleFeatureQuantity2$Outbound, CreateScheduleFeatureQuantity2$outboundSchema, type CreateScheduleFilter2, type CreateScheduleFilter2$Outbound, CreateScheduleFilter2$outboundSchema, type CreateScheduleGlobals, CreateScheduleIntervalRemoveItemEnum3, CreateScheduleIntervalRemoveItemEnum3$outboundSchema, CreateScheduleIntervalRemoveItemEnum4, CreateScheduleIntervalRemoveItemEnum4$outboundSchema, type CreateScheduleIntervalUnion2, type CreateScheduleIntervalUnion2$Outbound, CreateScheduleIntervalUnion2$outboundSchema, type CreateScheduleInvoice, CreateScheduleInvoice$inboundSchema, type CreateScheduleInvoiceMode, type CreateScheduleInvoiceMode$Outbound, CreateScheduleInvoiceMode$outboundSchema, CreateScheduleItemBillingMethod2, CreateScheduleItemBillingMethod2$outboundSchema, CreateScheduleItemExpiryDurationType2, CreateScheduleItemExpiryDurationType2$outboundSchema, CreateScheduleItemOnDecrease2, CreateScheduleItemOnDecrease2$outboundSchema, CreateScheduleItemOnIncrease2, CreateScheduleItemOnIncrease2$outboundSchema, type CreateScheduleItemPlanItem2, type CreateScheduleItemPlanItem2$Outbound, CreateScheduleItemPlanItem2$outboundSchema, type CreateScheduleItemPrice2, type CreateScheduleItemPrice2$Outbound, CreateScheduleItemPrice2$outboundSchema, CreateScheduleItemPriceInterval2, CreateScheduleItemPriceInterval2$outboundSchema, type CreateScheduleItemProration2, type CreateScheduleItemProration2$Outbound, CreateScheduleItemProration2$outboundSchema, type CreateScheduleItemReset2, type CreateScheduleItemReset2$Outbound, CreateScheduleItemReset2$outboundSchema, CreateScheduleItemResetInterval2, CreateScheduleItemResetInterval2$outboundSchema, type CreateScheduleItemRollover2, type CreateScheduleItemRollover2$Outbound, CreateScheduleItemRollover2$outboundSchema, type CreateScheduleItemTier2, type CreateScheduleItemTier2$Outbound, CreateScheduleItemTier2$outboundSchema, CreateScheduleItemTierBehavior2, CreateScheduleItemTierBehavior2$outboundSchema, CreateScheduleLimitType2, CreateScheduleLimitType2$outboundSchema, type CreateScheduleOverageAllowed2, type CreateScheduleOverageAllowed2$Outbound, CreateScheduleOverageAllowed2$outboundSchema, type CreateScheduleParams, type CreateScheduleParams$Outbound, CreateScheduleParams$outboundSchema, type CreateSchedulePlan2, type CreateSchedulePlan2$Outbound, CreateSchedulePlan2$outboundSchema, type CreateSchedulePlanItemFilter2, type CreateSchedulePlanItemFilter2$Outbound, CreateSchedulePlanItemFilter2$outboundSchema, CreateSchedulePriceInterval2, CreateSchedulePriceInterval2$outboundSchema, type CreateSchedulePurchaseLimit2, type CreateSchedulePurchaseLimit2$Outbound, CreateSchedulePurchaseLimit2$outboundSchema, CreateSchedulePurchaseLimitInterval2, CreateSchedulePurchaseLimitInterval2$outboundSchema, CreateScheduleRedirectMode, CreateScheduleRedirectMode$outboundSchema, CreateScheduleRemoveItemBillingMethod2, CreateScheduleRemoveItemBillingMethod2$outboundSchema, type CreateScheduleRequiredAction, CreateScheduleRequiredAction$inboundSchema, type CreateScheduleResponse, CreateScheduleResponse$inboundSchema, type CreateScheduleSpendLimit2, type CreateScheduleSpendLimit2$Outbound, CreateScheduleSpendLimit2$outboundSchema, CreateScheduleStatus, CreateScheduleStatus$inboundSchema, CreateScheduleThresholdType2, CreateScheduleThresholdType2$outboundSchema, type CreateScheduleUsageAlert2, type CreateScheduleUsageAlert2$Outbound, CreateScheduleUsageAlert2$outboundSchema, type CreateScheduleUsageLimit2, type CreateScheduleUsageLimit2$Outbound, CreateScheduleUsageLimit2$outboundSchema, CreateScheduleUsageLimitInterval2, CreateScheduleUsageLimitInterval2$outboundSchema, type Customer, Customer$inboundSchema, type CustomerAutoTopup, CustomerAutoTopup$inboundSchema, type CustomerBillingControls, CustomerBillingControls$inboundSchema, type CustomerConfig, CustomerConfig$inboundSchema, type CustomerCreditSchema, CustomerCreditSchema$inboundSchema, type CustomerData, type CustomerData$Outbound, CustomerData$outboundSchema, type CustomerDataAutoTopup, type CustomerDataAutoTopup$Outbound, CustomerDataAutoTopup$outboundSchema, type CustomerDataBillingControls, type CustomerDataBillingControls$Outbound, CustomerDataBillingControls$outboundSchema, type CustomerDataConfig, type CustomerDataConfig$Outbound, CustomerDataConfig$outboundSchema, type CustomerDataFilter, type CustomerDataFilter$Outbound, CustomerDataFilter$outboundSchema, CustomerDataLimitType, CustomerDataLimitType$outboundSchema, type CustomerDataOverageAllowed, type CustomerDataOverageAllowed$Outbound, CustomerDataOverageAllowed$outboundSchema, type CustomerDataPurchaseLimit, type CustomerDataPurchaseLimit$Outbound, CustomerDataPurchaseLimit$outboundSchema, CustomerDataPurchaseLimitInterval, CustomerDataPurchaseLimitInterval$outboundSchema, type CustomerDataSpendLimit, type CustomerDataSpendLimit$Outbound, CustomerDataSpendLimit$outboundSchema, CustomerDataThresholdType, CustomerDataThresholdType$outboundSchema, type CustomerDataUsageAlert, type CustomerDataUsageAlert$Outbound, CustomerDataUsageAlert$outboundSchema, type CustomerDataUsageLimit, type CustomerDataUsageLimit$Outbound, CustomerDataUsageLimit$outboundSchema, CustomerDataUsageLimitInterval, CustomerDataUsageLimitInterval$outboundSchema, CustomerDiscountType, CustomerDiscountType$inboundSchema, type CustomerDisplay, CustomerDisplay$inboundSchema, CustomerDurationType, CustomerDurationType$inboundSchema, type CustomerEligibility, CustomerEligibility$inboundSchema, CustomerEntityEnv, CustomerEntityEnv$inboundSchema, CustomerEnv, CustomerEnv$inboundSchema, CustomerExpand, CustomerExpand$outboundSchema, type CustomerFeature, CustomerFeature$inboundSchema, type CustomerFilter, CustomerFilter$inboundSchema, CustomerFlagsType, CustomerFlagsType$inboundSchema, CustomerLimitType, CustomerLimitType$inboundSchema, type CustomerModelMarkups, CustomerModelMarkups$inboundSchema, type CustomerOverageAllowed, CustomerOverageAllowed$inboundSchema, type CustomerProviderMarkups, CustomerProviderMarkups$inboundSchema, type CustomerPurchaseLimit1, CustomerPurchaseLimit1$inboundSchema, type CustomerPurchaseLimit2, CustomerPurchaseLimit2$inboundSchema, CustomerPurchaseLimitInterval1, CustomerPurchaseLimitInterval1$inboundSchema, CustomerPurchaseLimitInterval2, CustomerPurchaseLimitInterval2$inboundSchema, type CustomerPurchaseLimitUnion, CustomerPurchaseLimitUnion$inboundSchema, type CustomerSpendLimit, CustomerSpendLimit$inboundSchema, CustomerStatus, CustomerStatus$inboundSchema, CustomerThresholdType, CustomerThresholdType$inboundSchema, type CustomerUsageAlert, CustomerUsageAlert$inboundSchema, type CustomerUsageLimit, CustomerUsageLimit$inboundSchema, CustomerUsageLimitInterval, CustomerUsageLimitInterval$inboundSchema, type Customize, Customize$inboundSchema, type Deductions, Deductions$inboundSchema, type DeleteBalanceGlobals, DeleteBalanceInterval, DeleteBalanceInterval$outboundSchema, type DeleteBalanceParams, type DeleteBalanceParams$Outbound, DeleteBalanceParams$outboundSchema, type DeleteBalanceResponse, DeleteBalanceResponse$inboundSchema, type DeleteCustomerGlobals, type DeleteCustomerParams, type DeleteCustomerParams$Outbound, DeleteCustomerParams$outboundSchema, type DeleteCustomerResponse, DeleteCustomerResponse$inboundSchema, type DeleteEntityGlobals, type DeleteEntityParams, type DeleteEntityParams$Outbound, DeleteEntityParams$outboundSchema, type DeleteEntityResponse, DeleteEntityResponse$inboundSchema, type DeleteFeatureGlobals, type DeleteFeatureParams, type DeleteFeatureParams$Outbound, DeleteFeatureParams$outboundSchema, type DeleteFeatureResponse, DeleteFeatureResponse$inboundSchema, type DeletePlanGlobals, type DeletePlanParams, type DeletePlanParams$Outbound, DeletePlanParams$outboundSchema, type DeletePlanResponse, DeletePlanResponse$inboundSchema, type DfuFlashParams, type DfuFlashParams$Outbound, DfuFlashParams$outboundSchema, type DfuFlashResult, DfuFlashResult$inboundSchema, type Discount, Discount$inboundSchema, DurationType, DurationType$inboundSchema, type EntitlementsGranted, EntitlementsGranted$inboundSchema, type Entity, Entity$inboundSchema, type EventsAggregateParams, type EventsAggregateParams$Outbound, EventsAggregateParams$outboundSchema, type EventsListParams, type EventsListParams$Outbound, EventsListParams$outboundSchema, type Expiry, Expiry$inboundSchema, ExpiryType, ExpiryType$inboundSchema, type FeatureGrant, FeatureGrant$inboundSchema, type FeatureGrantPromoCode, FeatureGrantPromoCode$inboundSchema, FeatureType1, FeatureType1$inboundSchema, FeatureType2, FeatureType2$inboundSchema, type Fetcher, type FinalizeBalanceParams, type FinalizeBalanceParams$Outbound, FinalizeBalanceParams$outboundSchema, FinalizeLockAction, FinalizeLockAction$outboundSchema, type FinalizeLockGlobals, type FinalizeLockResponse, FinalizeLockResponse$inboundSchema, type FinalizeLockResponseBody1, FinalizeLockResponseBody1$inboundSchema, type FinalizeLockResponseBody2, FinalizeLockResponseBody2$inboundSchema, type Flag1, Flag1$inboundSchema, type Flag2, Flag2$inboundSchema, type FlagDisplay1, FlagDisplay1$inboundSchema, type FlagDisplay2, FlagDisplay2$inboundSchema, FlagType1, FlagType1$inboundSchema, FlagType2, FlagType2$inboundSchema, type Flags, Flags$inboundSchema, type Flashed, Flashed$inboundSchema, type FreeTrial, FreeTrial$inboundSchema, FreeTrialDuration1, FreeTrialDuration1$inboundSchema, FreeTrialDuration2, FreeTrialDuration2$inboundSchema, type FreeTrialParams, FreeTrialParams$inboundSchema, type FreeTrialRequest, type FreeTrialRequest$Outbound, FreeTrialRequest$outboundSchema, type GetCustomerAutoTopup, GetCustomerAutoTopup$inboundSchema, GetCustomerAutoTopupSource, GetCustomerAutoTopupSource$inboundSchema, type GetCustomerBillingControls, GetCustomerBillingControls$inboundSchema, type GetCustomerConfig, GetCustomerConfig$inboundSchema, type GetCustomerCreditSchema, GetCustomerCreditSchema$inboundSchema, type GetCustomerCustomer, GetCustomerCustomer$inboundSchema, type GetCustomerDiscount, GetCustomerDiscount$inboundSchema, GetCustomerDiscountType, GetCustomerDiscountType$inboundSchema, type GetCustomerDisplay, GetCustomerDisplay$inboundSchema, GetCustomerDurationType, GetCustomerDurationType$inboundSchema, type GetCustomerEntity, GetCustomerEntity$inboundSchema, GetCustomerEntityEnv, GetCustomerEntityEnv$inboundSchema, GetCustomerEnv, GetCustomerEnv$inboundSchema, type GetCustomerFeature, GetCustomerFeature$inboundSchema, type GetCustomerFilter, GetCustomerFilter$inboundSchema, type GetCustomerFlags, GetCustomerFlags$inboundSchema, GetCustomerFlagsType, GetCustomerFlagsType$inboundSchema, type GetCustomerGlobals, type GetCustomerInvoice, GetCustomerInvoice$inboundSchema, GetCustomerLimitType, GetCustomerLimitType$inboundSchema, type GetCustomerModelMarkups, GetCustomerModelMarkups$inboundSchema, type GetCustomerOverageAllowed, GetCustomerOverageAllowed$inboundSchema, GetCustomerOverageAllowedSource, GetCustomerOverageAllowedSource$inboundSchema, type GetCustomerParams, type GetCustomerParams$Outbound, GetCustomerParams$outboundSchema, GetCustomerProcessorType, GetCustomerProcessorType$inboundSchema, type GetCustomerProcessors, GetCustomerProcessors$inboundSchema, type GetCustomerProviderMarkups, GetCustomerProviderMarkups$inboundSchema, type GetCustomerPurchase, GetCustomerPurchase$inboundSchema, type GetCustomerPurchaseLimit1, GetCustomerPurchaseLimit1$inboundSchema, type GetCustomerPurchaseLimit2, GetCustomerPurchaseLimit2$inboundSchema, GetCustomerPurchaseLimitInterval1, GetCustomerPurchaseLimitInterval1$inboundSchema, GetCustomerPurchaseLimitInterval2, GetCustomerPurchaseLimitInterval2$inboundSchema, type GetCustomerPurchaseLimitUnion, GetCustomerPurchaseLimitUnion$inboundSchema, GetCustomerPurchaseScope, GetCustomerPurchaseScope$inboundSchema, type GetCustomerReferral, GetCustomerReferral$inboundSchema, type GetCustomerResponse, GetCustomerResponse$inboundSchema, type GetCustomerRevenuecat, GetCustomerRevenuecat$inboundSchema, type GetCustomerRewards, GetCustomerRewards$inboundSchema, type GetCustomerSpendLimit, GetCustomerSpendLimit$inboundSchema, GetCustomerSpendLimitSource, GetCustomerSpendLimitSource$inboundSchema, GetCustomerStatus, GetCustomerStatus$inboundSchema, type GetCustomerStripe, GetCustomerStripe$inboundSchema, type GetCustomerSubscription, GetCustomerSubscription$inboundSchema, GetCustomerSubscriptionScope, GetCustomerSubscriptionScope$inboundSchema, GetCustomerThresholdType, GetCustomerThresholdType$inboundSchema, type GetCustomerTrialsUsed, GetCustomerTrialsUsed$inboundSchema, type GetCustomerUsageAlert, GetCustomerUsageAlert$inboundSchema, GetCustomerUsageAlertSource, GetCustomerUsageAlertSource$inboundSchema, type GetCustomerUsageLimit, GetCustomerUsageLimit$inboundSchema, GetCustomerUsageLimitInterval, GetCustomerUsageLimitInterval$inboundSchema, GetCustomerUsageLimitSource, GetCustomerUsageLimitSource$inboundSchema, type GetCustomerVercel, GetCustomerVercel$inboundSchema, type GetEntityBillingControls, GetEntityBillingControls$inboundSchema, type GetEntityCreditSchema, GetEntityCreditSchema$inboundSchema, type GetEntityDisplay, GetEntityDisplay$inboundSchema, GetEntityEnv, GetEntityEnv$inboundSchema, type GetEntityFeature, GetEntityFeature$inboundSchema, type GetEntityFilter, GetEntityFilter$inboundSchema, type GetEntityFlags, GetEntityFlags$inboundSchema, type GetEntityGlobals, GetEntityInterval, GetEntityInterval$inboundSchema, type GetEntityInvoice, GetEntityInvoice$inboundSchema, GetEntityLimitType, GetEntityLimitType$inboundSchema, type GetEntityModelMarkups, GetEntityModelMarkups$inboundSchema, type GetEntityOverageAllowed, GetEntityOverageAllowed$inboundSchema, GetEntityOverageAllowedSource, GetEntityOverageAllowedSource$inboundSchema, type GetEntityParams, type GetEntityParams$Outbound, GetEntityParams$outboundSchema, GetEntityProcessorType, GetEntityProcessorType$inboundSchema, type GetEntityProviderMarkups, GetEntityProviderMarkups$inboundSchema, type GetEntityPurchase, GetEntityPurchase$inboundSchema, GetEntityPurchaseScope, GetEntityPurchaseScope$inboundSchema, type GetEntityResponse, GetEntityResponse$inboundSchema, type GetEntitySpendLimit, GetEntitySpendLimit$inboundSchema, GetEntitySpendLimitSource, GetEntitySpendLimitSource$inboundSchema, GetEntityStatus, GetEntityStatus$inboundSchema, type GetEntitySubscription, GetEntitySubscription$inboundSchema, GetEntitySubscriptionScope, GetEntitySubscriptionScope$inboundSchema, GetEntityThresholdType, GetEntityThresholdType$inboundSchema, GetEntityType, GetEntityType$inboundSchema, type GetEntityUsageAlert, GetEntityUsageAlert$inboundSchema, GetEntityUsageAlertSource, GetEntityUsageAlertSource$inboundSchema, type GetEntityUsageLimit, GetEntityUsageLimit$inboundSchema, GetEntityUsageLimitSource, GetEntityUsageLimitSource$inboundSchema, type GetFeatureCreditSchema, GetFeatureCreditSchema$inboundSchema, type GetFeatureDisplay, GetFeatureDisplay$inboundSchema, type GetFeatureGlobals, type GetFeatureModelMarkups, GetFeatureModelMarkups$inboundSchema, type GetFeatureParams, type GetFeatureParams$Outbound, GetFeatureParams$outboundSchema, type GetFeatureProviderMarkups, GetFeatureProviderMarkups$inboundSchema, type GetFeatureResponse, GetFeatureResponse$inboundSchema, GetFeatureType, GetFeatureType$inboundSchema, type GetOrCreateCustomerAutoTopup, type GetOrCreateCustomerAutoTopup$Outbound, GetOrCreateCustomerAutoTopup$outboundSchema, type GetOrCreateCustomerBillingControls, type GetOrCreateCustomerBillingControls$Outbound, GetOrCreateCustomerBillingControls$outboundSchema, type GetOrCreateCustomerConfig, type GetOrCreateCustomerConfig$Outbound, GetOrCreateCustomerConfig$outboundSchema, type GetOrCreateCustomerFilter, type GetOrCreateCustomerFilter$Outbound, GetOrCreateCustomerFilter$outboundSchema, type GetOrCreateCustomerGlobals, GetOrCreateCustomerLimitType, GetOrCreateCustomerLimitType$outboundSchema, type GetOrCreateCustomerOverageAllowed, type GetOrCreateCustomerOverageAllowed$Outbound, GetOrCreateCustomerOverageAllowed$outboundSchema, type GetOrCreateCustomerParams, type GetOrCreateCustomerParams$Outbound, GetOrCreateCustomerParams$outboundSchema, type GetOrCreateCustomerProperties, type GetOrCreateCustomerProperties$Outbound, GetOrCreateCustomerProperties$outboundSchema, type GetOrCreateCustomerPurchaseLimit, type GetOrCreateCustomerPurchaseLimit$Outbound, GetOrCreateCustomerPurchaseLimit$outboundSchema, GetOrCreateCustomerPurchaseLimitInterval, GetOrCreateCustomerPurchaseLimitInterval$outboundSchema, type GetOrCreateCustomerSpendLimit, type GetOrCreateCustomerSpendLimit$Outbound, GetOrCreateCustomerSpendLimit$outboundSchema, GetOrCreateCustomerThresholdType, GetOrCreateCustomerThresholdType$outboundSchema, type GetOrCreateCustomerUsageAlert, type GetOrCreateCustomerUsageAlert$Outbound, GetOrCreateCustomerUsageAlert$outboundSchema, type GetOrCreateCustomerUsageLimit, type GetOrCreateCustomerUsageLimit$Outbound, GetOrCreateCustomerUsageLimit$outboundSchema, GetOrCreateCustomerUsageLimitInterval, GetOrCreateCustomerUsageLimitInterval$outboundSchema, GetPlanAddItemBillingMethod, GetPlanAddItemBillingMethod$inboundSchema, GetPlanAddItemPriceInterval, GetPlanAddItemPriceInterval$inboundSchema, GetPlanAddItemResetInterval, GetPlanAddItemResetInterval$inboundSchema, GetPlanAttachAction, GetPlanAttachAction$inboundSchema, type GetPlanAutoTopup, GetPlanAutoTopup$inboundSchema, type GetPlanBasePrice, GetPlanBasePrice$inboundSchema, type GetPlanBillingControls, GetPlanBillingControls$inboundSchema, type GetPlanConfig, GetPlanConfig$inboundSchema, type GetPlanCreditSchema, GetPlanCreditSchema$inboundSchema, type GetPlanCustomerEligibility, GetPlanCustomerEligibility$inboundSchema, type GetPlanCustomize, GetPlanCustomize$inboundSchema, GetPlanDurationType, GetPlanDurationType$inboundSchema, GetPlanEnv, GetPlanEnv$inboundSchema, type GetPlanFeature, GetPlanFeature$inboundSchema, type GetPlanFeatureDisplay, GetPlanFeatureDisplay$inboundSchema, type GetPlanFilter, GetPlanFilter$inboundSchema, type GetPlanFreeTrial, GetPlanFreeTrial$inboundSchema, type GetPlanFreeTrialParams, GetPlanFreeTrialParams$inboundSchema, type GetPlanGlobals, GetPlanIntervalRemoveItemEnum1, GetPlanIntervalRemoveItemEnum1$inboundSchema, GetPlanIntervalRemoveItemEnum2, GetPlanIntervalRemoveItemEnum2$inboundSchema, type GetPlanIntervalUnion, GetPlanIntervalUnion$inboundSchema, type GetPlanItem, GetPlanItem$inboundSchema, GetPlanItemBillingMethod, GetPlanItemBillingMethod$inboundSchema, type GetPlanItemDisplay, GetPlanItemDisplay$inboundSchema, GetPlanItemExpiryDurationType, GetPlanItemExpiryDurationType$inboundSchema, type GetPlanItemPrice, GetPlanItemPrice$inboundSchema, type GetPlanItemReset, GetPlanItemReset$inboundSchema, type GetPlanItemRollover, GetPlanItemRollover$inboundSchema, type GetPlanItemTier, GetPlanItemTier$inboundSchema, GetPlanItemTierBehavior, GetPlanItemTierBehavior$inboundSchema, type GetPlanItemTo, GetPlanItemTo$inboundSchema, GetPlanLimitType, GetPlanLimitType$inboundSchema, GetPlanOnDecrease, GetPlanOnDecrease$inboundSchema, GetPlanOnEnd, GetPlanOnEnd$inboundSchema, GetPlanOnIncrease, GetPlanOnIncrease$inboundSchema, type GetPlanOverageAllowed, GetPlanOverageAllowed$inboundSchema, type GetPlanParams, type GetPlanParams$Outbound, GetPlanParams$outboundSchema, type GetPlanPlanItem, GetPlanPlanItem$inboundSchema, type GetPlanPlanItemFilter, GetPlanPlanItemFilter$inboundSchema, type GetPlanPrice, GetPlanPrice$inboundSchema, type GetPlanPriceDisplay, GetPlanPriceDisplay$inboundSchema, GetPlanPriceInterval, GetPlanPriceInterval$inboundSchema, GetPlanPriceItemInterval, GetPlanPriceItemInterval$inboundSchema, GetPlanPriceVariantDetailsInterval, GetPlanPriceVariantDetailsInterval$inboundSchema, type GetPlanProration, GetPlanProration$inboundSchema, type GetPlanPurchaseLimit, GetPlanPurchaseLimit$inboundSchema, GetPlanPurchaseLimitInterval, GetPlanPurchaseLimitInterval$inboundSchema, GetPlanRemoveItemBillingMethod, GetPlanRemoveItemBillingMethod$inboundSchema, GetPlanResetItemInterval, GetPlanResetItemInterval$inboundSchema, type GetPlanResponse, GetPlanResponse$inboundSchema, type GetPlanSpendLimit, GetPlanSpendLimit$inboundSchema, GetPlanStatus, GetPlanStatus$inboundSchema, GetPlanThresholdType, GetPlanThresholdType$inboundSchema, GetPlanType, GetPlanType$inboundSchema, type GetPlanUsageAlert, GetPlanUsageAlert$inboundSchema, type GetPlanUsageLimit, GetPlanUsageLimit$inboundSchema, GetPlanUsageLimitInterval, GetPlanUsageLimitInterval$inboundSchema, type GetPlanVariantDetails, GetPlanVariantDetails$inboundSchema, type GetPlanVariantDetailsAutoTopup, GetPlanVariantDetailsAutoTopup$inboundSchema, type GetPlanVariantDetailsBillingControls, GetPlanVariantDetailsBillingControls$inboundSchema, GetPlanVariantDetailsDurationType, GetPlanVariantDetailsDurationType$inboundSchema, GetPlanVariantDetailsExpiryDurationType, GetPlanVariantDetailsExpiryDurationType$inboundSchema, type GetPlanVariantDetailsFilter, GetPlanVariantDetailsFilter$inboundSchema, GetPlanVariantDetailsLimitType, GetPlanVariantDetailsLimitType$inboundSchema, GetPlanVariantDetailsOnEnd, GetPlanVariantDetailsOnEnd$inboundSchema, type GetPlanVariantDetailsOverageAllowed, GetPlanVariantDetailsOverageAllowed$inboundSchema, type GetPlanVariantDetailsPrice, GetPlanVariantDetailsPrice$inboundSchema, type GetPlanVariantDetailsPurchaseLimit, GetPlanVariantDetailsPurchaseLimit$inboundSchema, GetPlanVariantDetailsPurchaseLimitInterval, GetPlanVariantDetailsPurchaseLimitInterval$inboundSchema, type GetPlanVariantDetailsReset, GetPlanVariantDetailsReset$inboundSchema, type GetPlanVariantDetailsRollover, GetPlanVariantDetailsRollover$inboundSchema, type GetPlanVariantDetailsSpendLimit, GetPlanVariantDetailsSpendLimit$inboundSchema, GetPlanVariantDetailsThresholdType, GetPlanVariantDetailsThresholdType$inboundSchema, type GetPlanVariantDetailsTier, GetPlanVariantDetailsTier$inboundSchema, GetPlanVariantDetailsTierBehavior, GetPlanVariantDetailsTierBehavior$inboundSchema, type GetPlanVariantDetailsTo, GetPlanVariantDetailsTo$inboundSchema, type GetPlanVariantDetailsUsageAlert, GetPlanVariantDetailsUsageAlert$inboundSchema, type GetPlanVariantDetailsUsageLimit, GetPlanVariantDetailsUsageLimit$inboundSchema, GetPlanVariantDetailsUsageLimitInterval, GetPlanVariantDetailsUsageLimitInterval$inboundSchema, type GetRevenueCatKeysApp, GetRevenueCatKeysApp$inboundSchema, GetRevenueCatKeysEnv, GetRevenueCatKeysEnv$outboundSchema, type GetRevenueCatKeysGlobals, type GetRevenueCatKeysParams, type GetRevenueCatKeysParams$Outbound, GetRevenueCatKeysParams$outboundSchema, type GetRevenueCatKeysResponse, GetRevenueCatKeysResponse$inboundSchema, type Grant, Grant$inboundSchema, HTTPClient, HTTPClientError, type HTTPClientOptions, type ImportBalance, type ImportBalance$Outbound, ImportBalance$outboundSchema, ImportBillingBehavior, ImportBillingBehavior$outboundSchema, type ImportCustomerData, type ImportCustomerData$Outbound, ImportCustomerData$outboundSchema, type ImportFeatureQuantity, type ImportFeatureQuantity$Outbound, ImportFeatureQuantity$outboundSchema, type ImportFilter, type ImportFilter$Outbound, ImportFilter$outboundSchema, type ImportGlobals, ImportInterval, ImportInterval$outboundSchema, type ImportPlan, type ImportPlan$Outbound, ImportPlan$outboundSchema, type ImportProcessor, type ImportProcessor$Outbound, ImportProcessor$outboundSchema, ImportStatus, ImportStatus$outboundSchema, ImportType, ImportType$outboundSchema, type IncludedUsage1, IncludedUsage1$inboundSchema, type IncludedUsage2, IncludedUsage2$inboundSchema, Intent, Intent$inboundSchema, IntervalVariantRemoveItemEnum1, IntervalVariantRemoveItemEnum1$outboundSchema, IntervalVariantRemoveItemEnum2, IntervalVariantRemoveItemEnum2$outboundSchema, InvalidRequestError, type Invoice, Invoice$inboundSchema, type Item, Item$inboundSchema, ItemExpiryDurationType, ItemExpiryDurationType$inboundSchema, type Link, type Link$Outbound, Link$outboundSchema, LinkRevenueCatEnv, LinkRevenueCatEnv$outboundSchema, type LinkRevenueCatGlobals, type LinkRevenueCatParams, type LinkRevenueCatParams$Outbound, LinkRevenueCatParams$outboundSchema, type LinkRevenueCatResponse, LinkRevenueCatResponse$inboundSchema, type ListCustomersAutoTopup, ListCustomersAutoTopup$inboundSchema, ListCustomersAutoTopupSource, ListCustomersAutoTopupSource$inboundSchema, type ListCustomersBillingControls, ListCustomersBillingControls$inboundSchema, type ListCustomersConfig, ListCustomersConfig$inboundSchema, type ListCustomersCreditSchema, ListCustomersCreditSchema$inboundSchema, type ListCustomersDisplay, ListCustomersDisplay$inboundSchema, ListCustomersEnv, ListCustomersEnv$inboundSchema, type ListCustomersFeature, ListCustomersFeature$inboundSchema, type ListCustomersFilter, ListCustomersFilter$inboundSchema, type ListCustomersFlags, ListCustomersFlags$inboundSchema, type ListCustomersGlobals, ListCustomersLimitType, ListCustomersLimitType$inboundSchema, type ListCustomersList, ListCustomersList$inboundSchema, type ListCustomersModelMarkups, ListCustomersModelMarkups$inboundSchema, type ListCustomersOverageAllowed, ListCustomersOverageAllowed$inboundSchema, ListCustomersOverageAllowedSource, ListCustomersOverageAllowedSource$inboundSchema, type ListCustomersParams, type ListCustomersParams$Outbound, ListCustomersParams$outboundSchema, type ListCustomersPlan, type ListCustomersPlan$Outbound, ListCustomersPlan$outboundSchema, ListCustomersProcessor, ListCustomersProcessor$outboundSchema, type ListCustomersProcessors, ListCustomersProcessors$inboundSchema, type ListCustomersProviderMarkups, ListCustomersProviderMarkups$inboundSchema, type ListCustomersPurchase, ListCustomersPurchase$inboundSchema, type ListCustomersPurchaseLimit1, ListCustomersPurchaseLimit1$inboundSchema, type ListCustomersPurchaseLimit2, ListCustomersPurchaseLimit2$inboundSchema, ListCustomersPurchaseLimitInterval1, ListCustomersPurchaseLimitInterval1$inboundSchema, ListCustomersPurchaseLimitInterval2, ListCustomersPurchaseLimitInterval2$inboundSchema, type ListCustomersPurchaseLimitUnion, ListCustomersPurchaseLimitUnion$inboundSchema, ListCustomersPurchaseScope, ListCustomersPurchaseScope$inboundSchema, type ListCustomersResponse, ListCustomersResponse$inboundSchema, type ListCustomersRevenuecat, ListCustomersRevenuecat$inboundSchema, type ListCustomersSpendLimit, ListCustomersSpendLimit$inboundSchema, ListCustomersSpendLimitSource, ListCustomersSpendLimitSource$inboundSchema, ListCustomersStatus, ListCustomersStatus$inboundSchema, type ListCustomersStripe, ListCustomersStripe$inboundSchema, type ListCustomersSubscription, ListCustomersSubscription$inboundSchema, ListCustomersSubscriptionScope, ListCustomersSubscriptionScope$inboundSchema, ListCustomersSubscriptionStatus, ListCustomersSubscriptionStatus$outboundSchema, ListCustomersThresholdType, ListCustomersThresholdType$inboundSchema, ListCustomersType, ListCustomersType$inboundSchema, type ListCustomersUsageAlert, ListCustomersUsageAlert$inboundSchema, ListCustomersUsageAlertSource, ListCustomersUsageAlertSource$inboundSchema, type ListCustomersUsageLimit, ListCustomersUsageLimit$inboundSchema, ListCustomersUsageLimitInterval, ListCustomersUsageLimitInterval$inboundSchema, ListCustomersUsageLimitSource, ListCustomersUsageLimitSource$inboundSchema, type ListCustomersVercel, ListCustomersVercel$inboundSchema, type ListEntitiesBillingControls, ListEntitiesBillingControls$inboundSchema, type ListEntitiesCreditSchema, ListEntitiesCreditSchema$inboundSchema, type ListEntitiesDisplay, ListEntitiesDisplay$inboundSchema, ListEntitiesEnv, ListEntitiesEnv$inboundSchema, type ListEntitiesFeature, ListEntitiesFeature$inboundSchema, type ListEntitiesFilter, ListEntitiesFilter$inboundSchema, type ListEntitiesFlags, ListEntitiesFlags$inboundSchema, type ListEntitiesGlobals, ListEntitiesInterval, ListEntitiesInterval$inboundSchema, type ListEntitiesInvoice, ListEntitiesInvoice$inboundSchema, ListEntitiesLimitType, ListEntitiesLimitType$inboundSchema, type ListEntitiesList, ListEntitiesList$inboundSchema, type ListEntitiesModelMarkups, ListEntitiesModelMarkups$inboundSchema, type ListEntitiesOverageAllowed, ListEntitiesOverageAllowed$inboundSchema, ListEntitiesOverageAllowedSource, ListEntitiesOverageAllowedSource$inboundSchema, type ListEntitiesParams, type ListEntitiesParams$Outbound, ListEntitiesParams$outboundSchema, type ListEntitiesPlan, type ListEntitiesPlan$Outbound, ListEntitiesPlan$outboundSchema, ListEntitiesProcessor, ListEntitiesProcessor$outboundSchema, ListEntitiesProcessorType, ListEntitiesProcessorType$inboundSchema, type ListEntitiesProviderMarkups, ListEntitiesProviderMarkups$inboundSchema, type ListEntitiesPurchase, ListEntitiesPurchase$inboundSchema, ListEntitiesPurchaseScope, ListEntitiesPurchaseScope$inboundSchema, type ListEntitiesResponse, ListEntitiesResponse$inboundSchema, type ListEntitiesSpendLimit, ListEntitiesSpendLimit$inboundSchema, ListEntitiesSpendLimitSource, ListEntitiesSpendLimitSource$inboundSchema, ListEntitiesStatus, ListEntitiesStatus$inboundSchema, type ListEntitiesSubscription, ListEntitiesSubscription$inboundSchema, ListEntitiesSubscriptionScope, ListEntitiesSubscriptionScope$inboundSchema, ListEntitiesSubscriptionStatus, ListEntitiesSubscriptionStatus$outboundSchema, ListEntitiesThresholdType, ListEntitiesThresholdType$inboundSchema, ListEntitiesType, ListEntitiesType$inboundSchema, type ListEntitiesUsageAlert, ListEntitiesUsageAlert$inboundSchema, ListEntitiesUsageAlertSource, ListEntitiesUsageAlertSource$inboundSchema, type ListEntitiesUsageLimit, ListEntitiesUsageLimit$inboundSchema, ListEntitiesUsageLimitSource, ListEntitiesUsageLimitSource$inboundSchema, type ListEventsCustomRange, type ListEventsCustomRange$Outbound, ListEventsCustomRange$outboundSchema, type ListEventsFeatureId, type ListEventsFeatureId$Outbound, ListEventsFeatureId$outboundSchema, type ListEventsGlobals, ListEventsIntervalEnum, ListEventsIntervalEnum$inboundSchema, type ListEventsIntervalUnion, ListEventsIntervalUnion$inboundSchema, type ListEventsList, ListEventsList$inboundSchema, type ListEventsReset, ListEventsReset$inboundSchema, type ListEventsResponse, ListEventsResponse$inboundSchema, type ListFeaturesCreditSchema, ListFeaturesCreditSchema$inboundSchema, type ListFeaturesDisplay, ListFeaturesDisplay$inboundSchema, type ListFeaturesGlobals, type ListFeaturesList, ListFeaturesList$inboundSchema, type ListFeaturesModelMarkups, ListFeaturesModelMarkups$inboundSchema, type ListFeaturesProviderMarkups, ListFeaturesProviderMarkups$inboundSchema, type ListFeaturesRequest, type ListFeaturesRequest$Outbound, ListFeaturesRequest$outboundSchema, type ListFeaturesResponse, ListFeaturesResponse$inboundSchema, ListFeaturesType, ListFeaturesType$inboundSchema, ListPlansAddItemBillingMethod, ListPlansAddItemBillingMethod$inboundSchema, ListPlansAddItemPriceInterval, ListPlansAddItemPriceInterval$inboundSchema, ListPlansAddItemResetInterval, ListPlansAddItemResetInterval$inboundSchema, ListPlansAttachAction, ListPlansAttachAction$inboundSchema, type ListPlansAutoTopup, ListPlansAutoTopup$inboundSchema, type ListPlansBasePrice, ListPlansBasePrice$inboundSchema, type ListPlansBillingControls, ListPlansBillingControls$inboundSchema, type ListPlansConfig, ListPlansConfig$inboundSchema, type ListPlansCreditSchema, ListPlansCreditSchema$inboundSchema, type ListPlansCustomerEligibility, ListPlansCustomerEligibility$inboundSchema, type ListPlansCustomize, ListPlansCustomize$inboundSchema, ListPlansDurationType, ListPlansDurationType$inboundSchema, ListPlansEnv, ListPlansEnv$inboundSchema, type ListPlansFeature, ListPlansFeature$inboundSchema, type ListPlansFeatureDisplay, ListPlansFeatureDisplay$inboundSchema, type ListPlansFilter, ListPlansFilter$inboundSchema, type ListPlansFreeTrial, ListPlansFreeTrial$inboundSchema, type ListPlansFreeTrialParams, ListPlansFreeTrialParams$inboundSchema, type ListPlansGlobals, ListPlansIntervalRemoveItemEnum1, ListPlansIntervalRemoveItemEnum1$inboundSchema, ListPlansIntervalRemoveItemEnum2, ListPlansIntervalRemoveItemEnum2$inboundSchema, type ListPlansIntervalUnion, ListPlansIntervalUnion$inboundSchema, type ListPlansItem, ListPlansItem$inboundSchema, ListPlansItemBillingMethod, ListPlansItemBillingMethod$inboundSchema, type ListPlansItemDisplay, ListPlansItemDisplay$inboundSchema, ListPlansItemExpiryDurationType, ListPlansItemExpiryDurationType$inboundSchema, type ListPlansItemPrice, ListPlansItemPrice$inboundSchema, type ListPlansItemReset, ListPlansItemReset$inboundSchema, type ListPlansItemRollover, ListPlansItemRollover$inboundSchema, type ListPlansItemTier, ListPlansItemTier$inboundSchema, ListPlansItemTierBehavior, ListPlansItemTierBehavior$inboundSchema, ListPlansLimitType, ListPlansLimitType$inboundSchema, type ListPlansList, ListPlansList$inboundSchema, ListPlansOnDecrease, ListPlansOnDecrease$inboundSchema, ListPlansOnEnd, ListPlansOnEnd$inboundSchema, ListPlansOnIncrease, ListPlansOnIncrease$inboundSchema, type ListPlansOverageAllowed, ListPlansOverageAllowed$inboundSchema, type ListPlansParams, type ListPlansParams$Outbound, ListPlansParams$outboundSchema, type ListPlansPlanItem, ListPlansPlanItem$inboundSchema, type ListPlansPlanItemFilter, ListPlansPlanItemFilter$inboundSchema, type ListPlansPrice, ListPlansPrice$inboundSchema, type ListPlansPriceDisplay, ListPlansPriceDisplay$inboundSchema, ListPlansPriceInterval, ListPlansPriceInterval$inboundSchema, ListPlansPriceItemInterval, ListPlansPriceItemInterval$inboundSchema, ListPlansPriceVariantDetailsInterval, ListPlansPriceVariantDetailsInterval$inboundSchema, type ListPlansProration, ListPlansProration$inboundSchema, type ListPlansPurchaseLimit, ListPlansPurchaseLimit$inboundSchema, ListPlansPurchaseLimitInterval, ListPlansPurchaseLimitInterval$inboundSchema, ListPlansRemoveItemBillingMethod, ListPlansRemoveItemBillingMethod$inboundSchema, ListPlansResetItemInterval, ListPlansResetItemInterval$inboundSchema, type ListPlansResponse, ListPlansResponse$inboundSchema, type ListPlansSpendLimit, ListPlansSpendLimit$inboundSchema, ListPlansStatus, ListPlansStatus$inboundSchema, ListPlansThresholdType, ListPlansThresholdType$inboundSchema, type ListPlansTo, ListPlansTo$inboundSchema, ListPlansType, ListPlansType$inboundSchema, type ListPlansUsageAlert, ListPlansUsageAlert$inboundSchema, type ListPlansUsageLimit, ListPlansUsageLimit$inboundSchema, ListPlansUsageLimitInterval, ListPlansUsageLimitInterval$inboundSchema, type ListPlansVariantDetails, ListPlansVariantDetails$inboundSchema, type ListPlansVariantDetailsAutoTopup, ListPlansVariantDetailsAutoTopup$inboundSchema, type ListPlansVariantDetailsBillingControls, ListPlansVariantDetailsBillingControls$inboundSchema, ListPlansVariantDetailsDurationType, ListPlansVariantDetailsDurationType$inboundSchema, ListPlansVariantDetailsExpiryDurationType, ListPlansVariantDetailsExpiryDurationType$inboundSchema, type ListPlansVariantDetailsFilter, ListPlansVariantDetailsFilter$inboundSchema, ListPlansVariantDetailsLimitType, ListPlansVariantDetailsLimitType$inboundSchema, ListPlansVariantDetailsOnEnd, ListPlansVariantDetailsOnEnd$inboundSchema, type ListPlansVariantDetailsOverageAllowed, ListPlansVariantDetailsOverageAllowed$inboundSchema, type ListPlansVariantDetailsPrice, ListPlansVariantDetailsPrice$inboundSchema, type ListPlansVariantDetailsPurchaseLimit, ListPlansVariantDetailsPurchaseLimit$inboundSchema, ListPlansVariantDetailsPurchaseLimitInterval, ListPlansVariantDetailsPurchaseLimitInterval$inboundSchema, type ListPlansVariantDetailsReset, ListPlansVariantDetailsReset$inboundSchema, type ListPlansVariantDetailsRollover, ListPlansVariantDetailsRollover$inboundSchema, type ListPlansVariantDetailsSpendLimit, ListPlansVariantDetailsSpendLimit$inboundSchema, ListPlansVariantDetailsThresholdType, ListPlansVariantDetailsThresholdType$inboundSchema, type ListPlansVariantDetailsTier, ListPlansVariantDetailsTier$inboundSchema, ListPlansVariantDetailsTierBehavior, ListPlansVariantDetailsTierBehavior$inboundSchema, type ListPlansVariantDetailsUsageAlert, ListPlansVariantDetailsUsageAlert$inboundSchema, type ListPlansVariantDetailsUsageLimit, ListPlansVariantDetailsUsageLimit$inboundSchema, ListPlansVariantDetailsUsageLimitInterval, ListPlansVariantDetailsUsageLimitInterval$inboundSchema, type ListRewardsDuration, ListRewardsDuration$inboundSchema, type ListRewardsGlobals, type ListRewardsResponse, ListRewardsResponse$inboundSchema, type Migration, type Migration$Outbound, Migration$outboundSchema, type MintKeyGlobals, type MintKeyParams, type MintKeyParams$Outbound, MintKeyParams$outboundSchema, type MintKeyResponse, MintKeyResponse$inboundSchema, type MultiAttachAttachDiscount, type MultiAttachAttachDiscount$Outbound, MultiAttachAttachDiscount$outboundSchema, type MultiAttachBasePrice, type MultiAttachBasePrice$Outbound, MultiAttachBasePrice$outboundSchema, type MultiAttachBillingControls, type MultiAttachBillingControls$Outbound, MultiAttachBillingControls$outboundSchema, MultiAttachBillingMethod, MultiAttachBillingMethod$outboundSchema, MultiAttachCode, MultiAttachCode$inboundSchema, type MultiAttachCustomize, type MultiAttachCustomize$Outbound, MultiAttachCustomize$outboundSchema, MultiAttachDurationType, MultiAttachDurationType$outboundSchema, type MultiAttachEntityData, type MultiAttachEntityData$Outbound, MultiAttachEntityData$outboundSchema, MultiAttachEntityDataInterval, MultiAttachEntityDataInterval$outboundSchema, MultiAttachExpiryDurationType, MultiAttachExpiryDurationType$outboundSchema, type MultiAttachFeatureQuantity, type MultiAttachFeatureQuantity$Outbound, MultiAttachFeatureQuantity$outboundSchema, type MultiAttachFilter, type MultiAttachFilter$Outbound, MultiAttachFilter$outboundSchema, type MultiAttachFreeTrialParams, type MultiAttachFreeTrialParams$Outbound, MultiAttachFreeTrialParams$outboundSchema, type MultiAttachGlobals, type MultiAttachInvoice, MultiAttachInvoice$inboundSchema, type MultiAttachInvoiceMode, type MultiAttachInvoiceMode$Outbound, MultiAttachInvoiceMode$outboundSchema, MultiAttachItemPriceInterval, MultiAttachItemPriceInterval$outboundSchema, MultiAttachLimitType, MultiAttachLimitType$outboundSchema, MultiAttachOnDecrease, MultiAttachOnDecrease$outboundSchema, MultiAttachOnEnd, MultiAttachOnEnd$outboundSchema, MultiAttachOnIncrease, MultiAttachOnIncrease$outboundSchema, type MultiAttachOverageAllowed, type MultiAttachOverageAllowed$Outbound, MultiAttachOverageAllowed$outboundSchema, type MultiAttachParams, type MultiAttachParams$Outbound, MultiAttachParams$outboundSchema, type MultiAttachPlan, type MultiAttachPlan$Outbound, MultiAttachPlan$outboundSchema, type MultiAttachPlanItem, type MultiAttachPlanItem$Outbound, MultiAttachPlanItem$outboundSchema, type MultiAttachPrice, type MultiAttachPrice$Outbound, MultiAttachPrice$outboundSchema, MultiAttachPriceInterval, MultiAttachPriceInterval$outboundSchema, type MultiAttachProperties, type MultiAttachProperties$Outbound, MultiAttachProperties$outboundSchema, type MultiAttachProration, type MultiAttachProration$Outbound, MultiAttachProration$outboundSchema, MultiAttachRedirectMode, MultiAttachRedirectMode$outboundSchema, type MultiAttachRequiredAction, MultiAttachRequiredAction$inboundSchema, type MultiAttachReset, type MultiAttachReset$Outbound, MultiAttachReset$outboundSchema, MultiAttachResetInterval, MultiAttachResetInterval$outboundSchema, type MultiAttachResponse, MultiAttachResponse$inboundSchema, type MultiAttachRollover, type MultiAttachRollover$Outbound, MultiAttachRollover$outboundSchema, type MultiAttachSpendLimit, type MultiAttachSpendLimit$Outbound, MultiAttachSpendLimit$outboundSchema, MultiAttachThresholdType, MultiAttachThresholdType$outboundSchema, type MultiAttachTier, type MultiAttachTier$Outbound, MultiAttachTier$outboundSchema, MultiAttachTierBehavior, MultiAttachTierBehavior$outboundSchema, type MultiAttachTo, type MultiAttachTo$Outbound, MultiAttachTo$outboundSchema, type MultiAttachUsageAlert, type MultiAttachUsageAlert$Outbound, MultiAttachUsageAlert$outboundSchema, type MultiAttachUsageLimit, type MultiAttachUsageLimit$Outbound, MultiAttachUsageLimit$outboundSchema, MultiUpdateCancelAction, MultiUpdateCancelAction$outboundSchema, MultiUpdateCode, MultiUpdateCode$inboundSchema, type MultiUpdateGlobals, type MultiUpdateInvoice, MultiUpdateInvoice$inboundSchema, type MultiUpdateParams, type MultiUpdateParams$Outbound, MultiUpdateParams$outboundSchema, type MultiUpdatePreviewResponse, MultiUpdatePreviewResponse$inboundSchema, MultiUpdateProrationBehavior, MultiUpdateProrationBehavior$outboundSchema, type MultiUpdateRequiredAction, MultiUpdateRequiredAction$inboundSchema, type MultiUpdateResponse, MultiUpdateResponse$inboundSchema, type MultiUpdateUpdate, type MultiUpdateUpdate$Outbound, MultiUpdateUpdate$outboundSchema, OnDecrease, OnDecrease$inboundSchema, OnEnd, OnEnd$inboundSchema, OnIncrease, OnIncrease$inboundSchema, type OpenCustomerPortalGlobals, type OpenCustomerPortalParams, type OpenCustomerPortalParams$Outbound, OpenCustomerPortalParams$outboundSchema, type OpenCustomerPortalResponse, OpenCustomerPortalResponse$inboundSchema, OverageAllowedSource, OverageAllowedSource$inboundSchema, type PhaseResponse, PhaseResponse$inboundSchema, type PhaseStart, type PhaseStart$Outbound, PhaseStart$outboundSchema, type PhaseStartUnion, type PhaseStartUnion$Outbound, PhaseStartUnion$outboundSchema, type Plan, Plan$inboundSchema, PlanAddItemBillingMethod, PlanAddItemBillingMethod$inboundSchema, PlanAddItemPriceInterval, PlanAddItemPriceInterval$inboundSchema, PlanAddItemResetInterval, PlanAddItemResetInterval$inboundSchema, type PlanAutoTopup, PlanAutoTopup$inboundSchema, type PlanBillingControls, PlanBillingControls$inboundSchema, type PlanConfig, PlanConfig$inboundSchema, type PlanCreditSchema, PlanCreditSchema$inboundSchema, PlanDurationType, PlanDurationType$inboundSchema, PlanEnv, PlanEnv$inboundSchema, type PlanFeature, PlanFeature$inboundSchema, type PlanFeatureDisplay, PlanFeatureDisplay$inboundSchema, type PlanFilter, PlanFilter$inboundSchema, PlanIntervalRemoveItemEnum1, PlanIntervalRemoveItemEnum1$inboundSchema, PlanIntervalRemoveItemEnum2, PlanIntervalRemoveItemEnum2$inboundSchema, type PlanIntervalUnion, PlanIntervalUnion$inboundSchema, type PlanItem, PlanItem$inboundSchema, PlanItemBillingMethod, PlanItemBillingMethod$inboundSchema, type PlanItemDisplay, PlanItemDisplay$inboundSchema, type PlanItemFilter, PlanItemFilter$inboundSchema, type PlanItemPrice, PlanItemPrice$inboundSchema, type PlanItemReset, PlanItemReset$inboundSchema, type PlanItemRollover, PlanItemRollover$inboundSchema, type PlanItemTier, PlanItemTier$inboundSchema, PlanItemTierBehavior, PlanItemTierBehavior$inboundSchema, type PlanItemTo, PlanItemTo$inboundSchema, PlanLimitType, PlanLimitType$inboundSchema, type PlanOverageAllowed, PlanOverageAllowed$inboundSchema, type PlanPrice, PlanPrice$inboundSchema, type PlanPriceDisplay, PlanPriceDisplay$inboundSchema, PlanPriceInterval, PlanPriceInterval$inboundSchema, PlanPriceItemInterval, PlanPriceItemInterval$inboundSchema, PlanPriceVariantDetailsInterval, PlanPriceVariantDetailsInterval$inboundSchema, type PlanPurchaseLimit, PlanPurchaseLimit$inboundSchema, PlanPurchaseLimitInterval, PlanPurchaseLimitInterval$inboundSchema, PlanRemoveItemBillingMethod, PlanRemoveItemBillingMethod$inboundSchema, PlanResetItemInterval, PlanResetItemInterval$inboundSchema, type PlanSpendLimit, PlanSpendLimit$inboundSchema, PlanStatus, PlanStatus$inboundSchema, PlanThresholdType, PlanThresholdType$inboundSchema, PlanType, PlanType$inboundSchema, type PlanUsageAlert, PlanUsageAlert$inboundSchema, type PlanUsageLimit, PlanUsageLimit$inboundSchema, PlanUsageLimitInterval, PlanUsageLimitInterval$inboundSchema, type PlanVariantDetailsAutoTopup, PlanVariantDetailsAutoTopup$inboundSchema, type PlanVariantDetailsBillingControls, PlanVariantDetailsBillingControls$inboundSchema, PlanVariantDetailsDurationType, PlanVariantDetailsDurationType$inboundSchema, type PlanVariantDetailsFilter, PlanVariantDetailsFilter$inboundSchema, PlanVariantDetailsLimitType, PlanVariantDetailsLimitType$inboundSchema, type PlanVariantDetailsOverageAllowed, PlanVariantDetailsOverageAllowed$inboundSchema, type PlanVariantDetailsPrice, PlanVariantDetailsPrice$inboundSchema, type PlanVariantDetailsPurchaseLimit, PlanVariantDetailsPurchaseLimit$inboundSchema, PlanVariantDetailsPurchaseLimitInterval, PlanVariantDetailsPurchaseLimitInterval$inboundSchema, type PlanVariantDetailsReset, PlanVariantDetailsReset$inboundSchema, type PlanVariantDetailsRollover, PlanVariantDetailsRollover$inboundSchema, type PlanVariantDetailsSpendLimit, PlanVariantDetailsSpendLimit$inboundSchema, PlanVariantDetailsThresholdType, PlanVariantDetailsThresholdType$inboundSchema, type PlanVariantDetailsTier, PlanVariantDetailsTier$inboundSchema, PlanVariantDetailsTierBehavior, PlanVariantDetailsTierBehavior$inboundSchema, type PlanVariantDetailsTo, PlanVariantDetailsTo$inboundSchema, type PlanVariantDetailsUsageAlert, PlanVariantDetailsUsageAlert$inboundSchema, type PlanVariantDetailsUsageLimit, PlanVariantDetailsUsageLimit$inboundSchema, PlanVariantDetailsUsageLimitInterval, PlanVariantDetailsUsageLimitInterval$inboundSchema, type Preview1, Preview1$inboundSchema, type Preview2, Preview2$inboundSchema, PreviewAttachAddItemBillingMethod, PreviewAttachAddItemBillingMethod$outboundSchema, PreviewAttachAddItemExpiryDurationType, PreviewAttachAddItemExpiryDurationType$outboundSchema, PreviewAttachAddItemOnDecrease, PreviewAttachAddItemOnDecrease$outboundSchema, PreviewAttachAddItemOnIncrease, PreviewAttachAddItemOnIncrease$outboundSchema, type PreviewAttachAddItemPlanItem, type PreviewAttachAddItemPlanItem$Outbound, PreviewAttachAddItemPlanItem$outboundSchema, type PreviewAttachAddItemPrice, type PreviewAttachAddItemPrice$Outbound, PreviewAttachAddItemPrice$outboundSchema, PreviewAttachAddItemPriceInterval, PreviewAttachAddItemPriceInterval$outboundSchema, type PreviewAttachAddItemProration, type PreviewAttachAddItemProration$Outbound, PreviewAttachAddItemProration$outboundSchema, type PreviewAttachAddItemReset, type PreviewAttachAddItemReset$Outbound, PreviewAttachAddItemReset$outboundSchema, PreviewAttachAddItemResetInterval, PreviewAttachAddItemResetInterval$outboundSchema, type PreviewAttachAddItemRollover, type PreviewAttachAddItemRollover$Outbound, PreviewAttachAddItemRollover$outboundSchema, type PreviewAttachAddItemTier, type PreviewAttachAddItemTier$Outbound, PreviewAttachAddItemTier$outboundSchema, PreviewAttachAddItemTierBehavior, PreviewAttachAddItemTierBehavior$outboundSchema, type PreviewAttachAddItemTo, type PreviewAttachAddItemTo$Outbound, PreviewAttachAddItemTo$outboundSchema, type PreviewAttachAttachDiscount, type PreviewAttachAttachDiscount$Outbound, PreviewAttachAttachDiscount$outboundSchema, type PreviewAttachAutoTopup, type PreviewAttachAutoTopup$Outbound, PreviewAttachAutoTopup$outboundSchema, type PreviewAttachBasePrice, type PreviewAttachBasePrice$Outbound, PreviewAttachBasePrice$outboundSchema, type PreviewAttachBillingControls, type PreviewAttachBillingControls$Outbound, PreviewAttachBillingControls$outboundSchema, type PreviewAttachCarryOverBalances, type PreviewAttachCarryOverBalances$Outbound, PreviewAttachCarryOverBalances$outboundSchema, type PreviewAttachCarryOverUsages, type PreviewAttachCarryOverUsages$Outbound, PreviewAttachCarryOverUsages$outboundSchema, PreviewAttachCheckoutType, PreviewAttachCheckoutType$inboundSchema, type PreviewAttachCustomLineItem, type PreviewAttachCustomLineItem$Outbound, PreviewAttachCustomLineItem$outboundSchema, type PreviewAttachCustomize, type PreviewAttachCustomize$Outbound, PreviewAttachCustomize$outboundSchema, type PreviewAttachDiscount, PreviewAttachDiscount$inboundSchema, PreviewAttachDurationType, PreviewAttachDurationType$outboundSchema, type PreviewAttachFeatureQuantityRequest, type PreviewAttachFeatureQuantityRequest$Outbound, PreviewAttachFeatureQuantityRequest$outboundSchema, type PreviewAttachFilter, type PreviewAttachFilter$Outbound, PreviewAttachFilter$outboundSchema, type PreviewAttachFreeTrialParams, type PreviewAttachFreeTrialParams$Outbound, PreviewAttachFreeTrialParams$outboundSchema, type PreviewAttachGlobals, type PreviewAttachIncoming, PreviewAttachIncoming$inboundSchema, type PreviewAttachIncomingFeatureQuantity, PreviewAttachIncomingFeatureQuantity$inboundSchema, PreviewAttachIntervalRemoveItemEnum1, PreviewAttachIntervalRemoveItemEnum1$outboundSchema, PreviewAttachIntervalRemoveItemEnum2, PreviewAttachIntervalRemoveItemEnum2$outboundSchema, type PreviewAttachIntervalUnion, type PreviewAttachIntervalUnion$Outbound, PreviewAttachIntervalUnion$outboundSchema, type PreviewAttachInvoiceCredits, PreviewAttachInvoiceCredits$inboundSchema, type PreviewAttachInvoiceMode, type PreviewAttachInvoiceMode$Outbound, PreviewAttachInvoiceMode$outboundSchema, PreviewAttachItemBillingMethod, PreviewAttachItemBillingMethod$outboundSchema, PreviewAttachItemExpiryDurationType, PreviewAttachItemExpiryDurationType$outboundSchema, PreviewAttachItemOnDecrease, PreviewAttachItemOnDecrease$outboundSchema, PreviewAttachItemOnIncrease, PreviewAttachItemOnIncrease$outboundSchema, type PreviewAttachItemPlanItem, type PreviewAttachItemPlanItem$Outbound, PreviewAttachItemPlanItem$outboundSchema, type PreviewAttachItemPrice, type PreviewAttachItemPrice$Outbound, PreviewAttachItemPrice$outboundSchema, PreviewAttachItemPriceInterval, PreviewAttachItemPriceInterval$outboundSchema, type PreviewAttachItemProration, type PreviewAttachItemProration$Outbound, PreviewAttachItemProration$outboundSchema, type PreviewAttachItemReset, type PreviewAttachItemReset$Outbound, PreviewAttachItemReset$outboundSchema, PreviewAttachItemResetInterval, PreviewAttachItemResetInterval$outboundSchema, type PreviewAttachItemRollover, type PreviewAttachItemRollover$Outbound, PreviewAttachItemRollover$outboundSchema, type PreviewAttachItemTier, type PreviewAttachItemTier$Outbound, PreviewAttachItemTier$outboundSchema, PreviewAttachItemTierBehavior, PreviewAttachItemTierBehavior$outboundSchema, type PreviewAttachItemTo, type PreviewAttachItemTo$Outbound, PreviewAttachItemTo$outboundSchema, PreviewAttachLimitType, PreviewAttachLimitType$outboundSchema, type PreviewAttachLineItem, PreviewAttachLineItem$inboundSchema, type PreviewAttachLineItemPeriod, PreviewAttachLineItemPeriod$inboundSchema, type PreviewAttachNextCycle, PreviewAttachNextCycle$inboundSchema, type PreviewAttachNextCycleDiscount, PreviewAttachNextCycleDiscount$inboundSchema, type PreviewAttachNextCycleLineItem, PreviewAttachNextCycleLineItem$inboundSchema, type PreviewAttachNextCycleLineItemPeriod, PreviewAttachNextCycleLineItemPeriod$inboundSchema, PreviewAttachOnEnd, PreviewAttachOnEnd$outboundSchema, type PreviewAttachOutgoing, PreviewAttachOutgoing$inboundSchema, type PreviewAttachOutgoingFeatureQuantity, PreviewAttachOutgoingFeatureQuantity$inboundSchema, type PreviewAttachOverageAllowed, type PreviewAttachOverageAllowed$Outbound, PreviewAttachOverageAllowed$outboundSchema, type PreviewAttachParams, type PreviewAttachParams$Outbound, PreviewAttachParams$outboundSchema, type PreviewAttachPlanItemFilter, type PreviewAttachPlanItemFilter$Outbound, PreviewAttachPlanItemFilter$outboundSchema, PreviewAttachPlanSchedule, PreviewAttachPlanSchedule$outboundSchema, PreviewAttachPriceInterval, PreviewAttachPriceInterval$outboundSchema, type PreviewAttachProperties, type PreviewAttachProperties$Outbound, PreviewAttachProperties$outboundSchema, PreviewAttachProrationBehavior, PreviewAttachProrationBehavior$outboundSchema, type PreviewAttachPurchaseLimit, type PreviewAttachPurchaseLimit$Outbound, PreviewAttachPurchaseLimit$outboundSchema, PreviewAttachPurchaseLimitInterval, PreviewAttachPurchaseLimitInterval$outboundSchema, PreviewAttachRedirectMode, PreviewAttachRedirectMode$outboundSchema, PreviewAttachRemoveItemBillingMethod, PreviewAttachRemoveItemBillingMethod$outboundSchema, type PreviewAttachResponse, PreviewAttachResponse$inboundSchema, type PreviewAttachSpendLimit, type PreviewAttachSpendLimit$Outbound, PreviewAttachSpendLimit$outboundSchema, PreviewAttachStatus, PreviewAttachStatus$inboundSchema, type PreviewAttachTax, PreviewAttachTax$inboundSchema, PreviewAttachThresholdType, PreviewAttachThresholdType$outboundSchema, type PreviewAttachUsageAlert, type PreviewAttachUsageAlert$Outbound, PreviewAttachUsageAlert$outboundSchema, type PreviewAttachUsageLimit, type PreviewAttachUsageLimit$Outbound, PreviewAttachUsageLimit$outboundSchema, PreviewAttachUsageLimitInterval, PreviewAttachUsageLimitInterval$outboundSchema, type PreviewAttachUsageLineItem, PreviewAttachUsageLineItem$inboundSchema, type PreviewAttachUsageLineItemPeriod, PreviewAttachUsageLineItemPeriod$inboundSchema, type PreviewMultiAttachAttachDiscount, type PreviewMultiAttachAttachDiscount$Outbound, PreviewMultiAttachAttachDiscount$outboundSchema, type PreviewMultiAttachBasePrice, type PreviewMultiAttachBasePrice$Outbound, PreviewMultiAttachBasePrice$outboundSchema, type PreviewMultiAttachBillingControls, type PreviewMultiAttachBillingControls$Outbound, PreviewMultiAttachBillingControls$outboundSchema, PreviewMultiAttachBillingMethod, PreviewMultiAttachBillingMethod$outboundSchema, PreviewMultiAttachCheckoutType, PreviewMultiAttachCheckoutType$inboundSchema, type PreviewMultiAttachCustomize, type PreviewMultiAttachCustomize$Outbound, PreviewMultiAttachCustomize$outboundSchema, type PreviewMultiAttachDiscount, PreviewMultiAttachDiscount$inboundSchema, PreviewMultiAttachDurationType, PreviewMultiAttachDurationType$outboundSchema, type PreviewMultiAttachEntityData, type PreviewMultiAttachEntityData$Outbound, PreviewMultiAttachEntityData$outboundSchema, PreviewMultiAttachEntityDataInterval, PreviewMultiAttachEntityDataInterval$outboundSchema, PreviewMultiAttachExpiryDurationType, PreviewMultiAttachExpiryDurationType$outboundSchema, type PreviewMultiAttachFilter, type PreviewMultiAttachFilter$Outbound, PreviewMultiAttachFilter$outboundSchema, type PreviewMultiAttachFreeTrialParams, type PreviewMultiAttachFreeTrialParams$Outbound, PreviewMultiAttachFreeTrialParams$outboundSchema, type PreviewMultiAttachGlobals, type PreviewMultiAttachIncoming, PreviewMultiAttachIncoming$inboundSchema, type PreviewMultiAttachIncomingFeatureQuantity, PreviewMultiAttachIncomingFeatureQuantity$inboundSchema, type PreviewMultiAttachInvoiceCredits, PreviewMultiAttachInvoiceCredits$inboundSchema, type PreviewMultiAttachInvoiceMode, type PreviewMultiAttachInvoiceMode$Outbound, PreviewMultiAttachInvoiceMode$outboundSchema, PreviewMultiAttachItemPriceInterval, PreviewMultiAttachItemPriceInterval$outboundSchema, PreviewMultiAttachLimitType, PreviewMultiAttachLimitType$outboundSchema, type PreviewMultiAttachLineItem, PreviewMultiAttachLineItem$inboundSchema, type PreviewMultiAttachLineItemPeriod, PreviewMultiAttachLineItemPeriod$inboundSchema, type PreviewMultiAttachNextCycle, PreviewMultiAttachNextCycle$inboundSchema, type PreviewMultiAttachNextCycleDiscount, PreviewMultiAttachNextCycleDiscount$inboundSchema, type PreviewMultiAttachNextCycleLineItem, PreviewMultiAttachNextCycleLineItem$inboundSchema, type PreviewMultiAttachNextCycleLineItemPeriod, PreviewMultiAttachNextCycleLineItemPeriod$inboundSchema, PreviewMultiAttachOnDecrease, PreviewMultiAttachOnDecrease$outboundSchema, PreviewMultiAttachOnEnd, PreviewMultiAttachOnEnd$outboundSchema, PreviewMultiAttachOnIncrease, PreviewMultiAttachOnIncrease$outboundSchema, type PreviewMultiAttachOutgoing, PreviewMultiAttachOutgoing$inboundSchema, type PreviewMultiAttachOutgoingFeatureQuantity, PreviewMultiAttachOutgoingFeatureQuantity$inboundSchema, type PreviewMultiAttachOverageAllowed, type PreviewMultiAttachOverageAllowed$Outbound, PreviewMultiAttachOverageAllowed$outboundSchema, type PreviewMultiAttachParams, type PreviewMultiAttachParams$Outbound, PreviewMultiAttachParams$outboundSchema, type PreviewMultiAttachPlan, type PreviewMultiAttachPlan$Outbound, PreviewMultiAttachPlan$outboundSchema, type PreviewMultiAttachPlanFeatureQuantity, type PreviewMultiAttachPlanFeatureQuantity$Outbound, PreviewMultiAttachPlanFeatureQuantity$outboundSchema, type PreviewMultiAttachPlanItem, type PreviewMultiAttachPlanItem$Outbound, PreviewMultiAttachPlanItem$outboundSchema, type PreviewMultiAttachPrice, type PreviewMultiAttachPrice$Outbound, PreviewMultiAttachPrice$outboundSchema, PreviewMultiAttachPriceInterval, PreviewMultiAttachPriceInterval$outboundSchema, type PreviewMultiAttachProperties, type PreviewMultiAttachProperties$Outbound, PreviewMultiAttachProperties$outboundSchema, type PreviewMultiAttachProration, type PreviewMultiAttachProration$Outbound, PreviewMultiAttachProration$outboundSchema, PreviewMultiAttachRedirectMode, PreviewMultiAttachRedirectMode$outboundSchema, type PreviewMultiAttachReset, type PreviewMultiAttachReset$Outbound, PreviewMultiAttachReset$outboundSchema, PreviewMultiAttachResetInterval, PreviewMultiAttachResetInterval$outboundSchema, type PreviewMultiAttachResponse, PreviewMultiAttachResponse$inboundSchema, type PreviewMultiAttachRollover, type PreviewMultiAttachRollover$Outbound, PreviewMultiAttachRollover$outboundSchema, type PreviewMultiAttachSpendLimit, type PreviewMultiAttachSpendLimit$Outbound, PreviewMultiAttachSpendLimit$outboundSchema, PreviewMultiAttachStatus, PreviewMultiAttachStatus$inboundSchema, type PreviewMultiAttachTax, PreviewMultiAttachTax$inboundSchema, PreviewMultiAttachThresholdType, PreviewMultiAttachThresholdType$outboundSchema, type PreviewMultiAttachTier, type PreviewMultiAttachTier$Outbound, PreviewMultiAttachTier$outboundSchema, PreviewMultiAttachTierBehavior, PreviewMultiAttachTierBehavior$outboundSchema, type PreviewMultiAttachTo, type PreviewMultiAttachTo$Outbound, PreviewMultiAttachTo$outboundSchema, type PreviewMultiAttachUsageAlert, type PreviewMultiAttachUsageAlert$Outbound, PreviewMultiAttachUsageAlert$outboundSchema, type PreviewMultiAttachUsageLimit, type PreviewMultiAttachUsageLimit$Outbound, PreviewMultiAttachUsageLimit$outboundSchema, type PreviewMultiAttachUsageLineItem, PreviewMultiAttachUsageLineItem$inboundSchema, type PreviewMultiAttachUsageLineItemPeriod, PreviewMultiAttachUsageLineItemPeriod$inboundSchema, PreviewMultiUpdateCancelAction, PreviewMultiUpdateCancelAction$outboundSchema, type PreviewMultiUpdateDiscount, PreviewMultiUpdateDiscount$inboundSchema, type PreviewMultiUpdateGlobals, type PreviewMultiUpdateIncoming, PreviewMultiUpdateIncoming$inboundSchema, type PreviewMultiUpdateIncomingFeatureQuantity, PreviewMultiUpdateIncomingFeatureQuantity$inboundSchema, type PreviewMultiUpdateLineItem, PreviewMultiUpdateLineItem$inboundSchema, type PreviewMultiUpdateLineItemPeriod, PreviewMultiUpdateLineItemPeriod$inboundSchema, type PreviewMultiUpdateNextCycle, PreviewMultiUpdateNextCycle$inboundSchema, type PreviewMultiUpdateNextCycleDiscount, PreviewMultiUpdateNextCycleDiscount$inboundSchema, type PreviewMultiUpdateNextCycleLineItem, PreviewMultiUpdateNextCycleLineItem$inboundSchema, type PreviewMultiUpdateNextCycleLineItemPeriod, PreviewMultiUpdateNextCycleLineItemPeriod$inboundSchema, type PreviewMultiUpdateOutgoing, PreviewMultiUpdateOutgoing$inboundSchema, type PreviewMultiUpdateOutgoingFeatureQuantity, PreviewMultiUpdateOutgoingFeatureQuantity$inboundSchema, type PreviewMultiUpdateParams, type PreviewMultiUpdateParams$Outbound, PreviewMultiUpdateParams$outboundSchema, PreviewMultiUpdateProrationBehavior, PreviewMultiUpdateProrationBehavior$outboundSchema, type PreviewMultiUpdateSubscription, PreviewMultiUpdateSubscription$inboundSchema, type PreviewMultiUpdateUpdate, type PreviewMultiUpdateUpdate$Outbound, PreviewMultiUpdateUpdate$outboundSchema, type PreviewMultiUpdateUsageLineItem, PreviewMultiUpdateUsageLineItem$inboundSchema, type PreviewMultiUpdateUsageLineItemPeriod, PreviewMultiUpdateUsageLineItemPeriod$inboundSchema, PreviewUpdateAddItemBillingMethod, PreviewUpdateAddItemBillingMethod$outboundSchema, PreviewUpdateAddItemExpiryDurationType, PreviewUpdateAddItemExpiryDurationType$outboundSchema, PreviewUpdateAddItemOnDecrease, PreviewUpdateAddItemOnDecrease$outboundSchema, PreviewUpdateAddItemOnIncrease, PreviewUpdateAddItemOnIncrease$outboundSchema, type PreviewUpdateAddItemPlanItem, type PreviewUpdateAddItemPlanItem$Outbound, PreviewUpdateAddItemPlanItem$outboundSchema, type PreviewUpdateAddItemPrice, type PreviewUpdateAddItemPrice$Outbound, PreviewUpdateAddItemPrice$outboundSchema, PreviewUpdateAddItemPriceInterval, PreviewUpdateAddItemPriceInterval$outboundSchema, type PreviewUpdateAddItemProration, type PreviewUpdateAddItemProration$Outbound, PreviewUpdateAddItemProration$outboundSchema, type PreviewUpdateAddItemReset, type PreviewUpdateAddItemReset$Outbound, PreviewUpdateAddItemReset$outboundSchema, PreviewUpdateAddItemResetInterval, PreviewUpdateAddItemResetInterval$outboundSchema, type PreviewUpdateAddItemRollover, type PreviewUpdateAddItemRollover$Outbound, PreviewUpdateAddItemRollover$outboundSchema, type PreviewUpdateAddItemTier, type PreviewUpdateAddItemTier$Outbound, PreviewUpdateAddItemTier$outboundSchema, PreviewUpdateAddItemTierBehavior, PreviewUpdateAddItemTierBehavior$outboundSchema, type PreviewUpdateAddItemTo, type PreviewUpdateAddItemTo$Outbound, PreviewUpdateAddItemTo$outboundSchema, type PreviewUpdateAttachDiscount, type PreviewUpdateAttachDiscount$Outbound, PreviewUpdateAttachDiscount$outboundSchema, type PreviewUpdateAutoTopup, type PreviewUpdateAutoTopup$Outbound, PreviewUpdateAutoTopup$outboundSchema, type PreviewUpdateBasePrice, type PreviewUpdateBasePrice$Outbound, PreviewUpdateBasePrice$outboundSchema, type PreviewUpdateBillingControls, type PreviewUpdateBillingControls$Outbound, PreviewUpdateBillingControls$outboundSchema, PreviewUpdateCancelAction, PreviewUpdateCancelAction$outboundSchema, type PreviewUpdateCarryOverUsages, type PreviewUpdateCarryOverUsages$Outbound, PreviewUpdateCarryOverUsages$outboundSchema, type PreviewUpdateCustomize, type PreviewUpdateCustomize$Outbound, PreviewUpdateCustomize$outboundSchema, type PreviewUpdateDiscount, PreviewUpdateDiscount$inboundSchema, PreviewUpdateDurationType, PreviewUpdateDurationType$outboundSchema, type PreviewUpdateFeatureQuantityRequest, type PreviewUpdateFeatureQuantityRequest$Outbound, PreviewUpdateFeatureQuantityRequest$outboundSchema, type PreviewUpdateFilter, type PreviewUpdateFilter$Outbound, PreviewUpdateFilter$outboundSchema, type PreviewUpdateFreeTrialParams, type PreviewUpdateFreeTrialParams$Outbound, PreviewUpdateFreeTrialParams$outboundSchema, type PreviewUpdateGlobals, type PreviewUpdateIncoming, PreviewUpdateIncoming$inboundSchema, type PreviewUpdateIncomingFeatureQuantity, PreviewUpdateIncomingFeatureQuantity$inboundSchema, PreviewUpdateIntervalRemoveItemEnum1, PreviewUpdateIntervalRemoveItemEnum1$outboundSchema, PreviewUpdateIntervalRemoveItemEnum2, PreviewUpdateIntervalRemoveItemEnum2$outboundSchema, type PreviewUpdateIntervalUnion, type PreviewUpdateIntervalUnion$Outbound, PreviewUpdateIntervalUnion$outboundSchema, type PreviewUpdateInvoiceCredits, PreviewUpdateInvoiceCredits$inboundSchema, type PreviewUpdateInvoiceMode, type PreviewUpdateInvoiceMode$Outbound, PreviewUpdateInvoiceMode$outboundSchema, PreviewUpdateItemBillingMethod, PreviewUpdateItemBillingMethod$outboundSchema, PreviewUpdateItemExpiryDurationType, PreviewUpdateItemExpiryDurationType$outboundSchema, PreviewUpdateItemOnDecrease, PreviewUpdateItemOnDecrease$outboundSchema, PreviewUpdateItemOnIncrease, PreviewUpdateItemOnIncrease$outboundSchema, type PreviewUpdateItemPlanItem, type PreviewUpdateItemPlanItem$Outbound, PreviewUpdateItemPlanItem$outboundSchema, type PreviewUpdateItemPrice, type PreviewUpdateItemPrice$Outbound, PreviewUpdateItemPrice$outboundSchema, PreviewUpdateItemPriceInterval, PreviewUpdateItemPriceInterval$outboundSchema, type PreviewUpdateItemProration, type PreviewUpdateItemProration$Outbound, PreviewUpdateItemProration$outboundSchema, type PreviewUpdateItemReset, type PreviewUpdateItemReset$Outbound, PreviewUpdateItemReset$outboundSchema, PreviewUpdateItemResetInterval, PreviewUpdateItemResetInterval$outboundSchema, type PreviewUpdateItemRollover, type PreviewUpdateItemRollover$Outbound, PreviewUpdateItemRollover$outboundSchema, type PreviewUpdateItemTier, type PreviewUpdateItemTier$Outbound, PreviewUpdateItemTier$outboundSchema, PreviewUpdateItemTierBehavior, PreviewUpdateItemTierBehavior$outboundSchema, type PreviewUpdateItemTo, type PreviewUpdateItemTo$Outbound, PreviewUpdateItemTo$outboundSchema, PreviewUpdateLimitType, PreviewUpdateLimitType$outboundSchema, type PreviewUpdateLineItem, PreviewUpdateLineItem$inboundSchema, type PreviewUpdateLineItemPeriod, PreviewUpdateLineItemPeriod$inboundSchema, type PreviewUpdateNextCycle, PreviewUpdateNextCycle$inboundSchema, type PreviewUpdateNextCycleDiscount, PreviewUpdateNextCycleDiscount$inboundSchema, type PreviewUpdateNextCycleLineItem, PreviewUpdateNextCycleLineItem$inboundSchema, type PreviewUpdateNextCycleLineItemPeriod, PreviewUpdateNextCycleLineItemPeriod$inboundSchema, PreviewUpdateOnEnd, PreviewUpdateOnEnd$outboundSchema, type PreviewUpdateOutgoing, PreviewUpdateOutgoing$inboundSchema, type PreviewUpdateOutgoingFeatureQuantity, PreviewUpdateOutgoingFeatureQuantity$inboundSchema, type PreviewUpdateOverageAllowed, type PreviewUpdateOverageAllowed$Outbound, PreviewUpdateOverageAllowed$outboundSchema, type PreviewUpdateParams, type PreviewUpdateParams$Outbound, PreviewUpdateParams$outboundSchema, type PreviewUpdatePlanItemFilter, type PreviewUpdatePlanItemFilter$Outbound, PreviewUpdatePlanItemFilter$outboundSchema, PreviewUpdatePriceInterval, PreviewUpdatePriceInterval$outboundSchema, type PreviewUpdateProperties, type PreviewUpdateProperties$Outbound, PreviewUpdateProperties$outboundSchema, PreviewUpdateProrationBehavior, PreviewUpdateProrationBehavior$outboundSchema, type PreviewUpdatePurchaseLimit, type PreviewUpdatePurchaseLimit$Outbound, PreviewUpdatePurchaseLimit$outboundSchema, PreviewUpdatePurchaseLimitInterval, PreviewUpdatePurchaseLimitInterval$outboundSchema, type PreviewUpdateRecalculateBalances, type PreviewUpdateRecalculateBalances$Outbound, PreviewUpdateRecalculateBalances$outboundSchema, PreviewUpdateRedirectMode, PreviewUpdateRedirectMode$outboundSchema, PreviewUpdateRefundLastPayment, PreviewUpdateRefundLastPayment$outboundSchema, PreviewUpdateRemoveItemBillingMethod, PreviewUpdateRemoveItemBillingMethod$outboundSchema, type PreviewUpdateResponse, PreviewUpdateResponse$inboundSchema, type PreviewUpdateSpendLimit, type PreviewUpdateSpendLimit$Outbound, PreviewUpdateSpendLimit$outboundSchema, PreviewUpdateStatus, PreviewUpdateStatus$inboundSchema, type PreviewUpdateTax, PreviewUpdateTax$inboundSchema, PreviewUpdateThresholdType, PreviewUpdateThresholdType$outboundSchema, type PreviewUpdateUsageAlert, type PreviewUpdateUsageAlert$Outbound, PreviewUpdateUsageAlert$outboundSchema, type PreviewUpdateUsageLimit, type PreviewUpdateUsageLimit$Outbound, PreviewUpdateUsageLimit$outboundSchema, PreviewUpdateUsageLimitInterval, PreviewUpdateUsageLimitInterval$outboundSchema, type PreviewUpdateUsageLineItem, PreviewUpdateUsageLineItem$inboundSchema, type PreviewUpdateUsageLineItemPeriod, PreviewUpdateUsageLineItemPeriod$inboundSchema, PriceVariantInterval, PriceVariantInterval$outboundSchema, ProcessorType, ProcessorType$inboundSchema, type Processors, Processors$inboundSchema, type ProductDisplay1, ProductDisplay1$inboundSchema, type ProductDisplay2, ProductDisplay2$inboundSchema, ProductScenario1, ProductScenario1$inboundSchema, ProductScenario2, ProductScenario2$inboundSchema, ProductType1, ProductType1$inboundSchema, ProductType2, ProductType2$inboundSchema, type Properties, type Properties$Outbound, Properties$outboundSchema, type Proration, Proration$inboundSchema, type Purchase, Purchase$inboundSchema, PurchaseScope, PurchaseScope$inboundSchema, Range, Range$outboundSchema, type RedeemReferralCodeGlobals, type RedeemReferralCodeParams, type RedeemReferralCodeParams$Outbound, RedeemReferralCodeParams$outboundSchema, type RedeemReferralCodeResponse, RedeemReferralCodeResponse$inboundSchema, type RedeemRewardCodeGlobals, type RedeemRewardCodeParams, type RedeemRewardCodeParams$Outbound, RedeemRewardCodeParams$outboundSchema, type RedeemRewardCodeResponse, RedeemRewardCodeResponse$inboundSchema, type Referral, Referral$inboundSchema, type ReferralCustomer, ReferralCustomer$inboundSchema, type RefreshKeyGlobals, type RefreshKeyParams, type RefreshKeyParams$Outbound, RefreshKeyParams$outboundSchema, type RefreshKeyResponse, RefreshKeyResponse$inboundSchema, RequestAbortedError, type RequestBody, type RequestBody$Outbound, RequestBody$outboundSchema, RequestTimeoutError, ResponseValidationError, type Result, Result$inboundSchema, type Revenuecat, Revenuecat$inboundSchema, type RevokeKeyGlobals, type RevokeKeyParams, type RevokeKeyParams$Outbound, RevokeKeyParams$outboundSchema, type RevokeKeyResponse, RevokeKeyResponse$inboundSchema, type Rewards$1 as Rewards, Rewards$inboundSchema, type RewardsListParams, type RewardsListParams$Outbound, RewardsListParams$outboundSchema, type SDKOptions, SDKValidationError, SDK_METADATA, Scenario1, Scenario1$inboundSchema, Scenario2, Scenario2$inboundSchema, type Security, type Security$Outbound, Security$outboundSchema, ServerList, SetupPaymentAddItemBillingMethod, SetupPaymentAddItemBillingMethod$outboundSchema, SetupPaymentAddItemExpiryDurationType, SetupPaymentAddItemExpiryDurationType$outboundSchema, SetupPaymentAddItemOnDecrease, SetupPaymentAddItemOnDecrease$outboundSchema, SetupPaymentAddItemOnIncrease, SetupPaymentAddItemOnIncrease$outboundSchema, type SetupPaymentAddItemPlanItem, type SetupPaymentAddItemPlanItem$Outbound, SetupPaymentAddItemPlanItem$outboundSchema, type SetupPaymentAddItemPrice, type SetupPaymentAddItemPrice$Outbound, SetupPaymentAddItemPrice$outboundSchema, SetupPaymentAddItemPriceInterval, SetupPaymentAddItemPriceInterval$outboundSchema, type SetupPaymentAddItemProration, type SetupPaymentAddItemProration$Outbound, SetupPaymentAddItemProration$outboundSchema, type SetupPaymentAddItemReset, type SetupPaymentAddItemReset$Outbound, SetupPaymentAddItemReset$outboundSchema, SetupPaymentAddItemResetInterval, SetupPaymentAddItemResetInterval$outboundSchema, type SetupPaymentAddItemRollover, type SetupPaymentAddItemRollover$Outbound, SetupPaymentAddItemRollover$outboundSchema, type SetupPaymentAddItemTier, type SetupPaymentAddItemTier$Outbound, SetupPaymentAddItemTier$outboundSchema, SetupPaymentAddItemTierBehavior, SetupPaymentAddItemTierBehavior$outboundSchema, type SetupPaymentAddItemTo, type SetupPaymentAddItemTo$Outbound, SetupPaymentAddItemTo$outboundSchema, type SetupPaymentAttachDiscount, type SetupPaymentAttachDiscount$Outbound, SetupPaymentAttachDiscount$outboundSchema, type SetupPaymentAutoTopup, type SetupPaymentAutoTopup$Outbound, SetupPaymentAutoTopup$outboundSchema, type SetupPaymentBasePrice, type SetupPaymentBasePrice$Outbound, SetupPaymentBasePrice$outboundSchema, type SetupPaymentBillingControls, type SetupPaymentBillingControls$Outbound, SetupPaymentBillingControls$outboundSchema, type SetupPaymentCarryOverBalances, type SetupPaymentCarryOverBalances$Outbound, SetupPaymentCarryOverBalances$outboundSchema, type SetupPaymentCarryOverUsages, type SetupPaymentCarryOverUsages$Outbound, SetupPaymentCarryOverUsages$outboundSchema, type SetupPaymentCustomLineItem, type SetupPaymentCustomLineItem$Outbound, SetupPaymentCustomLineItem$outboundSchema, type SetupPaymentCustomize, type SetupPaymentCustomize$Outbound, SetupPaymentCustomize$outboundSchema, SetupPaymentDurationType, SetupPaymentDurationType$outboundSchema, type SetupPaymentFeatureQuantity, type SetupPaymentFeatureQuantity$Outbound, SetupPaymentFeatureQuantity$outboundSchema, type SetupPaymentFilter, type SetupPaymentFilter$Outbound, SetupPaymentFilter$outboundSchema, type SetupPaymentFreeTrialParams, type SetupPaymentFreeTrialParams$Outbound, SetupPaymentFreeTrialParams$outboundSchema, type SetupPaymentGlobals, SetupPaymentIntervalRemoveItemEnum1, SetupPaymentIntervalRemoveItemEnum1$outboundSchema, SetupPaymentIntervalRemoveItemEnum2, SetupPaymentIntervalRemoveItemEnum2$outboundSchema, type SetupPaymentIntervalUnion, type SetupPaymentIntervalUnion$Outbound, SetupPaymentIntervalUnion$outboundSchema, SetupPaymentItemBillingMethod, SetupPaymentItemBillingMethod$outboundSchema, SetupPaymentItemExpiryDurationType, SetupPaymentItemExpiryDurationType$outboundSchema, SetupPaymentItemOnDecrease, SetupPaymentItemOnDecrease$outboundSchema, SetupPaymentItemOnIncrease, SetupPaymentItemOnIncrease$outboundSchema, type SetupPaymentItemPlanItem, type SetupPaymentItemPlanItem$Outbound, SetupPaymentItemPlanItem$outboundSchema, type SetupPaymentItemPrice, type SetupPaymentItemPrice$Outbound, SetupPaymentItemPrice$outboundSchema, SetupPaymentItemPriceInterval, SetupPaymentItemPriceInterval$outboundSchema, type SetupPaymentItemProration, type SetupPaymentItemProration$Outbound, SetupPaymentItemProration$outboundSchema, type SetupPaymentItemReset, type SetupPaymentItemReset$Outbound, SetupPaymentItemReset$outboundSchema, SetupPaymentItemResetInterval, SetupPaymentItemResetInterval$outboundSchema, type SetupPaymentItemRollover, type SetupPaymentItemRollover$Outbound, SetupPaymentItemRollover$outboundSchema, type SetupPaymentItemTier, type SetupPaymentItemTier$Outbound, SetupPaymentItemTier$outboundSchema, SetupPaymentItemTierBehavior, SetupPaymentItemTierBehavior$outboundSchema, type SetupPaymentItemTo, type SetupPaymentItemTo$Outbound, SetupPaymentItemTo$outboundSchema, SetupPaymentLimitType, SetupPaymentLimitType$outboundSchema, SetupPaymentOnEnd, SetupPaymentOnEnd$outboundSchema, type SetupPaymentOverageAllowed, type SetupPaymentOverageAllowed$Outbound, SetupPaymentOverageAllowed$outboundSchema, type SetupPaymentParams, type SetupPaymentParams$Outbound, SetupPaymentParams$outboundSchema, type SetupPaymentPlanItemFilter, type SetupPaymentPlanItemFilter$Outbound, SetupPaymentPlanItemFilter$outboundSchema, SetupPaymentPriceInterval, SetupPaymentPriceInterval$outboundSchema, type SetupPaymentProperties, type SetupPaymentProperties$Outbound, SetupPaymentProperties$outboundSchema, SetupPaymentProrationBehavior, SetupPaymentProrationBehavior$outboundSchema, type SetupPaymentPurchaseLimit, type SetupPaymentPurchaseLimit$Outbound, SetupPaymentPurchaseLimit$outboundSchema, SetupPaymentPurchaseLimitInterval, SetupPaymentPurchaseLimitInterval$outboundSchema, SetupPaymentRemoveItemBillingMethod, SetupPaymentRemoveItemBillingMethod$outboundSchema, type SetupPaymentResponse, SetupPaymentResponse$inboundSchema, type SetupPaymentSpendLimit, type SetupPaymentSpendLimit$Outbound, SetupPaymentSpendLimit$outboundSchema, SetupPaymentThresholdType, SetupPaymentThresholdType$outboundSchema, type SetupPaymentUsageAlert, type SetupPaymentUsageAlert$Outbound, SetupPaymentUsageAlert$outboundSchema, type SetupPaymentUsageLimit, type SetupPaymentUsageLimit$Outbound, SetupPaymentUsageLimit$outboundSchema, SetupPaymentUsageLimitInterval, SetupPaymentUsageLimitInterval$outboundSchema, SpendLimitSource, SpendLimitSource$inboundSchema, type StartingAfter2, type StartingAfter2$Outbound, StartingAfter2$outboundSchema, type StartsAt2, type StartsAt2$Outbound, StartsAt2$outboundSchema, StorePush, StorePush$inboundSchema, type Stripe, Stripe$inboundSchema, type Subscription, Subscription$inboundSchema, SubscriptionScope, SubscriptionScope$inboundSchema, type SyncRevenueCatApp, SyncRevenueCatApp$inboundSchema, SyncRevenueCatEnv, SyncRevenueCatEnv$outboundSchema, type SyncRevenueCatGlobals, type SyncRevenueCatParams, type SyncRevenueCatParams$Outbound, SyncRevenueCatParams$outboundSchema, SyncRevenueCatPrice, SyncRevenueCatPrice$inboundSchema, SyncRevenueCatProduct, SyncRevenueCatProduct$inboundSchema, type SyncRevenueCatResponse, SyncRevenueCatResponse$inboundSchema, SyncRevenueCatStatus, SyncRevenueCatStatus$inboundSchema, type Total, Total$inboundSchema, type TrackDeduction1, TrackDeduction1$inboundSchema, type TrackDeduction2, TrackDeduction2$inboundSchema, type TrackGlobals, TrackIntervalEnum1, TrackIntervalEnum1$inboundSchema, TrackIntervalEnum2, TrackIntervalEnum2$inboundSchema, type TrackIntervalUnion1, TrackIntervalUnion1$inboundSchema, type TrackIntervalUnion2, TrackIntervalUnion2$inboundSchema, type TrackLock, type TrackLock$Outbound, TrackLock$outboundSchema, type TrackParams, type TrackParams$Outbound, TrackParams$outboundSchema, type TrackReset1, TrackReset1$inboundSchema, type TrackReset2, TrackReset2$inboundSchema, type TrackResponse, TrackResponse$inboundSchema, type TrackResponseBody1, TrackResponseBody1$inboundSchema, type TrackResponseBody2, TrackResponseBody2$inboundSchema, type TrackTokensDeduction1, TrackTokensDeduction1$inboundSchema, type TrackTokensDeduction2, TrackTokensDeduction2$inboundSchema, type TrackTokensGlobals, TrackTokensIntervalEnum1, TrackTokensIntervalEnum1$inboundSchema, TrackTokensIntervalEnum2, TrackTokensIntervalEnum2$inboundSchema, type TrackTokensIntervalUnion1, TrackTokensIntervalUnion1$inboundSchema, type TrackTokensIntervalUnion2, TrackTokensIntervalUnion2$inboundSchema, type TrackTokensParams, type TrackTokensParams$Outbound, TrackTokensParams$outboundSchema, type TrackTokensReset1, TrackTokensReset1$inboundSchema, type TrackTokensReset2, TrackTokensReset2$inboundSchema, type TrackTokensResponse, TrackTokensResponse$inboundSchema, type TrackTokensResponseBody1, TrackTokensResponseBody1$inboundSchema, type TrackTokensResponseBody2, TrackTokensResponseBody2$inboundSchema, type TrialsUsed, TrialsUsed$inboundSchema, UnexpectedClientError, type UpdateBalanceGlobals, UpdateBalanceInterval, UpdateBalanceInterval$outboundSchema, type UpdateBalanceParams, type UpdateBalanceParams$Outbound, UpdateBalanceParams$outboundSchema, type UpdateBalanceResponse, UpdateBalanceResponse$inboundSchema, type UpdateCustomerAutoTopupRequest, type UpdateCustomerAutoTopupRequest$Outbound, UpdateCustomerAutoTopupRequest$outboundSchema, type UpdateCustomerAutoTopupResponse, UpdateCustomerAutoTopupResponse$inboundSchema, UpdateCustomerAutoTopupSource, UpdateCustomerAutoTopupSource$inboundSchema, type UpdateCustomerBillingControlsRequest, type UpdateCustomerBillingControlsRequest$Outbound, UpdateCustomerBillingControlsRequest$outboundSchema, type UpdateCustomerBillingControlsResponse, UpdateCustomerBillingControlsResponse$inboundSchema, type UpdateCustomerConfigRequest, type UpdateCustomerConfigRequest$Outbound, UpdateCustomerConfigRequest$outboundSchema, type UpdateCustomerConfigResponse, UpdateCustomerConfigResponse$inboundSchema, type UpdateCustomerCreditSchema, UpdateCustomerCreditSchema$inboundSchema, type UpdateCustomerDisplay, UpdateCustomerDisplay$inboundSchema, UpdateCustomerEnv, UpdateCustomerEnv$inboundSchema, type UpdateCustomerFeature, UpdateCustomerFeature$inboundSchema, type UpdateCustomerFilterRequest, type UpdateCustomerFilterRequest$Outbound, UpdateCustomerFilterRequest$outboundSchema, type UpdateCustomerFilterResponse, UpdateCustomerFilterResponse$inboundSchema, type UpdateCustomerFlags, UpdateCustomerFlags$inboundSchema, type UpdateCustomerGlobals, UpdateCustomerLimitTypeRequestBody, UpdateCustomerLimitTypeRequestBody$outboundSchema, UpdateCustomerLimitTypeResponse, UpdateCustomerLimitTypeResponse$inboundSchema, type UpdateCustomerModelMarkups, UpdateCustomerModelMarkups$inboundSchema, type UpdateCustomerOverageAllowedRequest, type UpdateCustomerOverageAllowedRequest$Outbound, UpdateCustomerOverageAllowedRequest$outboundSchema, type UpdateCustomerOverageAllowedResponse, UpdateCustomerOverageAllowedResponse$inboundSchema, UpdateCustomerOverageAllowedSource, UpdateCustomerOverageAllowedSource$inboundSchema, type UpdateCustomerParams, type UpdateCustomerParams$Outbound, UpdateCustomerParams$outboundSchema, type UpdateCustomerProcessors, UpdateCustomerProcessors$inboundSchema, type UpdateCustomerProperties, type UpdateCustomerProperties$Outbound, UpdateCustomerProperties$outboundSchema, type UpdateCustomerProviderMarkups, UpdateCustomerProviderMarkups$inboundSchema, type UpdateCustomerPurchase, UpdateCustomerPurchase$inboundSchema, UpdateCustomerPurchaseLimitIntervalRequestBody, UpdateCustomerPurchaseLimitIntervalRequestBody$outboundSchema, UpdateCustomerPurchaseLimitIntervalResponse1, UpdateCustomerPurchaseLimitIntervalResponse1$inboundSchema, UpdateCustomerPurchaseLimitIntervalResponse2, UpdateCustomerPurchaseLimitIntervalResponse2$inboundSchema, type UpdateCustomerPurchaseLimitRequest, type UpdateCustomerPurchaseLimitRequest$Outbound, UpdateCustomerPurchaseLimitRequest$outboundSchema, type UpdateCustomerPurchaseLimitResponse1, UpdateCustomerPurchaseLimitResponse1$inboundSchema, type UpdateCustomerPurchaseLimitResponse2, UpdateCustomerPurchaseLimitResponse2$inboundSchema, type UpdateCustomerPurchaseLimitUnion, UpdateCustomerPurchaseLimitUnion$inboundSchema, UpdateCustomerPurchaseScope, UpdateCustomerPurchaseScope$inboundSchema, type UpdateCustomerResponse, UpdateCustomerResponse$inboundSchema, type UpdateCustomerRevenuecat, UpdateCustomerRevenuecat$inboundSchema, type UpdateCustomerSpendLimitRequest, type UpdateCustomerSpendLimitRequest$Outbound, UpdateCustomerSpendLimitRequest$outboundSchema, type UpdateCustomerSpendLimitResponse, UpdateCustomerSpendLimitResponse$inboundSchema, UpdateCustomerSpendLimitSource, UpdateCustomerSpendLimitSource$inboundSchema, UpdateCustomerStatus, UpdateCustomerStatus$inboundSchema, type UpdateCustomerStripe, UpdateCustomerStripe$inboundSchema, type UpdateCustomerSubscription, UpdateCustomerSubscription$inboundSchema, UpdateCustomerSubscriptionScope, UpdateCustomerSubscriptionScope$inboundSchema, UpdateCustomerThresholdTypeRequestBody, UpdateCustomerThresholdTypeRequestBody$outboundSchema, UpdateCustomerThresholdTypeResponse, UpdateCustomerThresholdTypeResponse$inboundSchema, UpdateCustomerType, UpdateCustomerType$inboundSchema, type UpdateCustomerUsageAlertRequestBody, type UpdateCustomerUsageAlertRequestBody$Outbound, UpdateCustomerUsageAlertRequestBody$outboundSchema, type UpdateCustomerUsageAlertResponse, UpdateCustomerUsageAlertResponse$inboundSchema, UpdateCustomerUsageAlertSource, UpdateCustomerUsageAlertSource$inboundSchema, UpdateCustomerUsageLimitIntervalRequestBody, UpdateCustomerUsageLimitIntervalRequestBody$outboundSchema, UpdateCustomerUsageLimitIntervalResponse, UpdateCustomerUsageLimitIntervalResponse$inboundSchema, type UpdateCustomerUsageLimitRequest, type UpdateCustomerUsageLimitRequest$Outbound, UpdateCustomerUsageLimitRequest$outboundSchema, type UpdateCustomerUsageLimitResponse, UpdateCustomerUsageLimitResponse$inboundSchema, UpdateCustomerUsageLimitSource, UpdateCustomerUsageLimitSource$inboundSchema, type UpdateCustomerVercel, UpdateCustomerVercel$inboundSchema, type UpdateEntityBillingControlsRequest, type UpdateEntityBillingControlsRequest$Outbound, UpdateEntityBillingControlsRequest$outboundSchema, type UpdateEntityBillingControlsResponse, UpdateEntityBillingControlsResponse$inboundSchema, type UpdateEntityCreditSchema, UpdateEntityCreditSchema$inboundSchema, type UpdateEntityDisplay, UpdateEntityDisplay$inboundSchema, UpdateEntityEnv, UpdateEntityEnv$inboundSchema, type UpdateEntityFeature, UpdateEntityFeature$inboundSchema, type UpdateEntityFilterRequest, type UpdateEntityFilterRequest$Outbound, UpdateEntityFilterRequest$outboundSchema, type UpdateEntityFilterResponse, UpdateEntityFilterResponse$inboundSchema, type UpdateEntityFlags, UpdateEntityFlags$inboundSchema, type UpdateEntityGlobals, UpdateEntityIntervalRequestBody, UpdateEntityIntervalRequestBody$outboundSchema, UpdateEntityIntervalResponse, UpdateEntityIntervalResponse$inboundSchema, type UpdateEntityInvoice, UpdateEntityInvoice$inboundSchema, UpdateEntityLimitTypeRequestBody, UpdateEntityLimitTypeRequestBody$outboundSchema, UpdateEntityLimitTypeResponse, UpdateEntityLimitTypeResponse$inboundSchema, type UpdateEntityModelMarkups, UpdateEntityModelMarkups$inboundSchema, type UpdateEntityOverageAllowedRequest, type UpdateEntityOverageAllowedRequest$Outbound, UpdateEntityOverageAllowedRequest$outboundSchema, type UpdateEntityOverageAllowedResponse, UpdateEntityOverageAllowedResponse$inboundSchema, UpdateEntityOverageAllowedSource, UpdateEntityOverageAllowedSource$inboundSchema, type UpdateEntityParams, type UpdateEntityParams$Outbound, UpdateEntityParams$outboundSchema, UpdateEntityProcessorType, UpdateEntityProcessorType$inboundSchema, type UpdateEntityProperties, type UpdateEntityProperties$Outbound, UpdateEntityProperties$outboundSchema, type UpdateEntityProviderMarkups, UpdateEntityProviderMarkups$inboundSchema, type UpdateEntityPurchase, UpdateEntityPurchase$inboundSchema, UpdateEntityPurchaseScope, UpdateEntityPurchaseScope$inboundSchema, type UpdateEntityResponse, UpdateEntityResponse$inboundSchema, type UpdateEntitySpendLimitRequest, type UpdateEntitySpendLimitRequest$Outbound, UpdateEntitySpendLimitRequest$outboundSchema, type UpdateEntitySpendLimitResponse, UpdateEntitySpendLimitResponse$inboundSchema, UpdateEntitySpendLimitSource, UpdateEntitySpendLimitSource$inboundSchema, UpdateEntityStatus, UpdateEntityStatus$inboundSchema, type UpdateEntitySubscription, UpdateEntitySubscription$inboundSchema, UpdateEntitySubscriptionScope, UpdateEntitySubscriptionScope$inboundSchema, UpdateEntityThresholdTypeRequestBody, UpdateEntityThresholdTypeRequestBody$outboundSchema, UpdateEntityThresholdTypeResponse, UpdateEntityThresholdTypeResponse$inboundSchema, UpdateEntityType, UpdateEntityType$inboundSchema, type UpdateEntityUsageAlertRequestBody, type UpdateEntityUsageAlertRequestBody$Outbound, UpdateEntityUsageAlertRequestBody$outboundSchema, type UpdateEntityUsageAlertResponse, UpdateEntityUsageAlertResponse$inboundSchema, UpdateEntityUsageAlertSource, UpdateEntityUsageAlertSource$inboundSchema, type UpdateEntityUsageLimitRequest, type UpdateEntityUsageLimitRequest$Outbound, UpdateEntityUsageLimitRequest$outboundSchema, type UpdateEntityUsageLimitResponse, UpdateEntityUsageLimitResponse$inboundSchema, UpdateEntityUsageLimitSource, UpdateEntityUsageLimitSource$inboundSchema, type UpdateFeatureCreditSchemaRequestBody, type UpdateFeatureCreditSchemaRequestBody$Outbound, UpdateFeatureCreditSchemaRequestBody$outboundSchema, type UpdateFeatureCreditSchemaResponse, UpdateFeatureCreditSchemaResponse$inboundSchema, type UpdateFeatureDisplayRequestBody, type UpdateFeatureDisplayRequestBody$Outbound, UpdateFeatureDisplayRequestBody$outboundSchema, type UpdateFeatureDisplayResponse, UpdateFeatureDisplayResponse$inboundSchema, type UpdateFeatureGlobals, type UpdateFeatureModelMarkupsRequest, type UpdateFeatureModelMarkupsRequest$Outbound, UpdateFeatureModelMarkupsRequest$outboundSchema, type UpdateFeatureModelMarkupsResponse, UpdateFeatureModelMarkupsResponse$inboundSchema, type UpdateFeatureParams, type UpdateFeatureParams$Outbound, UpdateFeatureParams$outboundSchema, type UpdateFeatureProviderMarkupsRequest, type UpdateFeatureProviderMarkupsRequest$Outbound, UpdateFeatureProviderMarkupsRequest$outboundSchema, type UpdateFeatureProviderMarkupsResponse, UpdateFeatureProviderMarkupsResponse$inboundSchema, type UpdateFeatureResponse, UpdateFeatureResponse$inboundSchema, UpdateFeatureTypeRequestBody, UpdateFeatureTypeRequestBody$outboundSchema, UpdateFeatureTypeResponse, UpdateFeatureTypeResponse$inboundSchema, UpdatePlanAttachAction, UpdatePlanAttachAction$inboundSchema, type UpdatePlanAutoTopupRequest, type UpdatePlanAutoTopupRequest$Outbound, UpdatePlanAutoTopupRequest$outboundSchema, type UpdatePlanAutoTopupResponse, UpdatePlanAutoTopupResponse$inboundSchema, type UpdatePlanBasePriceRequest, type UpdatePlanBasePriceRequest$Outbound, UpdatePlanBasePriceRequest$outboundSchema, type UpdatePlanBasePriceResponse, UpdatePlanBasePriceResponse$inboundSchema, type UpdatePlanBillingControlsRequest, type UpdatePlanBillingControlsRequest$Outbound, UpdatePlanBillingControlsRequest$outboundSchema, type UpdatePlanBillingControlsResponse, UpdatePlanBillingControlsResponse$inboundSchema, type UpdatePlanConfigRequest, type UpdatePlanConfigRequest$Outbound, UpdatePlanConfigRequest$outboundSchema, type UpdatePlanConfigResponse, UpdatePlanConfigResponse$inboundSchema, type UpdatePlanCreditSchema, UpdatePlanCreditSchema$inboundSchema, type UpdatePlanCustomerEligibility, UpdatePlanCustomerEligibility$inboundSchema, type UpdatePlanCustomizeResponse, UpdatePlanCustomizeResponse$inboundSchema, UpdatePlanDurationTypeRequest, UpdatePlanDurationTypeRequest$outboundSchema, UpdatePlanDurationTypeResponse, UpdatePlanDurationTypeResponse$inboundSchema, UpdatePlanEnv, UpdatePlanEnv$inboundSchema, type UpdatePlanFeature, UpdatePlanFeature$inboundSchema, type UpdatePlanFeatureDisplay, UpdatePlanFeatureDisplay$inboundSchema, type UpdatePlanFilterRequest, type UpdatePlanFilterRequest$Outbound, UpdatePlanFilterRequest$outboundSchema, type UpdatePlanFilterResponse, UpdatePlanFilterResponse$inboundSchema, type UpdatePlanFreeTrial, UpdatePlanFreeTrial$inboundSchema, type UpdatePlanFreeTrialParamsRequest, type UpdatePlanFreeTrialParamsRequest$Outbound, UpdatePlanFreeTrialParamsRequest$outboundSchema, type UpdatePlanFreeTrialParamsResponse, UpdatePlanFreeTrialParamsResponse$inboundSchema, type UpdatePlanGlobals, UpdatePlanIntervalVariantDetailsRemoveItemEnum1, UpdatePlanIntervalVariantDetailsRemoveItemEnum1$inboundSchema, UpdatePlanIntervalVariantDetailsRemoveItemEnum2, UpdatePlanIntervalVariantDetailsRemoveItemEnum2$inboundSchema, type UpdatePlanItem, UpdatePlanItem$inboundSchema, UpdatePlanItemBillingMethodRequestBody, UpdatePlanItemBillingMethodRequestBody$outboundSchema, UpdatePlanItemBillingMethodResponse, UpdatePlanItemBillingMethodResponse$inboundSchema, type UpdatePlanItemDisplay, UpdatePlanItemDisplay$inboundSchema, UpdatePlanItemExpiryDurationTypeRequestBody, UpdatePlanItemExpiryDurationTypeRequestBody$outboundSchema, UpdatePlanItemExpiryDurationTypeResponse, UpdatePlanItemExpiryDurationTypeResponse$inboundSchema, UpdatePlanItemOnDecrease, UpdatePlanItemOnDecrease$outboundSchema, UpdatePlanItemOnIncrease, UpdatePlanItemOnIncrease$outboundSchema, type UpdatePlanItemPlanItem, type UpdatePlanItemPlanItem$Outbound, UpdatePlanItemPlanItem$outboundSchema, UpdatePlanItemPriceIntervalRequestBody, UpdatePlanItemPriceIntervalRequestBody$outboundSchema, type UpdatePlanItemPriceRequestBody, type UpdatePlanItemPriceRequestBody$Outbound, UpdatePlanItemPriceRequestBody$outboundSchema, type UpdatePlanItemPriceResponse, UpdatePlanItemPriceResponse$inboundSchema, type UpdatePlanItemProration, type UpdatePlanItemProration$Outbound, UpdatePlanItemProration$outboundSchema, UpdatePlanItemResetIntervalRequestBody, UpdatePlanItemResetIntervalRequestBody$outboundSchema, type UpdatePlanItemResetRequestBody, type UpdatePlanItemResetRequestBody$Outbound, UpdatePlanItemResetRequestBody$outboundSchema, type UpdatePlanItemResetResponse, UpdatePlanItemResetResponse$inboundSchema, type UpdatePlanItemRolloverRequestBody, type UpdatePlanItemRolloverRequestBody$Outbound, UpdatePlanItemRolloverRequestBody$outboundSchema, type UpdatePlanItemRolloverResponse, UpdatePlanItemRolloverResponse$inboundSchema, UpdatePlanItemTierBehaviorRequestBody, UpdatePlanItemTierBehaviorRequestBody$outboundSchema, UpdatePlanItemTierBehaviorResponse, UpdatePlanItemTierBehaviorResponse$inboundSchema, type UpdatePlanItemTierRequestBody, type UpdatePlanItemTierRequestBody$Outbound, UpdatePlanItemTierRequestBody$outboundSchema, type UpdatePlanItemTierResponse, UpdatePlanItemTierResponse$inboundSchema, type UpdatePlanItemToRequestBody, type UpdatePlanItemToRequestBody$Outbound, UpdatePlanItemToRequestBody$outboundSchema, type UpdatePlanItemToResponse, UpdatePlanItemToResponse$inboundSchema, UpdatePlanLimitTypeRequestBody, UpdatePlanLimitTypeRequestBody$outboundSchema, UpdatePlanLimitTypeResponse, UpdatePlanLimitTypeResponse$inboundSchema, UpdatePlanOnEndRequest, UpdatePlanOnEndRequest$outboundSchema, UpdatePlanOnEndResponse, UpdatePlanOnEndResponse$inboundSchema, type UpdatePlanOverageAllowedRequest, type UpdatePlanOverageAllowedRequest$Outbound, UpdatePlanOverageAllowedRequest$outboundSchema, type UpdatePlanOverageAllowedResponse, UpdatePlanOverageAllowedResponse$inboundSchema, type UpdatePlanParams, type UpdatePlanParams$Outbound, UpdatePlanParams$outboundSchema, type UpdatePlanPlanItemFilterResponse, UpdatePlanPlanItemFilterResponse$inboundSchema, type UpdatePlanPlanItemResponse, UpdatePlanPlanItemResponse$inboundSchema, type UpdatePlanPriceDisplay, UpdatePlanPriceDisplay$inboundSchema, UpdatePlanPriceIntervalRequestBody, UpdatePlanPriceIntervalRequestBody$outboundSchema, UpdatePlanPriceIntervalResponse, UpdatePlanPriceIntervalResponse$inboundSchema, UpdatePlanPriceItemIntervalResponse, UpdatePlanPriceItemIntervalResponse$inboundSchema, type UpdatePlanPriceResponse, UpdatePlanPriceResponse$inboundSchema, UpdatePlanPriceVariantDetailsInterval, UpdatePlanPriceVariantDetailsInterval$inboundSchema, type UpdatePlanProperties, type UpdatePlanProperties$Outbound, UpdatePlanProperties$outboundSchema, type UpdatePlanProrationResponse, UpdatePlanProrationResponse$inboundSchema, UpdatePlanPurchaseLimitIntervalRequestBody, UpdatePlanPurchaseLimitIntervalRequestBody$outboundSchema, UpdatePlanPurchaseLimitIntervalResponse, UpdatePlanPurchaseLimitIntervalResponse$inboundSchema, type UpdatePlanPurchaseLimitRequest, type UpdatePlanPurchaseLimitRequest$Outbound, UpdatePlanPurchaseLimitRequest$outboundSchema, type UpdatePlanPurchaseLimitResponse, UpdatePlanPurchaseLimitResponse$inboundSchema, UpdatePlanResetItemIntervalResponse, UpdatePlanResetItemIntervalResponse$inboundSchema, type UpdatePlanResponse, UpdatePlanResponse$inboundSchema, type UpdatePlanSpendLimitRequest, type UpdatePlanSpendLimitRequest$Outbound, UpdatePlanSpendLimitRequest$outboundSchema, type UpdatePlanSpendLimitResponse, UpdatePlanSpendLimitResponse$inboundSchema, UpdatePlanStatus, UpdatePlanStatus$inboundSchema, UpdatePlanThresholdTypeRequestBody, UpdatePlanThresholdTypeRequestBody$outboundSchema, UpdatePlanThresholdTypeResponse, UpdatePlanThresholdTypeResponse$inboundSchema, UpdatePlanType, UpdatePlanType$inboundSchema, type UpdatePlanUsageAlertRequestBody, type UpdatePlanUsageAlertRequestBody$Outbound, UpdatePlanUsageAlertRequestBody$outboundSchema, type UpdatePlanUsageAlertResponse, UpdatePlanUsageAlertResponse$inboundSchema, UpdatePlanUsageLimitIntervalRequestBody, UpdatePlanUsageLimitIntervalRequestBody$outboundSchema, UpdatePlanUsageLimitIntervalResponse, UpdatePlanUsageLimitIntervalResponse$inboundSchema, type UpdatePlanUsageLimitRequest, type UpdatePlanUsageLimitRequest$Outbound, UpdatePlanUsageLimitRequest$outboundSchema, type UpdatePlanUsageLimitResponse, UpdatePlanUsageLimitResponse$inboundSchema, type UpdatePlanVariantDetails, UpdatePlanVariantDetails$inboundSchema, UpdatePlanVariantDetailsAddItemBillingMethod, UpdatePlanVariantDetailsAddItemBillingMethod$inboundSchema, UpdatePlanVariantDetailsAddItemPriceInterval, UpdatePlanVariantDetailsAddItemPriceInterval$inboundSchema, type UpdatePlanVariantDetailsAutoTopup, UpdatePlanVariantDetailsAutoTopup$inboundSchema, type UpdatePlanVariantDetailsBillingControls, UpdatePlanVariantDetailsBillingControls$inboundSchema, UpdatePlanVariantDetailsDurationType, UpdatePlanVariantDetailsDurationType$inboundSchema, UpdatePlanVariantDetailsExpiryDurationType, UpdatePlanVariantDetailsExpiryDurationType$inboundSchema, type UpdatePlanVariantDetailsFilter, UpdatePlanVariantDetailsFilter$inboundSchema, type UpdatePlanVariantDetailsIntervalUnion, UpdatePlanVariantDetailsIntervalUnion$inboundSchema, UpdatePlanVariantDetailsLimitType, UpdatePlanVariantDetailsLimitType$inboundSchema, UpdatePlanVariantDetailsOnDecrease, UpdatePlanVariantDetailsOnDecrease$inboundSchema, UpdatePlanVariantDetailsOnEnd, UpdatePlanVariantDetailsOnEnd$inboundSchema, UpdatePlanVariantDetailsOnIncrease, UpdatePlanVariantDetailsOnIncrease$inboundSchema, type UpdatePlanVariantDetailsOverageAllowed, UpdatePlanVariantDetailsOverageAllowed$inboundSchema, type UpdatePlanVariantDetailsPrice, UpdatePlanVariantDetailsPrice$inboundSchema, type UpdatePlanVariantDetailsPurchaseLimit, UpdatePlanVariantDetailsPurchaseLimit$inboundSchema, UpdatePlanVariantDetailsPurchaseLimitInterval, UpdatePlanVariantDetailsPurchaseLimitInterval$inboundSchema, UpdatePlanVariantDetailsRemoveItemBillingMethod, UpdatePlanVariantDetailsRemoveItemBillingMethod$inboundSchema, type UpdatePlanVariantDetailsReset, UpdatePlanVariantDetailsReset$inboundSchema, UpdatePlanVariantDetailsResetInterval, UpdatePlanVariantDetailsResetInterval$inboundSchema, type UpdatePlanVariantDetailsRollover, UpdatePlanVariantDetailsRollover$inboundSchema, type UpdatePlanVariantDetailsSpendLimit, UpdatePlanVariantDetailsSpendLimit$inboundSchema, UpdatePlanVariantDetailsThresholdType, UpdatePlanVariantDetailsThresholdType$inboundSchema, type UpdatePlanVariantDetailsTier, UpdatePlanVariantDetailsTier$inboundSchema, UpdatePlanVariantDetailsTierBehavior, UpdatePlanVariantDetailsTierBehavior$inboundSchema, type UpdatePlanVariantDetailsTo, UpdatePlanVariantDetailsTo$inboundSchema, type UpdatePlanVariantDetailsUsageAlert, UpdatePlanVariantDetailsUsageAlert$inboundSchema, type UpdatePlanVariantDetailsUsageLimit, UpdatePlanVariantDetailsUsageLimit$inboundSchema, UpdatePlanVariantDetailsUsageLimitInterval, UpdatePlanVariantDetailsUsageLimitInterval$inboundSchema, type UpdateSubscriptionParams, type UpdateSubscriptionParams$Outbound, UpdateSubscriptionParams$outboundSchema, UsageAlertSource, UsageAlertSource$inboundSchema, UsageLimitSource, UsageLimitSource$inboundSchema, UsageModel1, UsageModel1$inboundSchema, UsageModel2, UsageModel2$inboundSchema, type Variant, type Variant$Outbound, Variant$outboundSchema, VariantAddItemBillingMethod, VariantAddItemBillingMethod$outboundSchema, VariantAddItemPriceInterval, VariantAddItemPriceInterval$outboundSchema, type VariantAutoTopup, type VariantAutoTopup$Outbound, VariantAutoTopup$outboundSchema, type VariantBasePrice, type VariantBasePrice$Outbound, VariantBasePrice$outboundSchema, type VariantBillingControls, type VariantBillingControls$Outbound, VariantBillingControls$outboundSchema, type VariantCustomize, type VariantCustomize$Outbound, VariantCustomize$outboundSchema, type VariantDetails, VariantDetails$inboundSchema, VariantDetailsExpiryDurationType, VariantDetailsExpiryDurationType$inboundSchema, VariantDetailsOnEnd, VariantDetailsOnEnd$inboundSchema, VariantDurationType, VariantDurationType$outboundSchema, VariantExpiryDurationType, VariantExpiryDurationType$outboundSchema, type VariantFilter, type VariantFilter$Outbound, VariantFilter$outboundSchema, type VariantFreeTrialParams, type VariantFreeTrialParams$Outbound, VariantFreeTrialParams$outboundSchema, type VariantIntervalUnion, type VariantIntervalUnion$Outbound, VariantIntervalUnion$outboundSchema, VariantLimitType, VariantLimitType$outboundSchema, type VariantMigration, type VariantMigration$Outbound, VariantMigration$outboundSchema, VariantOnDecrease, VariantOnDecrease$outboundSchema, VariantOnEnd, VariantOnEnd$outboundSchema, VariantOnIncrease, VariantOnIncrease$outboundSchema, type VariantOverageAllowed, type VariantOverageAllowed$Outbound, VariantOverageAllowed$outboundSchema, type VariantPlanItem, type VariantPlanItem$Outbound, VariantPlanItem$outboundSchema, type VariantPlanItemFilter, type VariantPlanItemFilter$Outbound, VariantPlanItemFilter$outboundSchema, type VariantPrice, type VariantPrice$Outbound, VariantPrice$outboundSchema, type VariantProperties, type VariantProperties$Outbound, VariantProperties$outboundSchema, type VariantProration, type VariantProration$Outbound, VariantProration$outboundSchema, type VariantPurchaseLimit, type VariantPurchaseLimit$Outbound, VariantPurchaseLimit$outboundSchema, VariantPurchaseLimitInterval, VariantPurchaseLimitInterval$outboundSchema, VariantRemoveItemBillingMethod, VariantRemoveItemBillingMethod$outboundSchema, type VariantReset, type VariantReset$Outbound, VariantReset$outboundSchema, VariantResetInterval, VariantResetInterval$outboundSchema, type VariantRollover, type VariantRollover$Outbound, VariantRollover$outboundSchema, type VariantSpendLimit, type VariantSpendLimit$Outbound, VariantSpendLimit$outboundSchema, VariantThresholdType, VariantThresholdType$outboundSchema, type VariantTier, type VariantTier$Outbound, VariantTier$outboundSchema, VariantTierBehavior, VariantTierBehavior$outboundSchema, type VariantTo, type VariantTo$Outbound, VariantTo$outboundSchema, type VariantUsageAlert, type VariantUsageAlert$Outbound, VariantUsageAlert$outboundSchema, type VariantUsageLimit, type VariantUsageLimit$Outbound, VariantUsageLimit$outboundSchema, VariantUsageLimitInterval, VariantUsageLimitInterval$outboundSchema, type Vercel, Vercel$inboundSchema, aggregateEventsCustomRangeToJSON, aggregateEventsFeatureIdToJSON, aggregateEventsListFromJSON, aggregateEventsResponseFromJSON, apiKeyFromJSON, attachAddItemPlanItemToJSON, attachAddItemPriceToJSON, attachAddItemProrationToJSON, attachAddItemResetToJSON, attachAddItemRolloverToJSON, attachAddItemTierToJSON, attachAddItemToToJSON, attachAttachDiscountToJSON, attachAutoTopupToJSON, attachBasePriceToJSON, attachBillingControlsToJSON, attachCarryOverBalancesToJSON, attachCarryOverUsagesToJSON, attachCustomLineItemToJSON, attachCustomizeToJSON, attachFeatureQuantityToJSON, attachFilterToJSON, attachFreeTrialParamsToJSON, attachIntervalUnionToJSON, attachInvoiceFromJSON, attachInvoiceModeToJSON, attachItemPlanItemToJSON, attachItemPriceToJSON, attachItemProrationToJSON, attachItemResetToJSON, attachItemRolloverToJSON, attachItemTierToJSON, attachItemToToJSON, attachOverageAllowedToJSON, attachParamsToJSON, attachPlanItemFilterToJSON, attachPropertiesToJSON, attachPurchaseLimitToJSON, attachRequiredActionFromJSON, attachResponseFromJSON, attachSpendLimitToJSON, attachUsageAlertToJSON, attachUsageLimitToJSON, balanceCreditSchemaFromJSON, balanceDisplayFromJSON, balanceFeatureFromJSON, balanceFromJSON, balanceIntervalUnionFromJSON, balanceModelMarkupsFromJSON, balancePriceFromJSON, balanceProviderMarkupsFromJSON, balanceResetFromJSON, balanceRolloverFromJSON, balanceTierFromJSON, balanceToFromJSON, basePriceFromJSON, batchTrackLockToJSON, batchTrackResponseFromJSON, billableToJSON, billingUpdateAddItemPlanItemToJSON, billingUpdateAddItemPriceToJSON, billingUpdateAddItemProrationToJSON, billingUpdateAddItemResetToJSON, billingUpdateAddItemRolloverToJSON, billingUpdateAddItemTierToJSON, billingUpdateAddItemToToJSON, billingUpdateAttachDiscountToJSON, billingUpdateAutoTopupToJSON, billingUpdateBasePriceToJSON, billingUpdateBillingControlsToJSON, billingUpdateCarryOverUsagesToJSON, billingUpdateCustomizeToJSON, billingUpdateFeatureQuantityToJSON, billingUpdateFilterToJSON, billingUpdateFreeTrialParamsToJSON, billingUpdateIntervalUnionToJSON, billingUpdateInvoiceFromJSON, billingUpdateInvoiceModeToJSON, billingUpdateItemPlanItemToJSON, billingUpdateItemPriceToJSON, billingUpdateItemProrationToJSON, billingUpdateItemResetToJSON, billingUpdateItemRolloverToJSON, billingUpdateItemTierToJSON, billingUpdateItemToToJSON, billingUpdateOverageAllowedToJSON, billingUpdatePlanItemFilterToJSON, billingUpdatePropertiesToJSON, billingUpdatePurchaseLimitToJSON, billingUpdateRecalculateBalancesToJSON, billingUpdateRequiredActionFromJSON, billingUpdateResponseFromJSON, billingUpdateSpendLimitToJSON, billingUpdateUsageAlertToJSON, billingUpdateUsageLimitToJSON, breakdownFromJSON, checkAutoTopup1FromJSON, checkAutoTopup2FromJSON, checkBillingControls1FromJSON, checkBillingControls2FromJSON, checkConfig1FromJSON, checkConfig2FromJSON, checkCreditSchema1FromJSON, checkCreditSchema2FromJSON, checkFeature1FromJSON, checkFeature2FromJSON, checkFilter1FromJSON, checkFilter2FromJSON, checkFreeTrial1FromJSON, checkFreeTrial2FromJSON, checkItem1FromJSON, checkItem2FromJSON, checkLockToJSON, checkModelMarkups1FromJSON, checkModelMarkups2FromJSON, checkOverageAllowed1FromJSON, checkOverageAllowed2FromJSON, checkParamsToJSON, checkProduct1FromJSON, checkProduct2FromJSON, checkProperties1FromJSON, checkProperties2FromJSON, checkProviderMarkups1FromJSON, checkProviderMarkups2FromJSON, checkPurchaseLimit1FromJSON, checkPurchaseLimit2FromJSON, checkResponseBody1FromJSON, checkResponseBody2FromJSON, checkResponseFromJSON, checkRollover1FromJSON, checkRollover2FromJSON, checkSpendLimit1FromJSON, checkSpendLimit2FromJSON, checkUsageAlert1FromJSON, checkUsageAlert2FromJSON, checkUsageLimit1FromJSON, checkUsageLimit2FromJSON, couponFromJSON, couponPromoCodeFromJSON, createBalanceParamsToJSON, createBalanceResetToJSON, createBalanceResponseFromJSON, createBalanceRolloverToJSON, createEntityBillingControlsRequestToJSON, createEntityBillingControlsResponseFromJSON, createEntityCreditSchemaFromJSON, createEntityDisplayFromJSON, createEntityFeatureFromJSON, createEntityFilterRequestToJSON, createEntityFilterResponseFromJSON, createEntityFlagsFromJSON, createEntityInvoiceFromJSON, createEntityModelMarkupsFromJSON, createEntityOverageAllowedRequestToJSON, createEntityOverageAllowedResponseFromJSON, createEntityParamsToJSON, createEntityPropertiesToJSON, createEntityProviderMarkupsFromJSON, createEntityPurchaseFromJSON, createEntityResponseFromJSON, createEntitySpendLimitRequestToJSON, createEntitySpendLimitResponseFromJSON, createEntitySubscriptionFromJSON, createEntityUsageAlertRequestBodyToJSON, createEntityUsageAlertResponseFromJSON, createEntityUsageLimitRequestToJSON, createEntityUsageLimitResponseFromJSON, createFeatureCreditSchemaRequestBodyToJSON, createFeatureCreditSchemaResponseFromJSON, createFeatureDisplayRequestBodyToJSON, createFeatureDisplayResponseFromJSON, createFeatureModelMarkupsRequestToJSON, createFeatureModelMarkupsResponseFromJSON, createFeatureParamsToJSON, createFeatureProviderMarkupsRequestToJSON, createFeatureProviderMarkupsResponseFromJSON, createFeatureResponseFromJSON, createPlanAutoTopupRequestToJSON, createPlanAutoTopupResponseFromJSON, createPlanBasePriceFromJSON, createPlanBillingControlsRequestToJSON, createPlanBillingControlsResponseFromJSON, createPlanConfigRequestToJSON, createPlanConfigResponseFromJSON, createPlanCreditSchemaFromJSON, createPlanCustomerEligibilityFromJSON, createPlanCustomizeFromJSON, createPlanFeatureDisplayFromJSON, createPlanFeatureFromJSON, createPlanFilterRequestToJSON, createPlanFilterResponseFromJSON, createPlanFreeTrialParamsFromJSON, createPlanFreeTrialResponseFromJSON, createPlanIntervalUnionFromJSON, createPlanItemDisplayFromJSON, createPlanItemFromJSON, createPlanItemPlanItemToJSON, createPlanItemPriceRequestBodyToJSON, createPlanItemPriceResponseFromJSON, createPlanItemProrationToJSON, createPlanItemResetResponseFromJSON, createPlanItemRolloverResponseFromJSON, createPlanItemTierResponseFromJSON, createPlanItemToResponseFromJSON, createPlanOverageAllowedRequestToJSON, createPlanOverageAllowedResponseFromJSON, createPlanParamsToJSON, createPlanPlanItemFilterFromJSON, createPlanPlanItemResponseFromJSON, createPlanPriceDisplayFromJSON, createPlanPriceRequestBodyToJSON, createPlanPriceResponseFromJSON, createPlanPropertiesToJSON, createPlanProrationResponseFromJSON, createPlanPurchaseLimitRequestToJSON, createPlanPurchaseLimitResponseFromJSON, createPlanResetRequestBodyToJSON, createPlanResponseFromJSON, createPlanRolloverRequestBodyToJSON, createPlanSpendLimitRequestToJSON, createPlanSpendLimitResponseFromJSON, createPlanTierRequestBodyToJSON, createPlanToRequestBodyToJSON, createPlanUsageAlertRequestBodyToJSON, createPlanUsageAlertResponseFromJSON, createPlanUsageLimitRequestToJSON, createPlanUsageLimitResponseFromJSON, createPlanVariantDetailsAutoTopupFromJSON, createPlanVariantDetailsBillingControlsFromJSON, createPlanVariantDetailsFilterFromJSON, createPlanVariantDetailsFromJSON, createPlanVariantDetailsOverageAllowedFromJSON, createPlanVariantDetailsPriceFromJSON, createPlanVariantDetailsPurchaseLimitFromJSON, createPlanVariantDetailsResetFromJSON, createPlanVariantDetailsRolloverFromJSON, createPlanVariantDetailsSpendLimitFromJSON, createPlanVariantDetailsTierFromJSON, createPlanVariantDetailsToFromJSON, createPlanVariantDetailsUsageAlertFromJSON, createPlanVariantDetailsUsageLimitFromJSON, createReferralCodeParamsToJSON, createReferralCodeResponseFromJSON, createScheduleAddItemPlanItem2ToJSON, createScheduleAddItemPrice2ToJSON, createScheduleAddItemProration2ToJSON, createScheduleAddItemReset2ToJSON, createScheduleAddItemRollover2ToJSON, createScheduleAddItemTier2ToJSON, createScheduleAttachDiscountToJSON, createScheduleAutoTopup2ToJSON, createScheduleBasePrice2ToJSON, createScheduleBillingControls2ToJSON, createScheduleCustomize2ToJSON, createScheduleFeatureQuantity2ToJSON, createScheduleFilter2ToJSON, createScheduleIntervalUnion2ToJSON, createScheduleInvoiceFromJSON, createScheduleInvoiceModeToJSON, createScheduleItemPlanItem2ToJSON, createScheduleItemPrice2ToJSON, createScheduleItemProration2ToJSON, createScheduleItemReset2ToJSON, createScheduleItemRollover2ToJSON, createScheduleItemTier2ToJSON, createScheduleOverageAllowed2ToJSON, createScheduleParamsToJSON, createSchedulePlan2ToJSON, createSchedulePlanItemFilter2ToJSON, createSchedulePurchaseLimit2ToJSON, createScheduleRequiredActionFromJSON, createScheduleResponseFromJSON, createScheduleSpendLimit2ToJSON, createScheduleUsageAlert2ToJSON, createScheduleUsageLimit2ToJSON, customerAutoTopupFromJSON, customerBillingControlsFromJSON, customerConfigFromJSON, customerCreditSchemaFromJSON, customerDataAutoTopupToJSON, customerDataBillingControlsToJSON, customerDataConfigToJSON, customerDataFilterToJSON, customerDataOverageAllowedToJSON, customerDataPurchaseLimitToJSON, customerDataSpendLimitToJSON, customerDataToJSON, customerDataUsageAlertToJSON, customerDataUsageLimitToJSON, customerDisplayFromJSON, customerEligibilityFromJSON, customerFeatureFromJSON, customerFilterFromJSON, customerFromJSON, customerModelMarkupsFromJSON, customerOverageAllowedFromJSON, customerProviderMarkupsFromJSON, customerPurchaseLimit1FromJSON, customerPurchaseLimit2FromJSON, customerPurchaseLimitUnionFromJSON, customerSpendLimitFromJSON, customerUsageAlertFromJSON, customerUsageLimitFromJSON, customizeFromJSON, deductionsFromJSON, deleteBalanceParamsToJSON, deleteBalanceResponseFromJSON, deleteCustomerParamsToJSON, deleteCustomerResponseFromJSON, deleteEntityParamsToJSON, deleteEntityResponseFromJSON, deleteFeatureParamsToJSON, deleteFeatureResponseFromJSON, deletePlanParamsToJSON, deletePlanResponseFromJSON, dfuFlashParamsToJSON, dfuFlashResultFromJSON, discountFromJSON, entitlementsGrantedFromJSON, entityFromJSON, eventsAggregateParamsToJSON, eventsListParamsToJSON, expiryFromJSON, featureGrantFromJSON, featureGrantPromoCodeFromJSON, files, finalizeBalanceParamsToJSON, finalizeLockResponseBody1FromJSON, finalizeLockResponseBody2FromJSON, finalizeLockResponseFromJSON, flag1FromJSON, flag2FromJSON, flagDisplay1FromJSON, flagDisplay2FromJSON, flagsFromJSON, flashedFromJSON, formatZodError, freeTrialFromJSON, freeTrialParamsFromJSON, freeTrialRequestToJSON, getCustomerAutoTopupFromJSON, getCustomerBillingControlsFromJSON, getCustomerConfigFromJSON, getCustomerCreditSchemaFromJSON, getCustomerCustomerFromJSON, getCustomerDiscountFromJSON, getCustomerDisplayFromJSON, getCustomerEntityFromJSON, getCustomerFeatureFromJSON, getCustomerFilterFromJSON, getCustomerFlagsFromJSON, getCustomerInvoiceFromJSON, getCustomerModelMarkupsFromJSON, getCustomerOverageAllowedFromJSON, getCustomerParamsToJSON, getCustomerProcessorsFromJSON, getCustomerProviderMarkupsFromJSON, getCustomerPurchaseFromJSON, getCustomerPurchaseLimit1FromJSON, getCustomerPurchaseLimit2FromJSON, getCustomerPurchaseLimitUnionFromJSON, getCustomerReferralFromJSON, getCustomerResponseFromJSON, getCustomerRevenuecatFromJSON, getCustomerRewardsFromJSON, getCustomerSpendLimitFromJSON, getCustomerStripeFromJSON, getCustomerSubscriptionFromJSON, getCustomerTrialsUsedFromJSON, getCustomerUsageAlertFromJSON, getCustomerUsageLimitFromJSON, getCustomerVercelFromJSON, getEntityBillingControlsFromJSON, getEntityCreditSchemaFromJSON, getEntityDisplayFromJSON, getEntityFeatureFromJSON, getEntityFilterFromJSON, getEntityFlagsFromJSON, getEntityInvoiceFromJSON, getEntityModelMarkupsFromJSON, getEntityOverageAllowedFromJSON, getEntityParamsToJSON, getEntityProviderMarkupsFromJSON, getEntityPurchaseFromJSON, getEntityResponseFromJSON, getEntitySpendLimitFromJSON, getEntitySubscriptionFromJSON, getEntityUsageAlertFromJSON, getEntityUsageLimitFromJSON, getFeatureCreditSchemaFromJSON, getFeatureDisplayFromJSON, getFeatureModelMarkupsFromJSON, getFeatureParamsToJSON, getFeatureProviderMarkupsFromJSON, getFeatureResponseFromJSON, getOrCreateCustomerAutoTopupToJSON, getOrCreateCustomerBillingControlsToJSON, getOrCreateCustomerConfigToJSON, getOrCreateCustomerFilterToJSON, getOrCreateCustomerOverageAllowedToJSON, getOrCreateCustomerParamsToJSON, getOrCreateCustomerPropertiesToJSON, getOrCreateCustomerPurchaseLimitToJSON, getOrCreateCustomerSpendLimitToJSON, getOrCreateCustomerUsageAlertToJSON, getOrCreateCustomerUsageLimitToJSON, getPlanAutoTopupFromJSON, getPlanBasePriceFromJSON, getPlanBillingControlsFromJSON, getPlanConfigFromJSON, getPlanCreditSchemaFromJSON, getPlanCustomerEligibilityFromJSON, getPlanCustomizeFromJSON, getPlanFeatureDisplayFromJSON, getPlanFeatureFromJSON, getPlanFilterFromJSON, getPlanFreeTrialFromJSON, getPlanFreeTrialParamsFromJSON, getPlanIntervalUnionFromJSON, getPlanItemDisplayFromJSON, getPlanItemFromJSON, getPlanItemPriceFromJSON, getPlanItemResetFromJSON, getPlanItemRolloverFromJSON, getPlanItemTierFromJSON, getPlanItemToFromJSON, getPlanOverageAllowedFromJSON, getPlanParamsToJSON, getPlanPlanItemFilterFromJSON, getPlanPlanItemFromJSON, getPlanPriceDisplayFromJSON, getPlanPriceFromJSON, getPlanProrationFromJSON, getPlanPurchaseLimitFromJSON, getPlanResponseFromJSON, getPlanSpendLimitFromJSON, getPlanUsageAlertFromJSON, getPlanUsageLimitFromJSON, getPlanVariantDetailsAutoTopupFromJSON, getPlanVariantDetailsBillingControlsFromJSON, getPlanVariantDetailsFilterFromJSON, getPlanVariantDetailsFromJSON, getPlanVariantDetailsOverageAllowedFromJSON, getPlanVariantDetailsPriceFromJSON, getPlanVariantDetailsPurchaseLimitFromJSON, getPlanVariantDetailsResetFromJSON, getPlanVariantDetailsRolloverFromJSON, getPlanVariantDetailsSpendLimitFromJSON, getPlanVariantDetailsTierFromJSON, getPlanVariantDetailsToFromJSON, getPlanVariantDetailsUsageAlertFromJSON, getPlanVariantDetailsUsageLimitFromJSON, getRevenueCatKeysAppFromJSON, getRevenueCatKeysParamsToJSON, getRevenueCatKeysResponseFromJSON, grantFromJSON, importBalanceToJSON, importCustomerDataToJSON, importFeatureQuantityToJSON, importFilterToJSON, importPlanToJSON, importProcessorToJSON, includedUsage1FromJSON, includedUsage2FromJSON, invoiceFromJSON, itemFromJSON, linkRevenueCatParamsToJSON, linkRevenueCatResponseFromJSON, linkToJSON, listCustomersAutoTopupFromJSON, listCustomersBillingControlsFromJSON, listCustomersConfigFromJSON, listCustomersCreditSchemaFromJSON, listCustomersDisplayFromJSON, listCustomersFeatureFromJSON, listCustomersFilterFromJSON, listCustomersFlagsFromJSON, listCustomersListFromJSON, listCustomersModelMarkupsFromJSON, listCustomersOverageAllowedFromJSON, listCustomersParamsToJSON, listCustomersPlanToJSON, listCustomersProcessorsFromJSON, listCustomersProviderMarkupsFromJSON, listCustomersPurchaseFromJSON, listCustomersPurchaseLimit1FromJSON, listCustomersPurchaseLimit2FromJSON, listCustomersPurchaseLimitUnionFromJSON, listCustomersResponseFromJSON, listCustomersRevenuecatFromJSON, listCustomersSpendLimitFromJSON, listCustomersStripeFromJSON, listCustomersSubscriptionFromJSON, listCustomersUsageAlertFromJSON, listCustomersUsageLimitFromJSON, listCustomersVercelFromJSON, listEntitiesBillingControlsFromJSON, listEntitiesCreditSchemaFromJSON, listEntitiesDisplayFromJSON, listEntitiesFeatureFromJSON, listEntitiesFilterFromJSON, listEntitiesFlagsFromJSON, listEntitiesInvoiceFromJSON, listEntitiesListFromJSON, listEntitiesModelMarkupsFromJSON, listEntitiesOverageAllowedFromJSON, listEntitiesParamsToJSON, listEntitiesPlanToJSON, listEntitiesProviderMarkupsFromJSON, listEntitiesPurchaseFromJSON, listEntitiesResponseFromJSON, listEntitiesSpendLimitFromJSON, listEntitiesSubscriptionFromJSON, listEntitiesUsageAlertFromJSON, listEntitiesUsageLimitFromJSON, listEventsCustomRangeToJSON, listEventsFeatureIdToJSON, listEventsIntervalUnionFromJSON, listEventsListFromJSON, listEventsResetFromJSON, listEventsResponseFromJSON, listFeaturesCreditSchemaFromJSON, listFeaturesDisplayFromJSON, listFeaturesListFromJSON, listFeaturesModelMarkupsFromJSON, listFeaturesProviderMarkupsFromJSON, listFeaturesRequestToJSON, listFeaturesResponseFromJSON, listPlansAutoTopupFromJSON, listPlansBasePriceFromJSON, listPlansBillingControlsFromJSON, listPlansConfigFromJSON, listPlansCreditSchemaFromJSON, listPlansCustomerEligibilityFromJSON, listPlansCustomizeFromJSON, listPlansFeatureDisplayFromJSON, listPlansFeatureFromJSON, listPlansFilterFromJSON, listPlansFreeTrialFromJSON, listPlansFreeTrialParamsFromJSON, listPlansIntervalUnionFromJSON, listPlansItemDisplayFromJSON, listPlansItemFromJSON, listPlansItemPriceFromJSON, listPlansItemResetFromJSON, listPlansItemRolloverFromJSON, listPlansItemTierFromJSON, listPlansListFromJSON, listPlansOverageAllowedFromJSON, listPlansParamsToJSON, listPlansPlanItemFilterFromJSON, listPlansPlanItemFromJSON, listPlansPriceDisplayFromJSON, listPlansPriceFromJSON, listPlansProrationFromJSON, listPlansPurchaseLimitFromJSON, listPlansResponseFromJSON, listPlansSpendLimitFromJSON, listPlansToFromJSON, listPlansUsageAlertFromJSON, listPlansUsageLimitFromJSON, listPlansVariantDetailsAutoTopupFromJSON, listPlansVariantDetailsBillingControlsFromJSON, listPlansVariantDetailsFilterFromJSON, listPlansVariantDetailsFromJSON, listPlansVariantDetailsOverageAllowedFromJSON, listPlansVariantDetailsPriceFromJSON, listPlansVariantDetailsPurchaseLimitFromJSON, listPlansVariantDetailsResetFromJSON, listPlansVariantDetailsRolloverFromJSON, listPlansVariantDetailsSpendLimitFromJSON, listPlansVariantDetailsTierFromJSON, listPlansVariantDetailsUsageAlertFromJSON, listPlansVariantDetailsUsageLimitFromJSON, listRewardsDurationFromJSON, listRewardsResponseFromJSON, migrationToJSON, mintKeyParamsToJSON, mintKeyResponseFromJSON, multiAttachAttachDiscountToJSON, multiAttachBasePriceToJSON, multiAttachBillingControlsToJSON, multiAttachCustomizeToJSON, multiAttachEntityDataToJSON, multiAttachFeatureQuantityToJSON, multiAttachFilterToJSON, multiAttachFreeTrialParamsToJSON, multiAttachInvoiceFromJSON, multiAttachInvoiceModeToJSON, multiAttachOverageAllowedToJSON, multiAttachParamsToJSON, multiAttachPlanItemToJSON, multiAttachPlanToJSON, multiAttachPriceToJSON, multiAttachPropertiesToJSON, multiAttachProrationToJSON, multiAttachRequiredActionFromJSON, multiAttachResetToJSON, multiAttachResponseFromJSON, multiAttachRolloverToJSON, multiAttachSpendLimitToJSON, multiAttachTierToJSON, multiAttachToToJSON, multiAttachUsageAlertToJSON, multiAttachUsageLimitToJSON, multiUpdateInvoiceFromJSON, multiUpdateParamsToJSON, multiUpdatePreviewResponseFromJSON, multiUpdateRequiredActionFromJSON, multiUpdateResponseFromJSON, multiUpdateUpdateToJSON, openCustomerPortalParamsToJSON, openCustomerPortalResponseFromJSON, phaseResponseFromJSON, phaseStartToJSON, phaseStartUnionToJSON, planAutoTopupFromJSON, planBillingControlsFromJSON, planConfigFromJSON, planCreditSchemaFromJSON, planFeatureDisplayFromJSON, planFeatureFromJSON, planFilterFromJSON, planFromJSON, planIntervalUnionFromJSON, planItemDisplayFromJSON, planItemFilterFromJSON, planItemFromJSON, planItemPriceFromJSON, planItemResetFromJSON, planItemRolloverFromJSON, planItemTierFromJSON, planItemToFromJSON, planOverageAllowedFromJSON, planPriceDisplayFromJSON, planPriceFromJSON, planPurchaseLimitFromJSON, planSpendLimitFromJSON, planUsageAlertFromJSON, planUsageLimitFromJSON, planVariantDetailsAutoTopupFromJSON, planVariantDetailsBillingControlsFromJSON, planVariantDetailsFilterFromJSON, planVariantDetailsOverageAllowedFromJSON, planVariantDetailsPriceFromJSON, planVariantDetailsPurchaseLimitFromJSON, planVariantDetailsResetFromJSON, planVariantDetailsRolloverFromJSON, planVariantDetailsSpendLimitFromJSON, planVariantDetailsTierFromJSON, planVariantDetailsToFromJSON, planVariantDetailsUsageAlertFromJSON, planVariantDetailsUsageLimitFromJSON, preview1FromJSON, preview2FromJSON, previewAttachAddItemPlanItemToJSON, previewAttachAddItemPriceToJSON, previewAttachAddItemProrationToJSON, previewAttachAddItemResetToJSON, previewAttachAddItemRolloverToJSON, previewAttachAddItemTierToJSON, previewAttachAddItemToToJSON, previewAttachAttachDiscountToJSON, previewAttachAutoTopupToJSON, previewAttachBasePriceToJSON, previewAttachBillingControlsToJSON, previewAttachCarryOverBalancesToJSON, previewAttachCarryOverUsagesToJSON, previewAttachCustomLineItemToJSON, previewAttachCustomizeToJSON, previewAttachDiscountFromJSON, previewAttachFeatureQuantityRequestToJSON, previewAttachFilterToJSON, previewAttachFreeTrialParamsToJSON, previewAttachIncomingFeatureQuantityFromJSON, previewAttachIncomingFromJSON, previewAttachIntervalUnionToJSON, previewAttachInvoiceCreditsFromJSON, previewAttachInvoiceModeToJSON, previewAttachItemPlanItemToJSON, previewAttachItemPriceToJSON, previewAttachItemProrationToJSON, previewAttachItemResetToJSON, previewAttachItemRolloverToJSON, previewAttachItemTierToJSON, previewAttachItemToToJSON, previewAttachLineItemFromJSON, previewAttachLineItemPeriodFromJSON, previewAttachNextCycleDiscountFromJSON, previewAttachNextCycleFromJSON, previewAttachNextCycleLineItemFromJSON, previewAttachNextCycleLineItemPeriodFromJSON, previewAttachOutgoingFeatureQuantityFromJSON, previewAttachOutgoingFromJSON, previewAttachOverageAllowedToJSON, previewAttachParamsToJSON, previewAttachPlanItemFilterToJSON, previewAttachPropertiesToJSON, previewAttachPurchaseLimitToJSON, previewAttachResponseFromJSON, previewAttachSpendLimitToJSON, previewAttachTaxFromJSON, previewAttachUsageAlertToJSON, previewAttachUsageLimitToJSON, previewAttachUsageLineItemFromJSON, previewAttachUsageLineItemPeriodFromJSON, previewMultiAttachAttachDiscountToJSON, previewMultiAttachBasePriceToJSON, previewMultiAttachBillingControlsToJSON, previewMultiAttachCustomizeToJSON, previewMultiAttachDiscountFromJSON, previewMultiAttachEntityDataToJSON, previewMultiAttachFilterToJSON, previewMultiAttachFreeTrialParamsToJSON, previewMultiAttachIncomingFeatureQuantityFromJSON, previewMultiAttachIncomingFromJSON, previewMultiAttachInvoiceCreditsFromJSON, previewMultiAttachInvoiceModeToJSON, previewMultiAttachLineItemFromJSON, previewMultiAttachLineItemPeriodFromJSON, previewMultiAttachNextCycleDiscountFromJSON, previewMultiAttachNextCycleFromJSON, previewMultiAttachNextCycleLineItemFromJSON, previewMultiAttachNextCycleLineItemPeriodFromJSON, previewMultiAttachOutgoingFeatureQuantityFromJSON, previewMultiAttachOutgoingFromJSON, previewMultiAttachOverageAllowedToJSON, previewMultiAttachParamsToJSON, previewMultiAttachPlanFeatureQuantityToJSON, previewMultiAttachPlanItemToJSON, previewMultiAttachPlanToJSON, previewMultiAttachPriceToJSON, previewMultiAttachPropertiesToJSON, previewMultiAttachProrationToJSON, previewMultiAttachResetToJSON, previewMultiAttachResponseFromJSON, previewMultiAttachRolloverToJSON, previewMultiAttachSpendLimitToJSON, previewMultiAttachTaxFromJSON, previewMultiAttachTierToJSON, previewMultiAttachToToJSON, previewMultiAttachUsageAlertToJSON, previewMultiAttachUsageLimitToJSON, previewMultiAttachUsageLineItemFromJSON, previewMultiAttachUsageLineItemPeriodFromJSON, previewMultiUpdateDiscountFromJSON, previewMultiUpdateIncomingFeatureQuantityFromJSON, previewMultiUpdateIncomingFromJSON, previewMultiUpdateLineItemFromJSON, previewMultiUpdateLineItemPeriodFromJSON, previewMultiUpdateNextCycleDiscountFromJSON, previewMultiUpdateNextCycleFromJSON, previewMultiUpdateNextCycleLineItemFromJSON, previewMultiUpdateNextCycleLineItemPeriodFromJSON, previewMultiUpdateOutgoingFeatureQuantityFromJSON, previewMultiUpdateOutgoingFromJSON, previewMultiUpdateParamsToJSON, previewMultiUpdateSubscriptionFromJSON, previewMultiUpdateUpdateToJSON, previewMultiUpdateUsageLineItemFromJSON, previewMultiUpdateUsageLineItemPeriodFromJSON, previewUpdateAddItemPlanItemToJSON, previewUpdateAddItemPriceToJSON, previewUpdateAddItemProrationToJSON, previewUpdateAddItemResetToJSON, previewUpdateAddItemRolloverToJSON, previewUpdateAddItemTierToJSON, previewUpdateAddItemToToJSON, previewUpdateAttachDiscountToJSON, previewUpdateAutoTopupToJSON, previewUpdateBasePriceToJSON, previewUpdateBillingControlsToJSON, previewUpdateCarryOverUsagesToJSON, previewUpdateCustomizeToJSON, previewUpdateDiscountFromJSON, previewUpdateFeatureQuantityRequestToJSON, previewUpdateFilterToJSON, previewUpdateFreeTrialParamsToJSON, previewUpdateIncomingFeatureQuantityFromJSON, previewUpdateIncomingFromJSON, previewUpdateIntervalUnionToJSON, previewUpdateInvoiceCreditsFromJSON, previewUpdateInvoiceModeToJSON, previewUpdateItemPlanItemToJSON, previewUpdateItemPriceToJSON, previewUpdateItemProrationToJSON, previewUpdateItemResetToJSON, previewUpdateItemRolloverToJSON, previewUpdateItemTierToJSON, previewUpdateItemToToJSON, previewUpdateLineItemFromJSON, previewUpdateLineItemPeriodFromJSON, previewUpdateNextCycleDiscountFromJSON, previewUpdateNextCycleFromJSON, previewUpdateNextCycleLineItemFromJSON, previewUpdateNextCycleLineItemPeriodFromJSON, previewUpdateOutgoingFeatureQuantityFromJSON, previewUpdateOutgoingFromJSON, previewUpdateOverageAllowedToJSON, previewUpdateParamsToJSON, previewUpdatePlanItemFilterToJSON, previewUpdatePropertiesToJSON, previewUpdatePurchaseLimitToJSON, previewUpdateRecalculateBalancesToJSON, previewUpdateResponseFromJSON, previewUpdateSpendLimitToJSON, previewUpdateTaxFromJSON, previewUpdateUsageAlertToJSON, previewUpdateUsageLimitToJSON, previewUpdateUsageLineItemFromJSON, previewUpdateUsageLineItemPeriodFromJSON, processorsFromJSON, productDisplay1FromJSON, productDisplay2FromJSON, propertiesToJSON, prorationFromJSON, purchaseFromJSON, redeemReferralCodeParamsToJSON, redeemReferralCodeResponseFromJSON, redeemRewardCodeParamsToJSON, redeemRewardCodeResponseFromJSON, referralCustomerFromJSON, referralFromJSON, refreshKeyParamsToJSON, refreshKeyResponseFromJSON, requestBodyToJSON, resultFromJSON, revenuecatFromJSON, revokeKeyParamsToJSON, revokeKeyResponseFromJSON, rewardsFromJSON, rewardsListParamsToJSON, securityToJSON, serverURLFromOptions, setupPaymentAddItemPlanItemToJSON, setupPaymentAddItemPriceToJSON, setupPaymentAddItemProrationToJSON, setupPaymentAddItemResetToJSON, setupPaymentAddItemRolloverToJSON, setupPaymentAddItemTierToJSON, setupPaymentAddItemToToJSON, setupPaymentAttachDiscountToJSON, setupPaymentAutoTopupToJSON, setupPaymentBasePriceToJSON, setupPaymentBillingControlsToJSON, setupPaymentCarryOverBalancesToJSON, setupPaymentCarryOverUsagesToJSON, setupPaymentCustomLineItemToJSON, setupPaymentCustomizeToJSON, setupPaymentFeatureQuantityToJSON, setupPaymentFilterToJSON, setupPaymentFreeTrialParamsToJSON, setupPaymentIntervalUnionToJSON, setupPaymentItemPlanItemToJSON, setupPaymentItemPriceToJSON, setupPaymentItemProrationToJSON, setupPaymentItemResetToJSON, setupPaymentItemRolloverToJSON, setupPaymentItemTierToJSON, setupPaymentItemToToJSON, setupPaymentOverageAllowedToJSON, setupPaymentParamsToJSON, setupPaymentPlanItemFilterToJSON, setupPaymentPropertiesToJSON, setupPaymentPurchaseLimitToJSON, setupPaymentResponseFromJSON, setupPaymentSpendLimitToJSON, setupPaymentUsageAlertToJSON, setupPaymentUsageLimitToJSON, startingAfter2ToJSON, startsAt2ToJSON, stripeFromJSON, subscriptionFromJSON, syncRevenueCatAppFromJSON, syncRevenueCatParamsToJSON, syncRevenueCatResponseFromJSON, totalFromJSON, trackDeduction1FromJSON, trackDeduction2FromJSON, trackIntervalUnion1FromJSON, trackIntervalUnion2FromJSON, trackLockToJSON, trackParamsToJSON, trackReset1FromJSON, trackReset2FromJSON, trackResponseBody1FromJSON, trackResponseBody2FromJSON, trackResponseFromJSON, trackTokensDeduction1FromJSON, trackTokensDeduction2FromJSON, trackTokensIntervalUnion1FromJSON, trackTokensIntervalUnion2FromJSON, trackTokensParamsToJSON, trackTokensReset1FromJSON, trackTokensReset2FromJSON, trackTokensResponseBody1FromJSON, trackTokensResponseBody2FromJSON, trackTokensResponseFromJSON, trialsUsedFromJSON, index as types, updateBalanceParamsToJSON, updateBalanceResponseFromJSON, updateCustomerAutoTopupRequestToJSON, updateCustomerAutoTopupResponseFromJSON, updateCustomerBillingControlsRequestToJSON, updateCustomerBillingControlsResponseFromJSON, updateCustomerConfigRequestToJSON, updateCustomerConfigResponseFromJSON, updateCustomerCreditSchemaFromJSON, updateCustomerDisplayFromJSON, updateCustomerFeatureFromJSON, updateCustomerFilterRequestToJSON, updateCustomerFilterResponseFromJSON, updateCustomerFlagsFromJSON, updateCustomerModelMarkupsFromJSON, updateCustomerOverageAllowedRequestToJSON, updateCustomerOverageAllowedResponseFromJSON, updateCustomerParamsToJSON, updateCustomerProcessorsFromJSON, updateCustomerPropertiesToJSON, updateCustomerProviderMarkupsFromJSON, updateCustomerPurchaseFromJSON, updateCustomerPurchaseLimitRequestToJSON, updateCustomerPurchaseLimitResponse1FromJSON, updateCustomerPurchaseLimitResponse2FromJSON, updateCustomerPurchaseLimitUnionFromJSON, updateCustomerResponseFromJSON, updateCustomerRevenuecatFromJSON, updateCustomerSpendLimitRequestToJSON, updateCustomerSpendLimitResponseFromJSON, updateCustomerStripeFromJSON, updateCustomerSubscriptionFromJSON, updateCustomerUsageAlertRequestBodyToJSON, updateCustomerUsageAlertResponseFromJSON, updateCustomerUsageLimitRequestToJSON, updateCustomerUsageLimitResponseFromJSON, updateCustomerVercelFromJSON, updateEntityBillingControlsRequestToJSON, updateEntityBillingControlsResponseFromJSON, updateEntityCreditSchemaFromJSON, updateEntityDisplayFromJSON, updateEntityFeatureFromJSON, updateEntityFilterRequestToJSON, updateEntityFilterResponseFromJSON, updateEntityFlagsFromJSON, updateEntityInvoiceFromJSON, updateEntityModelMarkupsFromJSON, updateEntityOverageAllowedRequestToJSON, updateEntityOverageAllowedResponseFromJSON, updateEntityParamsToJSON, updateEntityPropertiesToJSON, updateEntityProviderMarkupsFromJSON, updateEntityPurchaseFromJSON, updateEntityResponseFromJSON, updateEntitySpendLimitRequestToJSON, updateEntitySpendLimitResponseFromJSON, updateEntitySubscriptionFromJSON, updateEntityUsageAlertRequestBodyToJSON, updateEntityUsageAlertResponseFromJSON, updateEntityUsageLimitRequestToJSON, updateEntityUsageLimitResponseFromJSON, updateFeatureCreditSchemaRequestBodyToJSON, updateFeatureCreditSchemaResponseFromJSON, updateFeatureDisplayRequestBodyToJSON, updateFeatureDisplayResponseFromJSON, updateFeatureModelMarkupsRequestToJSON, updateFeatureModelMarkupsResponseFromJSON, updateFeatureParamsToJSON, updateFeatureProviderMarkupsRequestToJSON, updateFeatureProviderMarkupsResponseFromJSON, updateFeatureResponseFromJSON, updatePlanAutoTopupRequestToJSON, updatePlanAutoTopupResponseFromJSON, updatePlanBasePriceRequestToJSON, updatePlanBasePriceResponseFromJSON, updatePlanBillingControlsRequestToJSON, updatePlanBillingControlsResponseFromJSON, updatePlanConfigRequestToJSON, updatePlanConfigResponseFromJSON, updatePlanCreditSchemaFromJSON, updatePlanCustomerEligibilityFromJSON, updatePlanCustomizeResponseFromJSON, updatePlanFeatureDisplayFromJSON, updatePlanFeatureFromJSON, updatePlanFilterRequestToJSON, updatePlanFilterResponseFromJSON, updatePlanFreeTrialFromJSON, updatePlanFreeTrialParamsRequestToJSON, updatePlanFreeTrialParamsResponseFromJSON, updatePlanItemDisplayFromJSON, updatePlanItemFromJSON, updatePlanItemPlanItemToJSON, updatePlanItemPriceRequestBodyToJSON, updatePlanItemPriceResponseFromJSON, updatePlanItemProrationToJSON, updatePlanItemResetRequestBodyToJSON, updatePlanItemResetResponseFromJSON, updatePlanItemRolloverRequestBodyToJSON, updatePlanItemRolloverResponseFromJSON, updatePlanItemTierRequestBodyToJSON, updatePlanItemTierResponseFromJSON, updatePlanItemToRequestBodyToJSON, updatePlanItemToResponseFromJSON, updatePlanOverageAllowedRequestToJSON, updatePlanOverageAllowedResponseFromJSON, updatePlanParamsToJSON, updatePlanPlanItemFilterResponseFromJSON, updatePlanPlanItemResponseFromJSON, updatePlanPriceDisplayFromJSON, updatePlanPriceResponseFromJSON, updatePlanPropertiesToJSON, updatePlanProrationResponseFromJSON, updatePlanPurchaseLimitRequestToJSON, updatePlanPurchaseLimitResponseFromJSON, updatePlanResponseFromJSON, updatePlanSpendLimitRequestToJSON, updatePlanSpendLimitResponseFromJSON, updatePlanUsageAlertRequestBodyToJSON, updatePlanUsageAlertResponseFromJSON, updatePlanUsageLimitRequestToJSON, updatePlanUsageLimitResponseFromJSON, updatePlanVariantDetailsAutoTopupFromJSON, updatePlanVariantDetailsBillingControlsFromJSON, updatePlanVariantDetailsFilterFromJSON, updatePlanVariantDetailsFromJSON, updatePlanVariantDetailsIntervalUnionFromJSON, updatePlanVariantDetailsOverageAllowedFromJSON, updatePlanVariantDetailsPriceFromJSON, updatePlanVariantDetailsPurchaseLimitFromJSON, updatePlanVariantDetailsResetFromJSON, updatePlanVariantDetailsRolloverFromJSON, updatePlanVariantDetailsSpendLimitFromJSON, updatePlanVariantDetailsTierFromJSON, updatePlanVariantDetailsToFromJSON, updatePlanVariantDetailsUsageAlertFromJSON, updatePlanVariantDetailsUsageLimitFromJSON, updateSubscriptionParamsToJSON, variantAutoTopupToJSON, variantBasePriceToJSON, variantBillingControlsToJSON, variantCustomizeToJSON, variantDetailsFromJSON, variantFilterToJSON, variantFreeTrialParamsToJSON, variantIntervalUnionToJSON, variantMigrationToJSON, variantOverageAllowedToJSON, variantPlanItemFilterToJSON, variantPlanItemToJSON, variantPriceToJSON, variantPropertiesToJSON, variantProrationToJSON, variantPurchaseLimitToJSON, variantResetToJSON, variantRolloverToJSON, variantSpendLimitToJSON, variantTierToJSON, variantToJSON, variantToToJSON, variantUsageAlertToJSON, variantUsageLimitToJSON, vercelFromJSON };