@peable.to/contracts 0.4.0 → 1.0.0

package/dist/cjs/resources/catalog/prices.js

@@ -0,0 +1,423 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.priceRoutes = exports.listPricesQuery = exports.updatePriceParams = exports.createPriceParams = exports.defaultPriceDataParams = exports.priceDataParams = exports.priceSchema = exports.priceRecurringSchema = exports.priceTransformQuantitySchema = exports.priceTierSchema = void 0;
+exports.priceShapeOf = priceShapeOf;
+const zod_1 = require("zod");
+const envelopes_1 = require("../../common/envelopes");
+const objects_1 = require("../../common/objects");
+const params_1 = require("../../common/params");
+const primitives_1 = require("../../common/primitives");
+const route_1 = require("../../route");
+const catalog_1 = require("../../vocabulary/catalog");
+const shared_1 = require("./shared");
+/**
+ * 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.
+ */
+exports.priceTierSchema = (0, objects_1.defineComponent)('PriceTier', zod_1.z
+    .object({
+    up_to: zod_1.z
+        .number()
+        .int()
+        .nullable()
+        .describe('The last quantity this tier covers; `null` on the last tier.'),
+    unit_amount: primitives_1.amount.nullable(),
+    flat_amount: primitives_1.amount.nullable(),
+})
+    .strict());
+/**
+ * Divide the quantity before pricing it: `divide_by: 10, round: 'up'` bills
+ * 11 units as 2 packs of ten. Per-unit prices only.
+ */
+exports.priceTransformQuantitySchema = (0, objects_1.defineComponent)('PriceTransformQuantity', zod_1.z
+    .object({
+    divide_by: zod_1.z.number().int(),
+    round: zod_1.z.enum(catalog_1.TRANSFORM_QUANTITY_ROUNDS),
+})
+    .strict());
+exports.priceRecurringSchema = (0, objects_1.defineComponent)('PriceRecurring', zod_1.z
+    .object({
+    interval: zod_1.z.enum(catalog_1.RECURRING_INTERVALS),
+    interval_count: zod_1.z
+        .number()
+        .int()
+        .describe("Intervals between billings: `interval: 'month', interval_count: 3` is quarterly. At most three years."),
+    usage_type: zod_1.z.enum(catalog_1.RECURRING_USAGE_TYPES),
+    meter: zod_1.z
+        .string()
+        .nullable()
+        .describe('The meter (`mtr_…`) a `metered` price bills; `null` when `licensed`.'),
+})
+    .strict());
+exports.priceSchema = (0, objects_1.defineObject)('price', 'Price', zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('price'),
+    livemode: primitives_1.livemode,
+    active: zod_1.z.boolean(),
+    product: (0, objects_1.expandable)('product', 'The product it prices: `prod_…`, or the Product with `expand[]=product`.'),
+    currency: primitives_1.currency,
+    unit_amount: primitives_1.amount.nullable().describe('Base units per unit; `null` on a tiered price.'),
+    billing_scheme: zod_1.z.enum(catalog_1.PRICE_BILLING_SCHEMES),
+    tiers: zod_1.z
+        .array(exports.priceTierSchema)
+        .nullable()
+        .describe('`null` unless `billing_scheme` is `tiered`.'),
+    tiers_mode: zod_1.z.enum(catalog_1.PRICE_TIERS_MODES).nullable(),
+    transform_quantity: exports.priceTransformQuantitySchema.nullable(),
+    type: zod_1.z.enum(catalog_1.PRICE_TYPES),
+    recurring: exports.priceRecurringSchema
+        .nullable()
+        .describe('`null` exactly when `type` is `one_time`.'),
+    tax_behavior: zod_1.z
+        .enum(catalog_1.PRICE_TAX_BEHAVIORS)
+        .describe('Whether the price includes tax (Peable Tax). `unspecified` defers to the merchant default; once `inclusive` or `exclusive` it never changes.'),
+    lookup_key: zod_1.z
+        .string()
+        .nullable()
+        .describe("The merchant's own stable name for this price, unique among its prices (per mode): retrieve the current price of a plan with `lookup_keys[]`."),
+    nickname: zod_1.z.string().nullable(),
+    metadata: primitives_1.metadata,
+    created: primitives_1.unixSeconds,
+})
+    .strict(), {
+    description: 'How much a product costs, in one currency, once or per interval. Immutable once created except for `active`, `nickname`, `metadata`, `lookup_key` and — while `unspecified` — `tax_behavior`.',
+    examples: [
+        {
+            id: 'price_0193b8f2c1a87d3e9f4b',
+            object: 'price',
+            livemode: false,
+            active: true,
+            product: 'prod_0193b8f2c1a87d3e9f4a',
+            currency: 'EUR',
+            unit_amount: '999',
+            billing_scheme: 'per_unit',
+            tiers: null,
+            tiers_mode: null,
+            transform_quantity: null,
+            type: 'recurring',
+            recurring: { interval: 'month', interval_count: 1, usage_type: 'licensed', meter: null },
+            tax_behavior: 'inclusive',
+            lookup_key: 'plus_monthly',
+            nickname: 'Plus, monthly',
+            metadata: {},
+            created: 1793750400,
+        },
+    ],
+});
+// ---- The price shape, as a request names it --------------------------------------
+const recurringParams = zod_1.z
+    .object({
+    interval: zod_1.z.enum(catalog_1.RECURRING_INTERVALS),
+    interval_count: shared_1.countParam.optional().describe('Default 1.'),
+    usage_type: zod_1.z.enum(catalog_1.RECURRING_USAGE_TYPES).optional().describe('Default `licensed`.'),
+    meter: zod_1.z
+        .string()
+        .min(1)
+        .max(255)
+        .optional()
+        .describe("Required with `usage_type: 'metered'`: the meter (`mtr_…`) it bills."),
+})
+    .strict();
+const tierParams = zod_1.z
+    .object({
+    up_to: zod_1.z
+        .union([zod_1.z.number().int().min(1).max(Number.MAX_SAFE_INTEGER), zod_1.z.literal('inf')])
+        .describe("A positive integer, ascending; the last tier is `'inf'`."),
+    unit_amount: shared_1.baseUnitAmountParam.optional(),
+    flat_amount: shared_1.baseUnitAmountParam.optional(),
+})
+    .strict();
+const transformQuantityParams = zod_1.z
+    .object({
+    divide_by: shared_1.countParam,
+    round: zod_1.z.enum(catalog_1.TRANSFORM_QUANTITY_ROUNDS),
+})
+    .strict();
+/** The fields that make up a price's shape, as a request names them. */
+const priceShapeFields = {
+    currency: primitives_1.currency,
+    unit_amount: shared_1.baseUnitAmountParam
+        .optional()
+        .describe('Required for `per_unit`; absent for `tiered`.'),
+    billing_scheme: zod_1.z.enum(catalog_1.PRICE_BILLING_SCHEMES).optional().describe('Default `per_unit`.'),
+    tiers: zod_1.z.array(tierParams).min(1).max(catalog_1.CATALOG_LIMITS.priceTiersMax).optional(),
+    tiers_mode: zod_1.z.enum(catalog_1.PRICE_TIERS_MODES).optional(),
+    transform_quantity: transformQuantityParams.optional(),
+    recurring: recurringParams.optional().describe('Present: a recurring price. Absent: one-time.'),
+    tax_behavior: zod_1.z.enum(catalog_1.PRICE_TAX_BEHAVIORS).optional().describe('Default `unspecified`.'),
+};
+function tiersOf(input, currency, issue) {
+    let previous = 0;
+    return input.map((tier, index) => {
+        const last = index === input.length - 1;
+        const path = ['tiers', index];
+        if (last && tier.up_to !== 'inf') {
+            issue([...path, 'up_to'], "the last tier's up_to must be 'inf'");
+        }
+        else if (!last && tier.up_to === 'inf') {
+            issue([...path, 'up_to'], "only the last tier's up_to may be 'inf'");
+        }
+        else if (tier.up_to !== 'inf') {
+            if (tier.up_to <= previous) {
+                issue([...path, 'up_to'], 'tier up_to values must ascend');
+            }
+            previous = tier.up_to;
+        }
+        if (tier.unit_amount === undefined && tier.flat_amount === undefined) {
+            issue(path, 'a tier needs a unit_amount, a flat_amount or both');
+        }
+        (0, shared_1.amountWithinBound)(issue, tier.unit_amount, currency, [...path, 'unit_amount']);
+        (0, shared_1.amountWithinBound)(issue, tier.flat_amount, currency, [...path, 'flat_amount']);
+        return {
+            up_to: tier.up_to === 'inf' ? null : tier.up_to,
+            unit_amount: tier.unit_amount ?? null,
+            flat_amount: tier.flat_amount ?? null,
+        };
+    });
+}
+/**
+ * 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`).
+ */
+function priceShapeOf(input, ctx) {
+    const { issue, failed } = (0, shared_1.issuer)(ctx);
+    const scheme = input.billing_scheme ?? 'per_unit';
+    let tiers = null;
+    if (scheme === 'per_unit') {
+        if (input.unit_amount === undefined) {
+            issue(['unit_amount'], 'unit_amount is required for a per_unit price');
+        }
+        if (input.tiers !== undefined)
+            issue(['tiers'], 'tiers are only for a tiered price');
+        if (input.tiers_mode !== undefined) {
+            issue(['tiers_mode'], 'tiers_mode is only for a tiered price');
+        }
+        (0, shared_1.amountWithinBound)(issue, input.unit_amount, input.currency, ['unit_amount']);
+    }
+    else {
+        if (input.unit_amount !== undefined) {
+            issue(['unit_amount'], 'a tiered price takes its amounts from tiers, not unit_amount');
+        }
+        if (input.tiers_mode === undefined)
+            issue(['tiers_mode'], 'tiers_mode is required');
+        if (input.transform_quantity !== undefined) {
+            issue(['transform_quantity'], 'transform_quantity is only for a per_unit price');
+        }
+        if (input.tiers === undefined)
+            issue(['tiers'], 'tiers are required for a tiered price');
+        else
+            tiers = tiersOf(input.tiers, input.currency, issue);
+    }
+    let recurring = null;
+    if (input.recurring) {
+        const count = input.recurring.interval_count ?? 1;
+        const max = catalog_1.RECURRING_INTERVAL_COUNT_MAX[input.recurring.interval];
+        if (count > max) {
+            issue(['recurring', 'interval_count'], `an interval is at most three years (${max} ${input.recurring.interval}s)`);
+        }
+        const usageType = input.recurring.usage_type ?? 'licensed';
+        const meter = input.recurring.meter;
+        if (usageType === 'metered' && meter === undefined) {
+            issue(['recurring', 'meter'], 'a metered price names the meter (mtr_…) it bills');
+        }
+        if (usageType === 'licensed' && meter !== undefined) {
+            issue(['recurring', 'meter'], 'only a metered price has a meter');
+        }
+        recurring = {
+            interval: input.recurring.interval,
+            intervalCount: count,
+            usageType,
+            ...(meter !== undefined ? { meterPublicId: meter } : {}),
+        };
+    }
+    if (failed())
+        return null;
+    return {
+        currency: input.currency,
+        unitAmount: scheme === 'per_unit' ? (input.unit_amount ?? null) : null,
+        billingScheme: scheme,
+        tiers,
+        tiersMode: scheme === 'tiered' ? (input.tiers_mode ?? null) : null,
+        transformQuantity: input.transform_quantity
+            ? { divideBy: input.transform_quantity.divide_by, round: input.transform_quantity.round }
+            : null,
+        recurring,
+        taxBehavior: input.tax_behavior ?? 'unspecified',
+    };
+}
+/**
+ * Inline `price_data` (Stripe's): a one-off per-unit price for a checkout
+ * line item or an invoice item that names no stored price. Never stored as a
+ * `price_…` by itself.
+ */
+const inlinePriceFields = {
+    currency: primitives_1.currency,
+    unit_amount: shared_1.baseUnitAmountParam,
+    recurring: recurringParams.omit({ usage_type: true, meter: true }).optional(),
+    tax_behavior: zod_1.z.enum(catalog_1.PRICE_TAX_BEHAVIORS).optional(),
+};
+/** `price_data` — an inline price of an existing product (`product: 'prod_…'`). */
+exports.priceDataParams = zod_1.z
+    .object({
+    ...inlinePriceFields,
+    product: zod_1.z.string().min(1).max(255).describe('The `prod_…` it prices.'),
+})
+    .strict()
+    .transform((input, ctx) => {
+    const shape = priceShapeOf(input, ctx);
+    return shape === null ? zod_1.z.NEVER : { product: input.product, shape };
+});
+/** `default_price_data` on a product create — `price_data` for the product being made. */
+exports.defaultPriceDataParams = zod_1.z
+    .object(inlinePriceFields)
+    .strict()
+    .transform((input, ctx) => priceShapeOf(input, ctx) ?? zod_1.z.NEVER);
+const lookupKey = zod_1.z.string().min(1).max(catalog_1.CATALOG_LIMITS.lookupKeyMax);
+const nickname = zod_1.z.string().min(1).max(catalog_1.CATALOG_LIMITS.priceNicknameMax);
+exports.createPriceParams = zod_1.z
+    .object({
+    ...priceShapeFields,
+    product: zod_1.z.string().min(1).max(255),
+    lookup_key: lookupKey.optional(),
+    transfer_lookup_key: zod_1.z
+        .boolean()
+        .optional()
+        .describe('Move `lookup_key` here from the price that holds it.'),
+    nickname: nickname.optional(),
+    active: zod_1.z.boolean().optional(),
+    metadata: params_1.metadataCreateParam.optional(),
+    expand: params_1.expandParam.optional(),
+})
+    .strict()
+    .transform((input, ctx) => {
+    if (input.transfer_lookup_key && input.lookup_key === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['transfer_lookup_key'],
+            message: 'transfer_lookup_key needs a lookup_key',
+        });
+    }
+    const shape = priceShapeOf(input, ctx);
+    return shape === null ? zod_1.z.NEVER : { ...input, shape };
+});
+/** The only mutable fields. `""` clears `nickname` and `lookup_key`. */
+exports.updatePriceParams = zod_1.z
+    .object({
+    active: zod_1.z.boolean().optional(),
+    nickname: (0, shared_1.clearing)(nickname).optional(),
+    lookup_key: (0, shared_1.clearing)(lookupKey).optional(),
+    transfer_lookup_key: zod_1.z.boolean().optional(),
+    tax_behavior: zod_1.z
+        .enum(catalog_1.PRICE_TAX_BEHAVIORS)
+        .optional()
+        .describe("Only while the price's is `unspecified`."),
+    metadata: params_1.metadataUpdateParam.optional(),
+    expand: params_1.expandParam.optional(),
+})
+    .strict()
+    .superRefine((body, ctx) => {
+    if (body.transfer_lookup_key && (body.lookup_key === undefined || body.lookup_key === null)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['transfer_lookup_key'],
+            message: 'transfer_lookup_key needs a lookup_key',
+        });
+    }
+});
+exports.listPricesQuery = (0, params_1.listQuery)({
+    product: params_1.idParam.optional(),
+    active: shared_1.queryFlag.optional(),
+    type: zod_1.z.enum(catalog_1.PRICE_TYPES).optional(),
+    currency: primitives_1.currency.optional(),
+    lookup_keys: (0, shared_1.queryIdList)(catalog_1.CATALOG_LIMITS.lookupKeysFilterMax).optional().describe('At most 10.'),
+    recurring: zod_1.z
+        .object({
+        interval: zod_1.z.enum(catalog_1.RECURRING_INTERVALS).optional(),
+        usage_type: zod_1.z.enum(catalog_1.RECURRING_USAGE_TYPES).optional(),
+    })
+        .strict()
+        .optional(),
+});
+exports.priceRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'createPrice',
+        method: 'post',
+        path: '/v1/prices',
+        tag: 'Prices',
+        summary: 'Create a price',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        body: exports.createPriceParams,
+        response: exports.priceSchema,
+        sdk: 'prices.create',
+        expandable: 'price',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listPrices',
+        method: 'get',
+        path: '/v1/prices',
+        tag: 'Prices',
+        summary: 'List prices',
+        description: '`lookup_keys` (at most 10) finds the current price of a plan by its stable name.',
+        auth: 'service',
+        scope: 'payments:read',
+        query: exports.listPricesQuery,
+        response: (0, envelopes_1.listOf)(exports.priceSchema),
+        sdk: 'prices.list',
+        expandable: 'price',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrievePrice',
+        method: 'get',
+        path: '/v1/prices/{id}',
+        tag: 'Prices',
+        summary: 'Retrieve a price',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { id: 'The price (`price_…`).' },
+        query: params_1.expandOnlyQuery,
+        response: exports.priceSchema,
+        sdk: 'prices.retrieve',
+        expandable: 'price',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'updatePrice',
+        method: 'post',
+        path: '/v1/prices/{id}',
+        tag: 'Prices',
+        summary: 'Update a price',
+        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.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        params: { id: 'The price (`price_…`).' },
+        body: exports.updatePriceParams,
+        response: exports.priceSchema,
+        sdk: 'prices.update',
+        expandable: 'price',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'searchPrices',
+        method: 'get',
+        path: '/v1/prices/search',
+        tag: 'Prices',
+        summary: 'Search prices',
+        description: "Stripe's query language over `active`, `currency`, `product`, `type`, `lookup_key`, `created` and `metadata['key']`.",
+        auth: 'service',
+        scope: 'payments:read',
+        query: params_1.searchQuery,
+        response: (0, envelopes_1.searchResultOf)(exports.priceSchema),
+        sdk: 'prices.search',
+        expandable: 'price',
+    }),
+];

