@peable.to/contracts 0.3.0 → 1.0.0

package/dist/types/resources/catalog/prices.d.ts

@@ -0,0 +1,1091 @@
+import { z } from 'zod';
+import { type Expand } from '../../common/objects';
+import { type PriceBillingScheme, type PriceTaxBehavior, type PriceTiersMode, type RecurringInterval, type RecurringUsageType, type TransformQuantityRound } from '../../vocabulary/catalog';
+import type { CurrencyCode } from '../../vocabulary/money';
+/**
+ * Prices (`price_…`, ADR 0018) — how much a product costs, in one currency,
+ * once or per interval. A price is never deleted and its amount never
+ * changes: archive it (`active: false`) and create another.
+ */
+/**
+ * One tier of a tiered price. `up_to` is the last quantity the tier covers
+ * (inclusive), and `null` on the last tier, which covers everything above —
+ * sent as `'inf'`. Each amount is a base-unit string; at least one is set.
+ */
+export declare const priceTierSchema: z.ZodObject<{
+    up_to: z.ZodNullable<z.ZodNumber>;
+    unit_amount: z.ZodNullable<z.ZodString>;
+    flat_amount: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type PriceTier = z.output<typeof priceTierSchema>;
+/**
+ * Divide the quantity before pricing it: `divide_by: 10, round: 'up'` bills
+ * 11 units as 2 packs of ten. Per-unit prices only.
+ */
+export declare const priceTransformQuantitySchema: z.ZodObject<{
+    divide_by: z.ZodNumber;
+    round: z.ZodEnum<{
+        up: "up";
+        down: "down";
+    }>;
+}, z.core.$strict>;
+export type PriceTransformQuantity = z.output<typeof priceTransformQuantitySchema>;
+export declare const priceRecurringSchema: z.ZodObject<{
+    interval: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+        year: "year";
+    }>;
+    interval_count: z.ZodNumber;
+    usage_type: z.ZodEnum<{
+        licensed: "licensed";
+        metered: "metered";
+    }>;
+    meter: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type PriceRecurring = z.output<typeof priceRecurringSchema>;
+export declare const priceSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"price">;
+    livemode: z.ZodBoolean;
+    active: z.ZodBoolean;
+    product: z.ZodType<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">, z.core.$ZodTypeInternals<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">>>;
+    currency: z.ZodEnum<{
+        FAIR: "FAIR";
+        EUR: "EUR";
+        USD: "USD";
+        GBP: "GBP";
+        CHF: "CHF";
+        SEK: "SEK";
+        NOK: "NOK";
+        DKK: "DKK";
+        PLN: "PLN";
+        CZK: "CZK";
+        CAD: "CAD";
+        AUD: "AUD";
+        JPY: "JPY";
+    }>;
+    unit_amount: z.ZodNullable<z.ZodString>;
+    billing_scheme: z.ZodEnum<{
+        per_unit: "per_unit";
+        tiered: "tiered";
+    }>;
+    tiers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        up_to: z.ZodNullable<z.ZodNumber>;
+        unit_amount: z.ZodNullable<z.ZodString>;
+        flat_amount: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+    tiers_mode: z.ZodNullable<z.ZodEnum<{
+        graduated: "graduated";
+        volume: "volume";
+    }>>;
+    transform_quantity: z.ZodNullable<z.ZodObject<{
+        divide_by: z.ZodNumber;
+        round: z.ZodEnum<{
+            up: "up";
+            down: "down";
+        }>;
+    }, z.core.$strict>>;
+    type: z.ZodEnum<{
+        one_time: "one_time";
+        recurring: "recurring";
+    }>;
+    recurring: z.ZodNullable<z.ZodObject<{
+        interval: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+            year: "year";
+        }>;
+        interval_count: z.ZodNumber;
+        usage_type: z.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
+        }>;
+        meter: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    tax_behavior: z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+        unspecified: "unspecified";
+    }>;
+    lookup_key: z.ZodNullable<z.ZodString>;
+    nickname: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+    created: z.ZodNumber;
+}, z.core.$strict>;
+export type Price = Expand<z.output<typeof priceSchema>>;
+declare module '../../common/objects' {
+    interface ObjectMap {
+        price: Price;
+    }
+}
+declare const recurringParams: z.ZodObject<{
+    interval: z.ZodEnum<{
+        day: "day";
+        week: "week";
+        month: "month";
+        year: "year";
+    }>;
+    interval_count: z.ZodOptional<z.ZodNumber>;
+    usage_type: z.ZodOptional<z.ZodEnum<{
+        licensed: "licensed";
+        metered: "metered";
+    }>>;
+    meter: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type RecurringParams = z.input<typeof recurringParams>;
+declare const tierParams: z.ZodObject<{
+    up_to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+    unit_amount: z.ZodOptional<z.ZodString>;
+    flat_amount: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type PriceTierParams = z.input<typeof tierParams>;
+declare const transformQuantityParams: z.ZodObject<{
+    divide_by: z.ZodNumber;
+    round: z.ZodEnum<{
+        up: "up";
+        down: "down";
+    }>;
+}, z.core.$strict>;
+/** A tier as a parsed request stores it. */
+export interface ParsedPriceTier {
+    up_to: number | null;
+    unit_amount: string | null;
+    flat_amount: string | null;
+}
+/** A price's shape as a parsed request decides it (the backend stores this). */
+export interface ParsedPriceShape {
+    readonly currency: CurrencyCode;
+    readonly unitAmount: string | null;
+    readonly billingScheme: PriceBillingScheme;
+    readonly tiers: readonly ParsedPriceTier[] | null;
+    readonly tiersMode: PriceTiersMode | null;
+    readonly transformQuantity: {
+        divideBy: number;
+        round: TransformQuantityRound;
+    } | null;
+    readonly recurring: {
+        interval: RecurringInterval;
+        intervalCount: number;
+        usageType: RecurringUsageType;
+        /** The `mtr_…` a request named, before the gateway resolves it. */
+        meterPublicId?: string;
+    } | null;
+    readonly taxBehavior: PriceTaxBehavior;
+}
+interface PriceShapeInput {
+    currency: CurrencyCode;
+    unit_amount?: string | undefined;
+    billing_scheme?: PriceBillingScheme | undefined;
+    tiers?: z.output<typeof tierParams>[] | undefined;
+    tiers_mode?: PriceTiersMode | undefined;
+    transform_quantity?: z.output<typeof transformQuantityParams> | undefined;
+    recurring?: (Partial<z.output<typeof recurringParams>> & Pick<z.output<typeof recurringParams>, 'interval'>) | undefined;
+    tax_behavior?: PriceTaxBehavior | undefined;
+}
+/**
+ * Decide the stored shape of a price from its request fields, adding an issue
+ * (with the field's path) for every rule it breaks. Returns `null` when any
+ * rule was broken. Amounts are bounded per currency by its decimals
+ * (`maxBaseUnits`).
+ */
+export declare function priceShapeOf(input: PriceShapeInput, ctx: z.RefinementCtx): ParsedPriceShape | null;
+/** `price_data` — an inline price of an existing product (`product: 'prod_…'`). */
+export declare const priceDataParams: z.ZodPipe<z.ZodObject<{
+    product: z.ZodString;
+    currency: z.ZodEnum<{
+        FAIR: "FAIR";
+        EUR: "EUR";
+        USD: "USD";
+        GBP: "GBP";
+        CHF: "CHF";
+        SEK: "SEK";
+        NOK: "NOK";
+        DKK: "DKK";
+        PLN: "PLN";
+        CZK: "CZK";
+        CAD: "CAD";
+        AUD: "AUD";
+        JPY: "JPY";
+    }>;
+    unit_amount: z.ZodString;
+    recurring: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    tax_behavior: z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+        unspecified: "unspecified";
+    }>>;
+}, z.core.$strict>, z.ZodTransform<{
+    product: string;
+    shape: ParsedPriceShape;
+}, {
+    product: string;
+    currency: "FAIR" | "EUR" | "USD" | "GBP" | "CHF" | "SEK" | "NOK" | "DKK" | "PLN" | "CZK" | "CAD" | "AUD" | "JPY";
+    unit_amount: string;
+    recurring?: {
+        interval: "day" | "week" | "month" | "year";
+        interval_count?: number | undefined;
+    } | undefined;
+    tax_behavior?: "inclusive" | "exclusive" | "unspecified" | undefined;
+}>>;
+export type PriceDataParams = z.input<typeof priceDataParams>;
+/** `default_price_data` on a product create — `price_data` for the product being made. */
+export declare const defaultPriceDataParams: z.ZodPipe<z.ZodObject<{
+    currency: z.ZodEnum<{
+        FAIR: "FAIR";
+        EUR: "EUR";
+        USD: "USD";
+        GBP: "GBP";
+        CHF: "CHF";
+        SEK: "SEK";
+        NOK: "NOK";
+        DKK: "DKK";
+        PLN: "PLN";
+        CZK: "CZK";
+        CAD: "CAD";
+        AUD: "AUD";
+        JPY: "JPY";
+    }>;
+    unit_amount: z.ZodString;
+    recurring: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    tax_behavior: z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+        unspecified: "unspecified";
+    }>>;
+}, z.core.$strict>, z.ZodTransform<ParsedPriceShape, {
+    currency: "FAIR" | "EUR" | "USD" | "GBP" | "CHF" | "SEK" | "NOK" | "DKK" | "PLN" | "CZK" | "CAD" | "AUD" | "JPY";
+    unit_amount: string;
+    recurring?: {
+        interval: "day" | "week" | "month" | "year";
+        interval_count?: number | undefined;
+    } | undefined;
+    tax_behavior?: "inclusive" | "exclusive" | "unspecified" | undefined;
+}>>;
+export type DefaultPriceDataParams = z.input<typeof defaultPriceDataParams>;
+export declare const createPriceParams: z.ZodPipe<z.ZodObject<{
+    product: z.ZodString;
+    lookup_key: z.ZodOptional<z.ZodString>;
+    transfer_lookup_key: z.ZodOptional<z.ZodBoolean>;
+    nickname: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<Record<string, string>, Record<string, string>>>>;
+    expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+    currency: z.ZodEnum<{
+        FAIR: "FAIR";
+        EUR: "EUR";
+        USD: "USD";
+        GBP: "GBP";
+        CHF: "CHF";
+        SEK: "SEK";
+        NOK: "NOK";
+        DKK: "DKK";
+        PLN: "PLN";
+        CZK: "CZK";
+        CAD: "CAD";
+        AUD: "AUD";
+        JPY: "JPY";
+    }>;
+    unit_amount: z.ZodOptional<z.ZodString>;
+    billing_scheme: z.ZodOptional<z.ZodEnum<{
+        per_unit: "per_unit";
+        tiered: "tiered";
+    }>>;
+    tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        up_to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+        unit_amount: z.ZodOptional<z.ZodString>;
+        flat_amount: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    tiers_mode: z.ZodOptional<z.ZodEnum<{
+        graduated: "graduated";
+        volume: "volume";
+    }>>;
+    transform_quantity: z.ZodOptional<z.ZodObject<{
+        divide_by: z.ZodNumber;
+        round: z.ZodEnum<{
+            up: "up";
+            down: "down";
+        }>;
+    }, z.core.$strict>>;
+    recurring: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+            year: "year";
+        }>;
+        interval_count: z.ZodOptional<z.ZodNumber>;
+        usage_type: z.ZodOptional<z.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
+        }>>;
+        meter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    tax_behavior: z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+        unspecified: "unspecified";
+    }>>;
+}, z.core.$strict>, z.ZodTransform<{
+    shape: ParsedPriceShape;
+    product: string;
+    currency: "FAIR" | "EUR" | "USD" | "GBP" | "CHF" | "SEK" | "NOK" | "DKK" | "PLN" | "CZK" | "CAD" | "AUD" | "JPY";
+    lookup_key?: string | undefined;
+    transfer_lookup_key?: boolean | undefined;
+    nickname?: string | undefined;
+    active?: boolean | undefined;
+    metadata?: Record<string, string> | undefined;
+    expand?: string[] | undefined;
+    unit_amount?: string | undefined;
+    billing_scheme?: "per_unit" | "tiered" | undefined;
+    tiers?: {
+        up_to: number | "inf";
+        unit_amount?: string | undefined;
+        flat_amount?: string | undefined;
+    }[] | undefined;
+    tiers_mode?: "graduated" | "volume" | undefined;
+    transform_quantity?: {
+        divide_by: number;
+        round: "up" | "down";
+    } | undefined;
+    recurring?: {
+        interval: "day" | "week" | "month" | "year";
+        interval_count?: number | undefined;
+        usage_type?: "licensed" | "metered" | undefined;
+        meter?: string | undefined;
+    } | undefined;
+    tax_behavior?: "inclusive" | "exclusive" | "unspecified" | undefined;
+}, {
+    product: string;
+    currency: "FAIR" | "EUR" | "USD" | "GBP" | "CHF" | "SEK" | "NOK" | "DKK" | "PLN" | "CZK" | "CAD" | "AUD" | "JPY";
+    lookup_key?: string | undefined;
+    transfer_lookup_key?: boolean | undefined;
+    nickname?: string | undefined;
+    active?: boolean | undefined;
+    metadata?: Record<string, string> | undefined;
+    expand?: string[] | undefined;
+    unit_amount?: string | undefined;
+    billing_scheme?: "per_unit" | "tiered" | undefined;
+    tiers?: {
+        up_to: number | "inf";
+        unit_amount?: string | undefined;
+        flat_amount?: string | undefined;
+    }[] | undefined;
+    tiers_mode?: "graduated" | "volume" | undefined;
+    transform_quantity?: {
+        divide_by: number;
+        round: "up" | "down";
+    } | undefined;
+    recurring?: {
+        interval: "day" | "week" | "month" | "year";
+        interval_count?: number | undefined;
+        usage_type?: "licensed" | "metered" | undefined;
+        meter?: string | undefined;
+    } | undefined;
+    tax_behavior?: "inclusive" | "exclusive" | "unspecified" | undefined;
+}>>;
+export type CreatePriceParams = z.input<typeof createPriceParams>;
+/** The only mutable fields. `""` clears `nickname` and `lookup_key`. */
+export declare const updatePriceParams: z.ZodObject<{
+    active: z.ZodOptional<z.ZodBoolean>;
+    nickname: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>, z.ZodTransform<string | null, string>>>;
+    lookup_key: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>, z.ZodTransform<string | null, string>>>;
+    transfer_lookup_key: z.ZodOptional<z.ZodBoolean>;
+    tax_behavior: z.ZodOptional<z.ZodEnum<{
+        inclusive: "inclusive";
+        exclusive: "exclusive";
+        unspecified: "unspecified";
+    }>>;
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<import("../..").MetadataPatch, Record<string, string>>>>;
+    expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+export type UpdatePriceParams = z.input<typeof updatePriceParams>;
+export declare const listPricesQuery: z.ZodObject<{
+    limit: z.ZodPipe<z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>, z.ZodTransform<number, number | undefined>>;
+    starting_after: z.ZodOptional<z.ZodString>;
+    ending_before: z.ZodOptional<z.ZodString>;
+    created: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>, z.ZodTransform<import("../..").RangeFilter, number>>, z.ZodPipe<z.ZodObject<{
+        gt: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+        gte: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+        lt: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+        lte: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+    }, z.core.$strict>, z.ZodTransform<import("../..").RangeFilter, {
+        gt?: number | undefined;
+        gte?: number | undefined;
+        lt?: number | undefined;
+        lte?: number | undefined;
+    }>>]>>;
+    expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+    product: z.ZodOptional<z.ZodString>;
+    active: z.ZodOptional<z.ZodType<boolean, boolean, z.core.$ZodTypeInternals<boolean, boolean>>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        one_time: "one_time";
+        recurring: "recurring";
+    }>>;
+    currency: z.ZodOptional<z.ZodEnum<{
+        FAIR: "FAIR";
+        EUR: "EUR";
+        USD: "USD";
+        GBP: "GBP";
+        CHF: "CHF";
+        SEK: "SEK";
+        NOK: "NOK";
+        DKK: "DKK";
+        PLN: "PLN";
+        CZK: "CZK";
+        CAD: "CAD";
+        AUD: "AUD";
+        JPY: "JPY";
+    }>>;
+    lookup_keys: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+    recurring: z.ZodOptional<z.ZodObject<{
+        interval: z.ZodOptional<z.ZodEnum<{
+            day: "day";
+            week: "week";
+            month: "month";
+            year: "year";
+        }>>;
+        usage_type: z.ZodOptional<z.ZodEnum<{
+            licensed: "licensed";
+            metered: "metered";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type PriceListParams = z.input<typeof listPricesQuery>;
+export declare const priceRoutes: readonly [{
+    readonly operationId: "createPrice";
+    readonly method: "post";
+    readonly path: "/v1/prices";
+    readonly tag: "Prices";
+    readonly summary: "Create a price";
+    readonly auth: "service";
+    readonly scope: "payments:write";
+    readonly idempotent: true;
+    readonly body: z.ZodPipe<z.ZodObject<{
+        product: z.ZodString;
+        lookup_key: z.ZodOptional<z.ZodString>;
+        transfer_lookup_key: z.ZodOptional<z.ZodBoolean>;
+        nickname: z.ZodOptional<z.ZodString>;
+        active: z.ZodOptional<z.ZodBoolean>;
+        metadata: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<Record<string, string>, Record<string, string>>>>;
+        expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+        currency: z.ZodEnum<{
+            FAIR: "FAIR";
+            EUR: "EUR";
+            USD: "USD";
+            GBP: "GBP";
+            CHF: "CHF";
+            SEK: "SEK";
+            NOK: "NOK";
+            DKK: "DKK";
+            PLN: "PLN";
+            CZK: "CZK";
+            CAD: "CAD";
+            AUD: "AUD";
+            JPY: "JPY";
+        }>;
+        unit_amount: z.ZodOptional<z.ZodString>;
+        billing_scheme: z.ZodOptional<z.ZodEnum<{
+            per_unit: "per_unit";
+            tiered: "tiered";
+        }>>;
+        tiers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            up_to: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"inf">]>;
+            unit_amount: z.ZodOptional<z.ZodString>;
+            flat_amount: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        tiers_mode: z.ZodOptional<z.ZodEnum<{
+            graduated: "graduated";
+            volume: "volume";
+        }>>;
+        transform_quantity: z.ZodOptional<z.ZodObject<{
+            divide_by: z.ZodNumber;
+            round: z.ZodEnum<{
+                up: "up";
+                down: "down";
+            }>;
+        }, z.core.$strict>>;
+        recurring: z.ZodOptional<z.ZodObject<{
+            interval: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>;
+            interval_count: z.ZodOptional<z.ZodNumber>;
+            usage_type: z.ZodOptional<z.ZodEnum<{
+                licensed: "licensed";
+                metered: "metered";
+            }>>;
+            meter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        tax_behavior: z.ZodOptional<z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+            unspecified: "unspecified";
+        }>>;
+    }, z.core.$strict>, z.ZodTransform<{
+        shape: ParsedPriceShape;
+        product: string;
+        currency: "FAIR" | "EUR" | "USD" | "GBP" | "CHF" | "SEK" | "NOK" | "DKK" | "PLN" | "CZK" | "CAD" | "AUD" | "JPY";
+        lookup_key?: string | undefined;
+        transfer_lookup_key?: boolean | undefined;
+        nickname?: string | undefined;
+        active?: boolean | undefined;
+        metadata?: Record<string, string> | undefined;
+        expand?: string[] | undefined;
+        unit_amount?: string | undefined;
+        billing_scheme?: "per_unit" | "tiered" | undefined;
+        tiers?: {
+            up_to: number | "inf";
+            unit_amount?: string | undefined;
+            flat_amount?: string | undefined;
+        }[] | undefined;
+        tiers_mode?: "graduated" | "volume" | undefined;
+        transform_quantity?: {
+            divide_by: number;
+            round: "up" | "down";
+        } | undefined;
+        recurring?: {
+            interval: "day" | "week" | "month" | "year";
+            interval_count?: number | undefined;
+            usage_type?: "licensed" | "metered" | undefined;
+            meter?: string | undefined;
+        } | undefined;
+        tax_behavior?: "inclusive" | "exclusive" | "unspecified" | undefined;
+    }, {
+        product: string;
+        currency: "FAIR" | "EUR" | "USD" | "GBP" | "CHF" | "SEK" | "NOK" | "DKK" | "PLN" | "CZK" | "CAD" | "AUD" | "JPY";
+        lookup_key?: string | undefined;
+        transfer_lookup_key?: boolean | undefined;
+        nickname?: string | undefined;
+        active?: boolean | undefined;
+        metadata?: Record<string, string> | undefined;
+        expand?: string[] | undefined;
+        unit_amount?: string | undefined;
+        billing_scheme?: "per_unit" | "tiered" | undefined;
+        tiers?: {
+            up_to: number | "inf";
+            unit_amount?: string | undefined;
+            flat_amount?: string | undefined;
+        }[] | undefined;
+        tiers_mode?: "graduated" | "volume" | undefined;
+        transform_quantity?: {
+            divide_by: number;
+            round: "up" | "down";
+        } | undefined;
+        recurring?: {
+            interval: "day" | "week" | "month" | "year";
+            interval_count?: number | undefined;
+            usage_type?: "licensed" | "metered" | undefined;
+            meter?: string | undefined;
+        } | undefined;
+        tax_behavior?: "inclusive" | "exclusive" | "unspecified" | undefined;
+    }>>;
+    readonly response: z.ZodObject<{
+        id: z.ZodString;
+        object: z.ZodLiteral<"price">;
+        livemode: z.ZodBoolean;
+        active: z.ZodBoolean;
+        product: z.ZodType<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">, z.core.$ZodTypeInternals<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">>>;
+        currency: z.ZodEnum<{
+            FAIR: "FAIR";
+            EUR: "EUR";
+            USD: "USD";
+            GBP: "GBP";
+            CHF: "CHF";
+            SEK: "SEK";
+            NOK: "NOK";
+            DKK: "DKK";
+            PLN: "PLN";
+            CZK: "CZK";
+            CAD: "CAD";
+            AUD: "AUD";
+            JPY: "JPY";
+        }>;
+        unit_amount: z.ZodNullable<z.ZodString>;
+        billing_scheme: z.ZodEnum<{
+            per_unit: "per_unit";
+            tiered: "tiered";
+        }>;
+        tiers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            up_to: z.ZodNullable<z.ZodNumber>;
+            unit_amount: z.ZodNullable<z.ZodString>;
+            flat_amount: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+        tiers_mode: z.ZodNullable<z.ZodEnum<{
+            graduated: "graduated";
+            volume: "volume";
+        }>>;
+        transform_quantity: z.ZodNullable<z.ZodObject<{
+            divide_by: z.ZodNumber;
+            round: z.ZodEnum<{
+                up: "up";
+                down: "down";
+            }>;
+        }, z.core.$strict>>;
+        type: z.ZodEnum<{
+            one_time: "one_time";
+            recurring: "recurring";
+        }>;
+        recurring: z.ZodNullable<z.ZodObject<{
+            interval: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>;
+            interval_count: z.ZodNumber;
+            usage_type: z.ZodEnum<{
+                licensed: "licensed";
+                metered: "metered";
+            }>;
+            meter: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        tax_behavior: z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+            unspecified: "unspecified";
+        }>;
+        lookup_key: z.ZodNullable<z.ZodString>;
+        nickname: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+        created: z.ZodNumber;
+    }, z.core.$strict>;
+    readonly sdk: "prices.create";
+    readonly expandable: "price";
+}, {
+    readonly operationId: "listPrices";
+    readonly method: "get";
+    readonly path: "/v1/prices";
+    readonly tag: "Prices";
+    readonly summary: "List prices";
+    readonly description: "`lookup_keys` (at most 10) finds the current price of a plan by its stable name.";
+    readonly auth: "service";
+    readonly scope: "payments:read";
+    readonly query: z.ZodObject<{
+        limit: z.ZodPipe<z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>, z.ZodTransform<number, number | undefined>>;
+        starting_after: z.ZodOptional<z.ZodString>;
+        ending_before: z.ZodOptional<z.ZodString>;
+        created: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>, z.ZodTransform<import("../..").RangeFilter, number>>, z.ZodPipe<z.ZodObject<{
+            gt: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+            gte: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+            lt: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+            lte: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>;
+        }, z.core.$strict>, z.ZodTransform<import("../..").RangeFilter, {
+            gt?: number | undefined;
+            gte?: number | undefined;
+            lt?: number | undefined;
+            lte?: number | undefined;
+        }>>]>>;
+        expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+        product: z.ZodOptional<z.ZodString>;
+        active: z.ZodOptional<z.ZodType<boolean, boolean, z.core.$ZodTypeInternals<boolean, boolean>>>;
+        type: z.ZodOptional<z.ZodEnum<{
+            one_time: "one_time";
+            recurring: "recurring";
+        }>>;
+        currency: z.ZodOptional<z.ZodEnum<{
+            FAIR: "FAIR";
+            EUR: "EUR";
+            USD: "USD";
+            GBP: "GBP";
+            CHF: "CHF";
+            SEK: "SEK";
+            NOK: "NOK";
+            DKK: "DKK";
+            PLN: "PLN";
+            CZK: "CZK";
+            CAD: "CAD";
+            AUD: "AUD";
+            JPY: "JPY";
+        }>>;
+        lookup_keys: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+        recurring: z.ZodOptional<z.ZodObject<{
+            interval: z.ZodOptional<z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>>;
+            usage_type: z.ZodOptional<z.ZodEnum<{
+                licensed: "licensed";
+                metered: "metered";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly response: z.ZodObject<{
+        object: z.ZodLiteral<"list">;
+        data: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            object: z.ZodLiteral<"price">;
+            livemode: z.ZodBoolean;
+            active: z.ZodBoolean;
+            product: z.ZodType<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">, z.core.$ZodTypeInternals<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">>>;
+            currency: z.ZodEnum<{
+                FAIR: "FAIR";
+                EUR: "EUR";
+                USD: "USD";
+                GBP: "GBP";
+                CHF: "CHF";
+                SEK: "SEK";
+                NOK: "NOK";
+                DKK: "DKK";
+                PLN: "PLN";
+                CZK: "CZK";
+                CAD: "CAD";
+                AUD: "AUD";
+                JPY: "JPY";
+            }>;
+            unit_amount: z.ZodNullable<z.ZodString>;
+            billing_scheme: z.ZodEnum<{
+                per_unit: "per_unit";
+                tiered: "tiered";
+            }>;
+            tiers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                up_to: z.ZodNullable<z.ZodNumber>;
+                unit_amount: z.ZodNullable<z.ZodString>;
+                flat_amount: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>>;
+            tiers_mode: z.ZodNullable<z.ZodEnum<{
+                graduated: "graduated";
+                volume: "volume";
+            }>>;
+            transform_quantity: z.ZodNullable<z.ZodObject<{
+                divide_by: z.ZodNumber;
+                round: z.ZodEnum<{
+                    up: "up";
+                    down: "down";
+                }>;
+            }, z.core.$strict>>;
+            type: z.ZodEnum<{
+                one_time: "one_time";
+                recurring: "recurring";
+            }>;
+            recurring: z.ZodNullable<z.ZodObject<{
+                interval: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    year: "year";
+                }>;
+                interval_count: z.ZodNumber;
+                usage_type: z.ZodEnum<{
+                    licensed: "licensed";
+                    metered: "metered";
+                }>;
+                meter: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            tax_behavior: z.ZodEnum<{
+                inclusive: "inclusive";
+                exclusive: "exclusive";
+                unspecified: "unspecified";
+            }>;
+            lookup_key: z.ZodNullable<z.ZodString>;
+            nickname: z.ZodNullable<z.ZodString>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+            created: z.ZodNumber;
+        }, z.core.$strict>>;
+        has_more: z.ZodBoolean;
+        url: z.ZodString;
+    }, z.core.$strict>;
+    readonly sdk: "prices.list";
+    readonly expandable: "price";
+}, {
+    readonly operationId: "retrievePrice";
+    readonly method: "get";
+    readonly path: "/v1/prices/{id}";
+    readonly tag: "Prices";
+    readonly summary: "Retrieve a price";
+    readonly auth: "service";
+    readonly scope: "payments:read";
+    readonly params: {
+        readonly id: "The price (`price_…`).";
+    };
+    readonly query: z.ZodObject<{
+        expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>;
+    readonly response: z.ZodObject<{
+        id: z.ZodString;
+        object: z.ZodLiteral<"price">;
+        livemode: z.ZodBoolean;
+        active: z.ZodBoolean;
+        product: z.ZodType<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">, z.core.$ZodTypeInternals<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">>>;
+        currency: z.ZodEnum<{
+            FAIR: "FAIR";
+            EUR: "EUR";
+            USD: "USD";
+            GBP: "GBP";
+            CHF: "CHF";
+            SEK: "SEK";
+            NOK: "NOK";
+            DKK: "DKK";
+            PLN: "PLN";
+            CZK: "CZK";
+            CAD: "CAD";
+            AUD: "AUD";
+            JPY: "JPY";
+        }>;
+        unit_amount: z.ZodNullable<z.ZodString>;
+        billing_scheme: z.ZodEnum<{
+            per_unit: "per_unit";
+            tiered: "tiered";
+        }>;
+        tiers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            up_to: z.ZodNullable<z.ZodNumber>;
+            unit_amount: z.ZodNullable<z.ZodString>;
+            flat_amount: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+        tiers_mode: z.ZodNullable<z.ZodEnum<{
+            graduated: "graduated";
+            volume: "volume";
+        }>>;
+        transform_quantity: z.ZodNullable<z.ZodObject<{
+            divide_by: z.ZodNumber;
+            round: z.ZodEnum<{
+                up: "up";
+                down: "down";
+            }>;
+        }, z.core.$strict>>;
+        type: z.ZodEnum<{
+            one_time: "one_time";
+            recurring: "recurring";
+        }>;
+        recurring: z.ZodNullable<z.ZodObject<{
+            interval: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>;
+            interval_count: z.ZodNumber;
+            usage_type: z.ZodEnum<{
+                licensed: "licensed";
+                metered: "metered";
+            }>;
+            meter: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        tax_behavior: z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+            unspecified: "unspecified";
+        }>;
+        lookup_key: z.ZodNullable<z.ZodString>;
+        nickname: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+        created: z.ZodNumber;
+    }, z.core.$strict>;
+    readonly sdk: "prices.retrieve";
+    readonly expandable: "price";
+}, {
+    readonly operationId: "updatePrice";
+    readonly method: "post";
+    readonly path: "/v1/prices/{id}";
+    readonly tag: "Prices";
+    readonly summary: "Update a price";
+    readonly description: "Only `active`, `nickname`, `metadata`, `lookup_key` and — while it is `unspecified` — `tax_behavior` change. To change an amount, create a new price and archive this one.";
+    readonly auth: "service";
+    readonly scope: "payments:write";
+    readonly idempotent: true;
+    readonly params: {
+        readonly id: "The price (`price_…`).";
+    };
+    readonly body: z.ZodObject<{
+        active: z.ZodOptional<z.ZodBoolean>;
+        nickname: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>, z.ZodTransform<string | null, string>>>;
+        lookup_key: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>, z.ZodTransform<string | null, string>>>;
+        transfer_lookup_key: z.ZodOptional<z.ZodBoolean>;
+        tax_behavior: z.ZodOptional<z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+            unspecified: "unspecified";
+        }>>;
+        metadata: z.ZodOptional<z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodString>, z.ZodTransform<import("../..").MetadataPatch, Record<string, string>>>>;
+        expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>;
+    readonly response: z.ZodObject<{
+        id: z.ZodString;
+        object: z.ZodLiteral<"price">;
+        livemode: z.ZodBoolean;
+        active: z.ZodBoolean;
+        product: z.ZodType<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">, z.core.$ZodTypeInternals<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">>>;
+        currency: z.ZodEnum<{
+            FAIR: "FAIR";
+            EUR: "EUR";
+            USD: "USD";
+            GBP: "GBP";
+            CHF: "CHF";
+            SEK: "SEK";
+            NOK: "NOK";
+            DKK: "DKK";
+            PLN: "PLN";
+            CZK: "CZK";
+            CAD: "CAD";
+            AUD: "AUD";
+            JPY: "JPY";
+        }>;
+        unit_amount: z.ZodNullable<z.ZodString>;
+        billing_scheme: z.ZodEnum<{
+            per_unit: "per_unit";
+            tiered: "tiered";
+        }>;
+        tiers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            up_to: z.ZodNullable<z.ZodNumber>;
+            unit_amount: z.ZodNullable<z.ZodString>;
+            flat_amount: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+        tiers_mode: z.ZodNullable<z.ZodEnum<{
+            graduated: "graduated";
+            volume: "volume";
+        }>>;
+        transform_quantity: z.ZodNullable<z.ZodObject<{
+            divide_by: z.ZodNumber;
+            round: z.ZodEnum<{
+                up: "up";
+                down: "down";
+            }>;
+        }, z.core.$strict>>;
+        type: z.ZodEnum<{
+            one_time: "one_time";
+            recurring: "recurring";
+        }>;
+        recurring: z.ZodNullable<z.ZodObject<{
+            interval: z.ZodEnum<{
+                day: "day";
+                week: "week";
+                month: "month";
+                year: "year";
+            }>;
+            interval_count: z.ZodNumber;
+            usage_type: z.ZodEnum<{
+                licensed: "licensed";
+                metered: "metered";
+            }>;
+            meter: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        tax_behavior: z.ZodEnum<{
+            inclusive: "inclusive";
+            exclusive: "exclusive";
+            unspecified: "unspecified";
+        }>;
+        lookup_key: z.ZodNullable<z.ZodString>;
+        nickname: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+        created: z.ZodNumber;
+    }, z.core.$strict>;
+    readonly sdk: "prices.update";
+    readonly expandable: "price";
+}, {
+    readonly operationId: "searchPrices";
+    readonly method: "get";
+    readonly path: "/v1/prices/search";
+    readonly tag: "Prices";
+    readonly summary: "Search prices";
+    readonly description: "Stripe's query language over `active`, `currency`, `product`, `type`, `lookup_key`, `created` and `metadata['key']`.";
+    readonly auth: "service";
+    readonly scope: "payments:read";
+    readonly query: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodPipe<z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>>, z.ZodTransform<number, number | undefined>>;
+        page: z.ZodOptional<z.ZodString>;
+        expand: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>, z.ZodTransform<string[], string | string[]>>, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>;
+    readonly response: z.ZodObject<{
+        object: z.ZodLiteral<"search_result">;
+        data: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            object: z.ZodLiteral<"price">;
+            livemode: z.ZodBoolean;
+            active: z.ZodBoolean;
+            product: z.ZodType<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">, z.core.$ZodTypeInternals<string | import("../..").Ref<"product">, string | import("../..").Ref<"product">>>;
+            currency: z.ZodEnum<{
+                FAIR: "FAIR";
+                EUR: "EUR";
+                USD: "USD";
+                GBP: "GBP";
+                CHF: "CHF";
+                SEK: "SEK";
+                NOK: "NOK";
+                DKK: "DKK";
+                PLN: "PLN";
+                CZK: "CZK";
+                CAD: "CAD";
+                AUD: "AUD";
+                JPY: "JPY";
+            }>;
+            unit_amount: z.ZodNullable<z.ZodString>;
+            billing_scheme: z.ZodEnum<{
+                per_unit: "per_unit";
+                tiered: "tiered";
+            }>;
+            tiers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                up_to: z.ZodNullable<z.ZodNumber>;
+                unit_amount: z.ZodNullable<z.ZodString>;
+                flat_amount: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>>;
+            tiers_mode: z.ZodNullable<z.ZodEnum<{
+                graduated: "graduated";
+                volume: "volume";
+            }>>;
+            transform_quantity: z.ZodNullable<z.ZodObject<{
+                divide_by: z.ZodNumber;
+                round: z.ZodEnum<{
+                    up: "up";
+                    down: "down";
+                }>;
+            }, z.core.$strict>>;
+            type: z.ZodEnum<{
+                one_time: "one_time";
+                recurring: "recurring";
+            }>;
+            recurring: z.ZodNullable<z.ZodObject<{
+                interval: z.ZodEnum<{
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    year: "year";
+                }>;
+                interval_count: z.ZodNumber;
+                usage_type: z.ZodEnum<{
+                    licensed: "licensed";
+                    metered: "metered";
+                }>;
+                meter: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            tax_behavior: z.ZodEnum<{
+                inclusive: "inclusive";
+                exclusive: "exclusive";
+                unspecified: "unspecified";
+            }>;
+            lookup_key: z.ZodNullable<z.ZodString>;
+            nickname: z.ZodNullable<z.ZodString>;
+            metadata: z.ZodRecord<z.ZodString, z.ZodString>;
+            created: z.ZodNumber;
+        }, z.core.$strict>>;
+        has_more: z.ZodBoolean;
+        next_page: z.ZodNullable<z.ZodString>;
+        url: z.ZodString;
+        total_count: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly sdk: "prices.search";
+    readonly expandable: "price";
+}];
+export {};