package/dist/cjs/resources/catalog/products.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productRoutes = exports.listProductsQuery = exports.updateProductParams = exports.createProductParams = exports.deletedProductSchema = exports.productSchema = exports.productMarketingFeatureSchema = void 0;
+const zod_1 = require("zod");
+const envelopes_1 = require("../../common/envelopes");
+const objects_1 = require("../../common/objects");
+const params_1 = require("../../common/params");
+const primitives_1 = require("../../common/primitives");
+const route_1 = require("../../route");
+const catalog_1 = require("../../vocabulary/catalog");
+const tax_1 = require("../../vocabulary/tax");
+const prices_1 = require("./prices");
+const shared_1 = require("./shared");
+/**
+ * Products (`prod_…`, ADR 0018) — what a merchant sells; its prices say how
+ * much. A product with prices cannot be deleted: archive it with
+ * `active: false`.
+ */
+/** A product feature shown on pricing tables and checkout (Stripe's marketing features). */
+exports.productMarketingFeatureSchema = (0, objects_1.defineComponent)('ProductMarketingFeature', zod_1.z.object({ name: zod_1.z.string() }).strict());
+exports.productSchema = (0, objects_1.defineObject)('product', 'Product', zod_1.z
+    .object({
+    id: zod_1.z.string(),
+    object: zod_1.z.literal('product'),
+    livemode: primitives_1.livemode,
+    active: zod_1.z.boolean(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().nullable(),
+    images: zod_1.z.array(zod_1.z.string()).describe('Up to 8 image URLs.'),
+    metadata: primitives_1.metadata,
+    tax_code: zod_1.z
+        .string()
+        .nullable()
+        .describe("A Peable Tax code (`txcd_…`), or `null` for the merchant's default."),
+    default_price: (0, objects_1.expandable)('price', "The product's default price: `price_…`, or the Price with `expand[]=default_price`.").nullable(),
+    unit_label: zod_1.z
+        .string()
+        .nullable()
+        .describe('The unit a quantity counts (`seat`), shown on receipts and invoices.'),
+    url: zod_1.z.string().nullable(),
+    statement_descriptor: zod_1.z
+        .string()
+        .nullable()
+        .describe('What appears on a card statement; at most 22 characters.'),
+    marketing_features: zod_1.z.array(exports.productMarketingFeatureSchema),
+    created: primitives_1.unixSeconds,
+    updated: primitives_1.unixSeconds,
+})
+    .strict(), {
+    description: 'What a merchant sells. Its prices say how much. A product with prices cannot be deleted; set `active: false` to archive it.',
+    examples: [
+        {
+            id: 'prod_0193b8f2c1a87d3e9f4a',
+            object: 'product',
+            livemode: false,
+            active: true,
+            name: 'Mention Plus',
+            description: 'Everything in Mention, plus the Plus features.',
+            images: [],
+            metadata: {},
+            tax_code: 'txcd_10103000',
+            default_price: 'price_0193b8f2c1a87d3e9f4b',
+            unit_label: null,
+            url: null,
+            statement_descriptor: null,
+            marketing_features: [{ name: 'Longer posts' }],
+            created: 1793750400,
+            updated: 1793750400,
+        },
+    ],
+});
+/** What `DELETE /v1/products/{id}` answers. */
+exports.deletedProductSchema = (0, objects_1.defineComponent)('DeletedProduct', (0, envelopes_1.deletedOf)('product'));
+const url = zod_1.z
+    .string()
+    .max(catalog_1.CATALOG_LIMITS.urlMax)
+    .regex(/^https?:\/\/\S+$/, 'must be an http(s) URL');
+const fields = {
+    name: zod_1.z.string().min(1).max(catalog_1.CATALOG_LIMITS.productNameMax),
+    description: zod_1.z.string().min(1).max(catalog_1.CATALOG_LIMITS.productDescriptionMax),
+    images: zod_1.z.array(url).max(catalog_1.CATALOG_LIMITS.productImagesMax),
+    tax_code: zod_1.z
+        .string()
+        .refine(tax_1.isKnownTaxCode, 'is not a Peable Tax code (GET /v1/tax/codes lists them)'),
+    unit_label: zod_1.z.string().min(1).max(catalog_1.CATALOG_LIMITS.unitLabelMax),
+    url,
+    // Card networks print at most 22 characters, need one letter, and refuse
+    // `< > \ ' " *`.
+    statement_descriptor: zod_1.z
+        .string()
+        .min(1)
+        .max(catalog_1.CATALOG_LIMITS.statementDescriptorMax)
+        .regex(/[A-Za-z]/, 'must contain at least one letter')
+        .refine((value) => !/[<>\\'"*]/.test(value), 'cannot contain < > \\ \' " or *'),
+    marketing_features: zod_1.z
+        .array(zod_1.z.object({ name: zod_1.z.string().min(1).max(catalog_1.CATALOG_LIMITS.marketingFeatureNameMax) }).strict())
+        .max(catalog_1.CATALOG_LIMITS.marketingFeaturesMax),
+};
+exports.createProductParams = zod_1.z
+    .object({
+    name: fields.name,
+    active: zod_1.z.boolean().optional(),
+    description: fields.description.optional(),
+    images: fields.images.optional(),
+    metadata: params_1.metadataCreateParam.optional(),
+    tax_code: fields.tax_code.optional(),
+    default_price_data: prices_1.defaultPriceDataParams
+        .optional()
+        .describe("Create the product's default price with it."),
+    unit_label: fields.unit_label.optional(),
+    url: fields.url.optional(),
+    statement_descriptor: fields.statement_descriptor.optional(),
+    marketing_features: fields.marketing_features.optional(),
+    expand: params_1.expandParam.optional(),
+})
+    .strict();
+/** `""` clears an optional text field; `metadata` is a patch. */
+exports.updateProductParams = zod_1.z
+    .object({
+    name: fields.name.optional(),
+    active: zod_1.z.boolean().optional(),
+    description: (0, shared_1.clearing)(fields.description).optional(),
+    images: fields.images.optional(),
+    metadata: params_1.metadataUpdateParam.optional(),
+    tax_code: (0, shared_1.clearing)(fields.tax_code).optional(),
+    default_price: (0, shared_1.clearing)(zod_1.z.string().min(1).max(255))
+        .optional()
+        .describe('One of this product\'s active prices; `""` clears it.'),
+    unit_label: (0, shared_1.clearing)(fields.unit_label).optional(),
+    url: (0, shared_1.clearing)(fields.url).optional(),
+    statement_descriptor: (0, shared_1.clearing)(fields.statement_descriptor).optional(),
+    marketing_features: fields.marketing_features.optional(),
+    expand: params_1.expandParam.optional(),
+})
+    .strict();
+exports.listProductsQuery = (0, params_1.listQuery)({
+    active: shared_1.queryFlag.optional(),
+    ids: (0, shared_1.queryIdList)(catalog_1.CATALOG_LIMITS.idsFilterMax)
+        .optional()
+        .describe('Only these products (at most 100).'),
+});
+exports.productRoutes = [
+    (0, route_1.defineRoute)({
+        operationId: 'createProduct',
+        method: 'post',
+        path: '/v1/products',
+        tag: 'Products',
+        summary: 'Create a product',
+        description: '`default_price_data` creates its default price in the same request.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        body: exports.createProductParams,
+        response: exports.productSchema,
+        sdk: 'products.create',
+        expandable: 'product',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'listProducts',
+        method: 'get',
+        path: '/v1/products',
+        tag: 'Products',
+        summary: 'List products',
+        auth: 'service',
+        scope: 'payments:read',
+        query: exports.listProductsQuery,
+        response: (0, envelopes_1.listOf)(exports.productSchema),
+        sdk: 'products.list',
+        expandable: 'product',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'retrieveProduct',
+        method: 'get',
+        path: '/v1/products/{id}',
+        tag: 'Products',
+        summary: 'Retrieve a product',
+        auth: 'service',
+        scope: 'payments:read',
+        params: { id: 'The product (`prod_…`).' },
+        query: params_1.expandOnlyQuery,
+        response: exports.productSchema,
+        sdk: 'products.retrieve',
+        expandable: 'product',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'updateProduct',
+        method: 'post',
+        path: '/v1/products/{id}',
+        tag: 'Products',
+        summary: 'Update a product',
+        description: 'A field sent as `""` is cleared; `metadata` is a patch.',
+        auth: 'service',
+        scope: 'payments:write',
+        idempotent: true,
+        params: { id: 'The product (`prod_…`).' },
+        body: exports.updateProductParams,
+        response: exports.productSchema,
+        sdk: 'products.update',
+        expandable: 'product',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'deleteProduct',
+        method: 'delete',
+        path: '/v1/products/{id}',
+        tag: 'Products',
+        summary: 'Delete a product',
+        description: 'Only a product nothing names; one with prices is archived with `active: false`.',
+        auth: 'service',
+        scope: 'payments:write',
+        params: { id: 'The product (`prod_…`).' },
+        response: exports.deletedProductSchema,
+        sdk: 'products.del',
+    }),
+    (0, route_1.defineRoute)({
+        operationId: 'searchProducts',
+        method: 'get',
+        path: '/v1/products/search',
+        tag: 'Products',
+        summary: 'Search products',
+        description: "Stripe's query language over `active`, `name`, `description`, `url`, `created` and `metadata['key']`.",
+        auth: 'service',
+        scope: 'payments:read',
+        query: params_1.searchQuery,
+        response: (0, envelopes_1.searchResultOf)(exports.productSchema),
+        sdk: 'products.search',
+        expandable: 'product',
+    }),
+];