@stewardhq/sdk 0.3.0 → 0.6.0

package/dist/_chunks/src.js

@@ -1,4 +1,4 @@
-import { $ as CurrencySchema, C as BillingProfileKindSchema, E as SubscriptionStatusSchema, F as EmailSettingsPatchSchema, I as EmailSettingsSchema, Q as CodeSchema, V as applyEmailSettingsPatch, X as ActorRefSchema, Z as AmountMinorSchema, a as EVENT_TYPES, b as AccountStateSchema, ct as IntervalSchema, et as DateTimeSchema, j as EMAIL_TEMPLATES, o as EventIdSchema, ot as ExternalRefSchema, rt as EntitlementsSchema, st as IdSchema, w as BillingProfileSchema, y as AccountSchema } from "./events.js";
+import { $t as MeteredPriceSchema, A as SubscriptionStatusSchema, Bn as EntitlementsSchema, C as AccountSchema, D as BillingProfileKindSchema, Fn as CodeSchema, H as EmailSettingsSchema, Ht as MeterCreditPropertiesSchema, In as CurrencySchema, Jn as InvoiceBillingReasonSchema, Kn as IdSchema, L as EMAIL_TEMPLATES, Ln as DateTimeSchema, Nn as ActorRefSchema, O as BillingProfileSchema, Pn as AmountMinorSchema, Qt as MeteredPriceDefSchema, Un as ExternalRefSchema, Ut as MeterDefSchema, V as EmailSettingsPatchSchema, Vt as MeterCreditEntrySchema, Yn as InvoicePaymentStatusSchema, Z as applyEmailSettingsPatch, a as EVENT_TYPES, bt as AccountMetersSchema, ct as BenefitDefSchema, ft as CatalogBenefitSchema, gt as featureValueMatchesType, ln as plainDecimalOf, o as EventIdSchema, qn as IntervalSchema, rn as MICRO_UNITS_PER_UNIT, tn as meterFilterClauseOf, un as toMicroUnits, w as AccountStateSchema, wt as DecimalUnitsStringSchema, xt as CatalogMeterSchema } from "./events.js";
 import { z } from "zod";
 //#region ../contract/src/catalog.ts
 const FeatureTypeSchema = z.enum([
@@ -11,14 +11,34 @@ const FeatureDefSchema = z.object({
 	type: FeatureTypeSchema,
 	description: z.string().max(500).optional()
 });
+const PlanRankSchema = z.number().int().nonnegative();
+/** Upper bound of benefits a plan lists. */
+const MAX_PLAN_BENEFITS = 100;
+/** Plan in the catalog sync input. */
 const PlanDefSchema = z.object({
 	code: CodeSchema,
 	name: z.string().min(1).max(200),
-	/** Yükseltme/düşürme sırası: büyük olan üst plan. */
-	rank: z.number().int().nonnegative(),
+	/**
+	* Upgrade order of the pre-benefits entitlement rule (higher = upper plan). Optional since
+	* billing core (M35): default 0; the benefits resolution does not read it.
+	*/
+	rank: PlanRankSchema.default(0),
 	/** Self-servis satın alınabilir mi (false: yalnızca grant ile verilir). */
 	sellable: z.boolean(),
-	entitlements: EntitlementsSchema
+	entitlements: EntitlementsSchema,
+	/** Codes of catalog `benefits` the plan includes, in display order (billing core; default empty). */
+	benefits: z.array(CodeSchema).max(100).default([])
+});
+/** Plan as returned by `GET /v1/catalog`. */
+const CatalogPlanSchema = z.object({
+	code: CodeSchema,
+	name: z.string().min(1).max(200),
+	/** Stored value (0 when the catalog omitted it); kept for older clients (M35). */
+	rank: PlanRankSchema.default(0),
+	sellable: z.boolean(),
+	entitlements: EntitlementsSchema,
+	/** Present only for a product that defines benefits. */
+	benefits: z.array(CodeSchema).optional()
 });
 const PriceDefSchema = z.object({
 	planCode: CodeSchema,
@@ -31,11 +51,25 @@ const PriceDefSchema = z.object({
 	/** Baz puan: %20 = 2000. */
 	taxRateBps: z.number().int().min(0).max(1e4)
 });
+/** Upper bound of benefit definitions in one catalog. */
+const MAX_CATALOG_BENEFITS = 200;
+/** Upper bound of meters in one catalog. */
+const MAX_CATALOG_METERS = 100;
+/** Upper bound of metered prices in one catalog. */
+const MAX_CATALOG_METERED_PRICES = 500;
+/** Issue `params.code` of a metered price whose tax terms differ from the plan's base price (M20). */
+const METERED_PRICE_TAX_MISMATCH = "metered_price_tax_mismatch";
 const CatalogSyncInputSchema = z.object({
 	defaultPlanCode: CodeSchema,
 	features: z.array(FeatureDefSchema),
 	plans: z.array(PlanDefSchema).min(1),
-	prices: z.array(PriceDefSchema)
+	prices: z.array(PriceDefSchema),
+	/** Benefit definitions by code (billing core; default empty). */
+	benefits: z.record(CodeSchema, BenefitDefSchema).default({}),
+	/** Meter definitions by code (metering; default empty). */
+	meters: z.record(CodeSchema, MeterDefSchema).default({}),
+	/** Metered prices (metering; default empty). */
+	meteredPrices: z.array(MeteredPriceDefSchema).default([])
 }).superRefine((c, ctx) => {
 	const features = new Set(c.features.map((f) => f.key));
 	const plans = new Set(c.plans.map((p) => p.code));
@@ -62,6 +96,78 @@ const CatalogSyncInputSchema = z.object({
 		],
 		message: "tanımsız feature"
 	});
+	const benefitCodes = Object.keys(c.benefits);
+	if (benefitCodes.length > 200) ctx.addIssue({
+		code: "custom",
+		path: ["benefits"],
+		message: `at most 200 benefits`
+	});
+	for (const [i, p] of c.plans.entries()) {
+		const listed = /* @__PURE__ */ new Set();
+		for (const [j, code] of p.benefits.entries()) {
+			if (!Object.hasOwn(c.benefits, code)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"plans",
+					i,
+					"benefits",
+					j
+				],
+				message: `undefined benefit: ${code}`
+			});
+			if (listed.has(code)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"plans",
+					i,
+					"benefits",
+					j
+				],
+				message: `duplicate benefit: ${code}`
+			});
+			listed.add(code);
+		}
+	}
+	const featureTypes = new Map(c.features.map((f) => [f.key, f.type]));
+	for (const code of benefitCodes) {
+		const benefit = c.benefits[code];
+		if (benefit.type === "meter_credit") {
+			if (!Object.hasOwn(c.meters, benefit.properties.meter)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"benefits",
+					code,
+					"properties",
+					"meter"
+				],
+				message: `undefined meter: ${benefit.properties.meter}`
+			});
+			continue;
+		}
+		for (const [key, value] of Object.entries(benefit.properties)) {
+			const type = featureTypes.get(key);
+			if (type === void 0) ctx.addIssue({
+				code: "custom",
+				path: [
+					"benefits",
+					code,
+					"properties",
+					key
+				],
+				message: "undefined feature"
+			});
+			else if (!featureValueMatchesType(type, value)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"benefits",
+					code,
+					"properties",
+					key
+				],
+				message: `value does not match feature type ${type}`
+			});
+		}
+	}
 	const seen = /* @__PURE__ */ new Set();
 	for (const [i, p] of c.prices.entries()) {
 		if (!plans.has(p.planCode)) ctx.addIssue({
@@ -81,6 +187,61 @@ const CatalogSyncInputSchema = z.object({
 		});
 		seen.add(key);
 	}
+	if (Object.keys(c.meters).length > 100) ctx.addIssue({
+		code: "custom",
+		path: ["meters"],
+		message: `at most 100 meters`
+	});
+	if (c.meteredPrices.length > 500) ctx.addIssue({
+		code: "custom",
+		path: ["meteredPrices"],
+		message: `at most 500 metered prices`
+	});
+	const meteredSeen = /* @__PURE__ */ new Set();
+	for (const [i, mp] of c.meteredPrices.entries()) {
+		if (!plans.has(mp.planCode)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"meteredPrices",
+				i,
+				"planCode"
+			],
+			message: `undefined plan: ${mp.planCode}`
+		});
+		if (!Object.hasOwn(c.meters, mp.meter)) ctx.addIssue({
+			code: "custom",
+			path: [
+				"meteredPrices",
+				i,
+				"meter"
+			],
+			message: `undefined meter: ${mp.meter}`
+		});
+		const key = `${mp.planCode}/${mp.meter}/${mp.currency}`;
+		if (meteredSeen.has(key)) ctx.addIssue({
+			code: "custom",
+			path: ["meteredPrices", i],
+			message: `duplicate metered price key: ${key}`
+		});
+		meteredSeen.add(key);
+		if (!plans.has(mp.planCode)) continue;
+		const base = c.prices.filter((p) => p.planCode === mp.planCode && p.currency === mp.currency);
+		if (base.length === 0) ctx.addIssue({
+			code: "custom",
+			path: [
+				"meteredPrices",
+				i,
+				"currency"
+			],
+			message: `plan ${mp.planCode} has no base price in ${mp.currency}`
+		});
+		else if (base.some((p) => p.taxInclusive !== mp.taxInclusive || p.taxRateBps !== mp.taxRateBps)) ctx.addIssue({
+			code: "custom",
+			path: ["meteredPrices", i],
+			message: `${METERED_PRICE_TAX_MISMATCH}: taxInclusive and taxRateBps must equal the base prices of plan ${mp.planCode} in ${mp.currency}`,
+			params: { code: METERED_PRICE_TAX_MISMATCH }
+		});
+	}
 });
 const PriceSchema = PriceDefSchema.extend({
 	id: IdSchema,
@@ -91,9 +252,15 @@ const CatalogSchema = z.object({
 	product: CodeSchema,
 	defaultPlanCode: CodeSchema,
 	features: z.array(FeatureDefSchema),
-	plans: z.array(PlanDefSchema),
+	plans: z.array(CatalogPlanSchema),
 	/** Varsayılan olarak yalnızca aktif fiyatlar. */
-	prices: z.array(PriceSchema)
+	prices: z.array(PriceSchema),
+	/** Active (not archived) benefit definitions by code; present only for a product that defines benefits. */
+	benefits: z.record(CodeSchema, CatalogBenefitSchema).optional(),
+	/** Active (not archived) meters by code; present only for a product that defines meters (metering). */
+	meters: z.record(CodeSchema, CatalogMeterSchema).optional(),
+	/** Active metered prices; present only for a product that defines meters (metering). */
+	meteredPrices: z.array(MeteredPriceSchema).optional()
 });
 const CatalogSyncResultSchema = z.object({
 	/** Aynı girdiyle tekrar senkron: hiçbir şey değişmedi. */
@@ -111,7 +278,21 @@ const CatalogSyncResultSchema = z.object({
 		priceId: IdSchema,
 		provider: z.string(),
 		code: z.string()
-	}))
+	})),
+	/** Benefits created, changed or unarchived by this sync. */
+	changedBenefits: z.array(CodeSchema).optional(),
+	/** Benefits removed from the catalog and archived by this sync. */
+	archivedBenefits: z.array(CodeSchema).optional(),
+	/** Prices whose amount or tax terms were updated in place (the price id is kept; history in `price_changes`). */
+	updatedPrices: z.array(IdSchema).optional(),
+	/** Meters created, changed (labels, `lowAt`, display) or unarchived by this sync. */
+	changedMeters: z.array(CodeSchema).optional(),
+	/** Meters removed from the catalog and archived by this sync (their history stays). */
+	archivedMeters: z.array(CodeSchema).optional(),
+	createdMeteredPrices: z.array(IdSchema).optional(),
+	/** Metered prices whose amount, cap or tax terms were updated in place (the id is kept). */
+	updatedMeteredPrices: z.array(IdSchema).optional(),
+	deactivatedMeteredPrices: z.array(IdSchema).optional()
 });
 /** `POST /v1/admin/accounts/refresh` — ürünün tüm hesaplarının snapshot'ı yeniden hesaplanır. */
 const AccountsRefreshResultSchema = z.object({ 
@@ -163,6 +344,60 @@ const BrandingSchema = z.object({
 	accentColor: AccentColorSchema.optional(),
 	supportEmail: SupportEmailSchema.optional()
 });
+const DEFAULT_PAYMENT_DUE_DAYS = 7;
+const DEFAULT_MIN_INVOICE_MINOR = 1e3;
+const DEFAULT_BANK_TRANSFER_PAYMENT_DAYS = 5;
+const PaymentDueDaysSchema = z.number().int().min(1).max(60);
+const BankTransferPaymentDaysSchema = z.number().int().min(1).max(14);
+const BankTransferSettingsSchema = z.object({
+	enabled: z.boolean().default(false),
+	paymentDays: BankTransferPaymentDaysSchema.default(5)
+});
+const BillingSettingsSchema = z.object({
+	paymentDueDays: PaymentDueDaysSchema.default(7),
+	minInvoiceMinor: AmountMinorSchema.default(DEFAULT_MIN_INVOICE_MINOR),
+	allowMultipleSubscriptions: z.boolean().default(false),
+	bankTransfer: BankTransferSettingsSchema.default({
+		enabled: false,
+		paymentDays: 5
+	})
+});
+/** Patch of `settings.billing.bankTransfer`: an omitted field is unchanged, `null` restores its default. */
+const BankTransferSettingsPatchSchema = z.object({
+	enabled: z.boolean().nullable().optional(),
+	paymentDays: BankTransferPaymentDaysSchema.nullable().optional()
+}).strict();
+/** Patch of `settings.billing`: an omitted field is unchanged, `null` restores its default. */
+const BillingSettingsPatchSchema = z.object({
+	paymentDueDays: PaymentDueDaysSchema.nullable().optional(),
+	minInvoiceMinor: AmountMinorSchema.nullable().optional(),
+	allowMultipleSubscriptions: z.boolean().nullable().optional(),
+	/** Merges per field; `bankTransfer: null` restores its defaults (off). */
+	bankTransfer: BankTransferSettingsPatchSchema.nullable().optional()
+}).strict();
+const DEFAULT_EVENT_RETENTION_DAYS = 120;
+const DEFAULT_LATE_GRACE_MINUTES = 60;
+const METER_CHARGE_MODES = [
+	"off",
+	"dry_run",
+	"live"
+];
+const MeterChargeModeSchema = z.enum(METER_CHARGE_MODES);
+const DEFAULT_METER_CHARGE_MODE = "dry_run";
+const EventRetentionDaysSchema = z.number().int().min(45).max(400);
+const LateGraceMinutesSchema = z.number().int().min(0).max(1440);
+const EventsSettingsSchema = z.object({ retentionDays: EventRetentionDaysSchema.default(120) });
+const MeteringSettingsSchema = z.object({
+	lateGraceMinutes: LateGraceMinutesSchema.default(60),
+	chargeMode: MeterChargeModeSchema.default(DEFAULT_METER_CHARGE_MODE)
+});
+/** Patch of `settings.events`: an omitted field is unchanged, `null` restores its default. */
+const EventsSettingsPatchSchema = z.object({ retentionDays: EventRetentionDaysSchema.nullable().optional() }).strict();
+/** Patch of `settings.metering`: an omitted field is unchanged, `null` restores its default. */
+const MeteringSettingsPatchSchema = z.object({
+	lateGraceMinutes: LateGraceMinutesSchema.nullable().optional(),
+	chargeMode: MeterChargeModeSchema.nullable().optional()
+}).strict();
 const ProductSettingsSchema = z.object({
 	/** Checkout'ları alan ödeme sağlayıcısı. Operatör ayarıdır (pod CLI); yönetim ucundan yazılmaz. */
 	provider: z.string().min(1).default("iyzico"),
@@ -177,8 +412,26 @@ const ProductSettingsSchema = z.object({
 	checkoutTtlMinutes: TtlMinutesSchema.default(30),
 	portalTtlMinutes: TtlMinutesSchema.default(30),
 	/** Billing emails sent by steward (`emails.ts`). */
-	emails: EmailSettingsSchema.default({ templates: {} })
+	emails: EmailSettingsSchema.default({ templates: {} }),
+	/** Billing behavior (billing core); absent = defaults (`billingSettingsOf`). */
+	billing: BillingSettingsSchema.optional(),
+	/** Raw event retention (metering); absent = defaults (`eventsSettingsOf`). */
+	events: EventsSettingsSchema.optional(),
+	/** Meter periods and overage pricing (metering); absent = defaults (`meteringSettingsOf`). */
+	metering: MeteringSettingsSchema.optional()
 });
+/** `settings.billing` with defaults filled in. */
+function billingSettingsOf(settings) {
+	return settings.billing ?? BillingSettingsSchema.parse({});
+}
+/** `settings.events` with defaults filled in. */
+function eventsSettingsOf(settings) {
+	return settings.events ?? EventsSettingsSchema.parse({});
+}
+/** `settings.metering` with defaults filled in. */
+function meteringSettingsOf(settings) {
+	return settings.metering ?? MeteringSettingsSchema.parse({});
+}
 const BrandingPatchSchema = z.object({
 	name: BrandingNameSchema.nullable().optional(),
 	logoUrl: LogoUrlSchema.nullable().optional(),
@@ -196,8 +449,31 @@ const ProductSettingsPatchSchema = z.object({
 	branding: BrandingPatchSchema.nullable().optional(),
 	checkoutTtlMinutes: TtlMinutesSchema.optional(),
 	portalTtlMinutes: TtlMinutesSchema.optional(),
-	emails: EmailSettingsPatchSchema.nullable().optional()
+	emails: EmailSettingsPatchSchema.nullable().optional(),
+	/** Merges per field; `billing: null` restores every default. */
+	billing: BillingSettingsPatchSchema.nullable().optional(),
+	/** Merges per field; `events: null` restores every default. */
+	events: EventsSettingsPatchSchema.nullable().optional(),
+	/** Merges per field; `metering: null` restores every default. */
+	metering: MeteringSettingsPatchSchema.nullable().optional()
 }).strict();
+/** Settings sections patched field by field (`null` section: every default back). */
+const MERGED_SECTIONS = /* @__PURE__ */ new Set([
+	"billing",
+	"events",
+	"metering"
+]);
+/** Objects inside a merged section that merge one level deeper (`billing.bankTransfer`). */
+const NESTED_MERGED_FIELDS = /* @__PURE__ */ new Set(["bankTransfer"]);
+/** Field-by-field merge: `null` deletes a field (its default comes back), `undefined` keeps it. */
+function mergeFields(current, patch, nested = /* @__PURE__ */ new Set()) {
+	const merged = { ...current };
+	for (const [field, value] of Object.entries(patch)) if (value === null) delete merged[field];
+	else if (value === void 0) continue;
+	else if (nested.has(field)) merged[field] = mergeFields(current[field] ?? {}, value);
+	else merged[field] = value;
+	return merged;
+}
 /**
 * Doğrulanmış yamayı ayarlara uygular (saf). Sonuç şemadan geçer; alan kuralları
 * yamada zaten denetlendiği için yalnızca programlama hatasında fırlatır.
@@ -214,7 +490,10 @@ function applySettingsPatch(current, patch) {
 			}
 			next.branding = branding;
 		} else if (key === "emails") next.emails = applyEmailSettingsPatch(current.emails, value);
-		else if (value === null) delete next[key];
+		else if (MERGED_SECTIONS.has(key)) {
+			if (value === null) delete next[key];
+			else next[key] = mergeFields(current[key] ?? {}, value, NESTED_MERGED_FIELDS);
+		} else if (value === null) delete next[key];
 		else next[key] = value;
 	}
 	return ProductSettingsSchema.parse(next);
@@ -232,6 +511,16 @@ function isReturnUrlAllowed(settings, returnUrl) {
 //#endregion
 //#region ../contract/src/checkout.ts
 const ReturnUrlSchema = z.url({ protocol: /^https?$/ });
+/**
+* Identity number sent to the payment provider (and, when the invoice needs one, used on the
+* invoice) for an INDIVIDUAL buyer (M31): steward never asks for or stores a TCKN; the Turkish
+* "final consumer" placeholder goes instead. A company buyer's VKN comes from the billing profile.
+*
+* It deliberately FAILS the TCKN checksum (`isValidTckn("11111111111") === false`): never run it
+* through a TCKN validator and never show it as a customer's TCKN. Kept here, not in a provider
+* adapter, because another provider may need a different rule.
+*/
+const INDIVIDUAL_IDENTITY_PLACEHOLDER = "11111111111";
 /** Accepted document — content lives in the product, steward keeps only the trace. */
 const ConsentSchema = z.object({
 	document: z.string().min(1).max(100),
@@ -274,7 +563,15 @@ const CheckoutSessionCreateInputSchema = z.object({
 	/** Opens the account with this name if it does not exist; never renames an existing account. */
 	displayName: z.string().min(1).max(200).optional(),
 	prefill: CheckoutPrefillSchema.optional(),
-	consents: z.array(CheckoutConsentInputSchema).max(20).optional()
+	consents: z.array(CheckoutConsentInputSchema).max(20).optional(),
+	/**
+	* Upgrade (bank transfer plan H16): a live subscription of the account this checkout replaces.
+	* It does not block the session (`already_subscribed`) and keeps running until the payment is
+	* recorded; in the transaction that records it (card or bank transfer) it is canceled
+	* immediately and the new subscription starts. An abandoned, expired or canceled session leaves
+	* it untouched. Not a live subscription of the account → 422 `replaces_subscription_invalid`.
+	*/
+	replacesSubscriptionId: IdSchema.optional()
 }).superRefine((body, ctx) => {
 	const seen = /* @__PURE__ */ new Set();
 	body.consents?.forEach((consent, i) => {
@@ -301,7 +598,18 @@ const CheckoutStatusSchema = z.enum([
 	"expired",
 	"canceled"
 ]);
-/** Provider form shown on steward's hosted checkout page (never returned to the product). */
+/**
+* How the customer chose to pay on the hosted page (bank transfer plan H5): `card` (the provider's
+* form) or `bank_transfer` (the session stays `open` until an operator records the transfer).
+* Absent/null: not chosen yet. The session status set does not change for it.
+*/
+const PAYMENT_METHODS = ["card", "bank_transfer"];
+const PaymentMethodSchema = z.enum(PAYMENT_METHODS);
+/**
+* Provider form shown on steward's hosted checkout page (never returned to the product).
+* @deprecated Ürün yüzeyinde kullanılmıyor; yalnızca servis içi. Bir sonraki minor sürümde paketin
+* dış yüzeyinden çıkarılacak (temizlik planı C9).
+*/
 const ProviderPayloadSchema = z.discriminatedUnion("type", [z.object({
 	type: z.literal("html_snippet"),
 	html: z.string()
@@ -329,7 +637,11 @@ const CheckoutSessionSchema = z.object({
 	subscriptionId: IdSchema.nullable(),
 	expiresAt: DateTimeSchema,
 	createdAt: DateTimeSchema,
-	completedAt: DateTimeSchema.nullable()
+	completedAt: DateTimeSchema.nullable(),
+	/** Payment method chosen on the page (H6); absent (or null): not chosen yet, or an older steward. */
+	paymentMethod: PaymentMethodSchema.nullable().optional(),
+	/** The subscription this checkout replaces (H16); absent (or null): none, or an older steward. */
+	replacesSubscriptionId: IdSchema.nullable().optional()
 });
 /**
 * `POST /v1/accounts/{ref}/checkout-sessions` response: `url` is steward's checkout page
@@ -349,7 +661,7 @@ function originOf(value) {
 	}
 }
 /**
-* Browser redirect for a checkout outcome — the service and the fake steward share it.
+* Browser redirect for a checkout outcome — used by the service.
 * Placeholders in `successUrl` (`{CHECKOUT_ID}` `{STATUS}` `{ACCOUNT_REF}` `{LOCALE}`) are
 * filled with URL-encoded values; nothing is appended, so a URL without placeholders is used
 * as-is. An encoded value cannot change the origin; it is still checked, and if the origin
@@ -373,9 +685,54 @@ const CHECKOUT_ERRORS = [
 	"return_url_not_allowed",
 	"provider_not_configured",
 	"provider_error",
-	"account_deleted"
+	"account_deleted",
+	"meter_already_billed",
+	"replaces_subscription_invalid"
 ];
 //#endregion
+//#region ../contract/src/bank-transfers.ts
+const BankTransferRecordInputSchema = z.object({
+	/** The account's order code as written in the transfer description (`K7M2-QX9D-4`; case and separators are forgiven). */
+	code: z.string().min(1).max(40),
+	/** The amount received, minor units (kuruş, cent); must equal what the item waits for. */
+	amountMinor: z.number().int().positive(),
+	currency: CurrencySchema,
+	/** When the money reached the account. */
+	receivedAt: DateTimeSchema,
+	/** The bank's transaction / receipt number; one payment per reference. */
+	bankRef: z.string().trim().min(1).max(100),
+	/** Settle this checkout (required when several items match, and with `acceptExpired`). */
+	checkoutSessionId: IdSchema.optional(),
+	/** Pay this invoice (a checkout matches too, or a written-off invoice the transfer pays). */
+	invoiceId: IdSchema.optional(),
+	/** H10: settle the named checkout although it expired (a late transfer the operator accepts). */
+	acceptExpired: z.boolean().optional()
+}).strict().refine((input) => !input.acceptExpired || input.checkoutSessionId !== void 0, {
+	path: ["checkoutSessionId"],
+	message: "acceptExpired needs checkoutSessionId"
+}).refine((input) => input.checkoutSessionId === void 0 || input.invoiceId === void 0, {
+	path: ["invoiceId"],
+	message: "name either checkoutSessionId or invoiceId"
+});
+const BankTransferRecordedSchema = z.object({
+	accountRef: ExternalRefSchema,
+	code: z.string(),
+	/** The checkout the transfer completed; null when it paid an invoice. */
+	checkoutSessionId: IdSchema.nullable(),
+	/** The invoice the transfer paid; null when it completed a checkout. */
+	invoiceId: IdSchema.nullable(),
+	subscriptionId: IdSchema,
+	paymentId: IdSchema,
+	/** The subscription the upgrade replaced (canceled in the same transaction, H16); null: none. */
+	replacedSubscriptionId: IdSchema.nullable(),
+	/** The checkout had expired and the operator accepted the transfer (H10). */
+	acceptedAfterExpiry: z.boolean(),
+	/** The paid invoice had been written off (waived / uncollectible). */
+	paidAfterWriteoff: z.boolean(),
+	/** The account's state after the recording. */
+	account: AccountStateSchema.optional()
+});
+//#endregion
 //#region ../contract/src/portal.ts
 const PortalSessionCreateInputSchema = z.object({
 	/** Sayfa dili; verilmezse ürün ayarı `defaultLocale`. */
@@ -403,9 +760,11 @@ const SubscriptionSchema = z.object({
 	planCode: CodeSchema,
 	priceId: IdSchema,
 	interval: IntervalSchema,
+	/** Amount per period; billing core (M36): the subscription's locked amount. */
 	amountMinor: AmountMinorSchema,
 	currency: CurrencySchema,
 	provider: z.string(),
+	/** Legacy provider-managed subscription reference; `""` for a steward-managed subscription (billing core, M30). */
 	providerSubscriptionRef: z.string(),
 	cancelAtPeriodEnd: z.boolean(),
 	cancelAt: DateTimeSchema.nullable(),
@@ -424,6 +783,28 @@ const CancelSubscriptionInputSchema = z.object({
 	/** Sağlayıcıda zaten iptal edildiyse (panelden) sağlayıcı çağrısını atla. */
 	skipProvider: z.boolean().default(false)
 });
+/**
+* `POST /v1/subscriptions/{id}/change` (billing core MF9): schedule a change for the next period
+* boundary (`AccountState.subscription.scheduledChange`); the next renewal invoice is written from
+* the new terms. `planCode` / `interval` pick another price of the subscription's currency;
+* `price: "current"` re-locks the current amount of the (possibly updated) price and the plan's
+* current metered rates — a metered price added later is attached only this way (M20, M36). At
+* least one of the three. `when` is required so other timings can be added later. A second change
+* replaces the first; asking for the current plan and interval while a change is pending takes it
+* back ("keep my plan"; a move to the current price the operator announced stays).
+* Errors: 404 `subscription_not_found`; 409 `already_subscribed` (another live subscription of the
+* account holds the target plan or is moving to it), `meter_already_billed` (the target prices a
+* meter another live subscription bills; for `price: "current"` only when that is the only
+* difference); 422 `plan_not_found`, `plan_not_sellable`, `subscription_change_invalid` (no such
+* price, nothing changes, the subscription is not live, has a cancellation scheduled or is a legacy
+* provider subscription).
+*/
+const SubscriptionChangeInputSchema = z.object({
+	planCode: CodeSchema.optional(),
+	interval: IntervalSchema.optional(),
+	price: z.literal("current").optional(),
+	when: z.literal("next_period")
+}).refine((c) => c.planCode !== void 0 || c.interval !== void 0 || c.price !== void 0, { message: "planCode, interval or price is required" });
 const PaymentSchema = z.object({
 	id: IdSchema,
 	subscriptionId: IdSchema,
@@ -435,19 +816,28 @@ const PaymentSchema = z.object({
 	periodEnd: DateTimeSchema.nullable(),
 	occurredAt: DateTimeSchema
 });
+/** Upper bound of named benefits in one grant. */
+const MAX_GRANT_BENEFITS = 100;
 const GrantCreateInputSchema = z.object({
 	planCode: CodeSchema.optional(),
-	/** Plan değerlerinin üzerine yazılan tek tek haklar. */
+	/** Single values written over the merged entitlements (applied last; may lower). */
 	overrides: EntitlementsSchema.default({}),
+	/**
+	* Catalog benefit codes granted independently of a plan (billing core, M32), e.g. only "sso".
+	* An unknown or archived code is rejected with 422 `benefit_not_found`.
+	*/
+	benefitCodes: z.array(CodeSchema).max(100).optional(),
 	reason: z.string().min(3).max(500),
 	startsAt: DateTimeSchema.optional(),
 	endsAt: DateTimeSchema.optional()
-}).refine((g) => g.planCode !== void 0 || Object.keys(g.overrides).length > 0, { message: "planCode ya da en az bir override gerekli" });
+}).refine((g) => g.planCode !== void 0 || Object.keys(g.overrides).length > 0 || (g.benefitCodes?.length ?? 0) > 0, { message: "planCode, benefitCodes or at least one override is required" });
 const GrantSchema = z.object({
 	id: IdSchema,
 	accountRef: ExternalRefSchema,
 	planCode: CodeSchema.nullable(),
 	overrides: EntitlementsSchema,
+	/** Named benefits the grant gives (billing core; absent when none or from an older steward). */
+	benefitCodes: z.array(CodeSchema).optional(),
 	reason: z.string(),
 	actorRef: ActorRefSchema.nullable(),
 	startsAt: DateTimeSchema,
@@ -472,7 +862,11 @@ const InvoiceLineSchema = z.object({
 	description: z.string(),
 	quantity: z.number().int().positive(),
 	unitAmountMinor: AmountMinorSchema,
-	amountMinor: AmountMinorSchema
+	amountMinor: AmountMinorSchema,
+	meter: CodeSchema.optional(),
+	units: DecimalUnitsStringSchema.optional(),
+	priceAmountMinor: AmountMinorSchema.optional(),
+	pricePerUnits: z.number().int().positive().optional()
 });
 const InvoiceSchema = z.object({
 	id: IdSchema,
@@ -499,7 +893,12 @@ const InvoiceSchema = z.object({
 	/** Manuel faturanın notu (ör. sözleşme ya da teklif referansı). */
 	note: z.string().nullable().optional(),
 	voidedAt: DateTimeSchema.nullable().optional(),
-	voidReason: z.string().nullable().optional()
+	voidReason: z.string().nullable().optional(),
+	billingReason: InvoiceBillingReasonSchema.nullable().optional(),
+	paymentStatus: InvoicePaymentStatusSchema.nullable().optional(),
+	/** Billing period the invoice covers. */
+	periodStart: DateTimeSchema.nullable().optional(),
+	periodEnd: DateTimeSchema.nullable().optional()
 });
 const InvoiceIssueInputSchema = z.object({
 	number: z.string().min(1).max(100),
@@ -538,6 +937,28 @@ const ManualInvoiceInputSchema = z.object({
 /** `POST /v1/invoices/{id}/void` — yalnızca manuel fatura; numara serbest kalmaz, belge silinmez. */
 const InvoiceVoidInputSchema = z.object({ reason: z.string().trim().min(3).max(500) });
 /**
+* `POST /v1/invoices/{id}/payment-sessions` — opens steward's hosted pay page for an unpaid
+* invoice (the product's own "Pay invoice" button; emails and the portal link to the same page).
+* 409 `invoice_not_payable` when the invoice is not unpaid.
+*/
+const InvoicePaymentSessionCreateInputSchema = z.object({
+	/** `tr` | `en`; defaults to the account's email locale, else the product's `defaultLocale`. */
+	locale: z.enum(SETTINGS_LOCALES).optional(),
+	/** Where the page returns after the outcome; its origin must be allowed by product settings. Defaults to `appUrl`. */
+	returnUrl: z.url({ protocol: /^https?$/ }).max(2e3).optional()
+});
+/** Pay page session: redirect the customer to `url` (it carries the page key; do not log it). */
+const InvoicePaymentSessionSchema = z.object({
+	id: IdSchema,
+	url: z.string(),
+	expiresAt: DateTimeSchema
+});
+/**
+* `POST /v1/invoices/{id}/waive` — an operator forgives an unpaid invoice (`paymentStatus:
+* "waived"`, e.g. before deleting the account). 409 `invoice_not_waivable` otherwise.
+*/
+const InvoiceWaiveInputSchema = z.object({ reason: z.string().trim().min(3).max(500) });
+/**
 * Vergi dahil tutardan matrah ve vergiyi ayrıştırır (tam sayı, kuruşa
 * yuvarlama). Toplam her zaman korunur: subtotal + tax === total.
 */
@@ -642,6 +1063,45 @@ const ManualInvoiceResponseSchema = InvoiceSchema.extend(withAccount);
 const InvoiceVoidResponseSchema = InvoiceSchema.extend(withAccount);
 /** `GET /v1/checkout-sessions/{id}` — `account` yalnızca oturum `completed` ise. */
 const CheckoutSessionResponseSchema = CheckoutSessionSchema.extend(withAccount);
+/** `POST /v1/invoices/{id}/waive` (billing core): the waived invoice and the state after it (`openInvoices` shrinks). */
+const InvoiceWaiveResponseSchema = InvoiceSchema.extend(withAccount);
+/** `POST /v1/subscriptions/{id}/change` (billing core MF9): the subscription and the state with `scheduledChange`. */
+const ChangeSubscriptionResponseSchema = SubscriptionSchema.extend(withAccount);
+/** `POST /v1/subscriptions/{id}/uncancel` (billing core MF9): the scheduled cancellation is taken back. */
+const UncancelSubscriptionResponseSchema = SubscriptionSchema.extend(withAccount);
+/**
+* `POST /v1/accounts/{ref}/credits` (metering MF2): the ledger entry written, the meters after it
+* and (K5) the account state after it (a credit may change a meter's standing).
+*/
+const CreditGrantResponseSchema = z.object({
+	entry: MeterCreditEntrySchema,
+	meters: AccountMetersSchema,
+	...withAccount
+});
+/**
+* Known `GET /v1/me` capabilities (M27): what this steward understands beyond the 0.2 contract.
+* `steward catalog push` sends a catalog with `benefits` only when `benefits` is listed (an older
+* steward would silently drop the key); phase 2 adds `events` (`POST /v1/events/ingest`), `meters`
+* (catalog `meters`, `meter_credit` benefits, `GET …/meters`, credits) and `overage` (metered
+* prices, meter charges). A steward lists a capability only once it implements it. Open set.
+*/
+const STEWARD_CAPABILITIES = [
+	"benefits",
+	"events",
+	"meters",
+	"overage"
+];
+/** `GET /v1/me`: the key's product and scope (setup check). `capabilities` absent from older steward. */
+const MeResponseSchema = z.object({
+	product: z.string(),
+	keyName: z.string(),
+	scope: z.enum([
+		"product",
+		"admin",
+		"checkout"
+	]),
+	capabilities: z.array(z.string()).optional()
+});
 /** Değişiklik yapan her istekte zorunlu başlıklar. */
 const HEADER_IDEMPOTENCY_KEY = "idempotency-key";
 const HEADER_ACTOR_REF = "x-actor-ref";
@@ -689,12 +1149,20 @@ const ERROR_CODES = Object.freeze({
 	override_type_mismatch: spec(422, "validation"),
 	/** Grant girdisindeki plan katalogda yok. */
 	plan_not_found: spec(422, "validation"),
+	/** Grant `benefitCodes`: a code is not an active (not archived) catalog benefit of the product. */
+	benefit_not_found: spec(422, "validation"),
 	invalid_window: spec(422, "validation"),
 	already_subscribed: spec(409, "conflict"),
 	already_canceled: spec(409, "conflict"),
-	/** `PUT …/plan` `mode: "strict"`: canlı aboneliğin planı hedefi geçiyor; hiçbir şey yazılmadı. */
+	/**
+	* @deprecated LEGACY — no longer produced (billing core, M35: no plan rank). Steward before the billing core
+	* answered `PUT …/plan` `mode: "strict"` with it when a live subscription's plan outranked the
+	* target. Kept so clients that handle it keep compiling.
+	*/
 	subscription_plan_higher: spec(409, "conflict"),
 	plan_not_sellable: spec(422, "validation"),
+	/** Checkout `replacesSubscriptionId` (bank transfer plan H16): not a live subscription of the account. */
+	replaces_subscription_invalid: spec(422, "validation"),
 	/**
 	* F4e: hesap silinmiş (anonimleştirilmiş). `/v1/accounts/:ref` altındaki her uç (tekrar
 	* `DELETE` ve aynı ref'le `PUT` dahil) 410 döner; hesap geri açılmaz.
@@ -702,13 +1170,26 @@ const ERROR_CODES = Object.freeze({
 	account_deleted: spec(410, "not_found"),
 	/** `DELETE /v1/accounts/:ref`: canlı abonelik (dönem sonunda iptali planlı dahil) var; önce hemen iptal. */
 	subscription_active: spec(409, "conflict"),
-	/** `DELETE /v1/accounts/:ref`: sağlayıcı formu açık checkout oturumu var; süresi dolup kapanınca tekrar dene. */
+	/**
+	* `DELETE /v1/accounts/:ref`: sağlayıcı formu açık ya da havale bekleyen (bank transfer plan H5) checkout
+	* oturumu var; kapanınca (süre dolumu, ödeme kaydı) tekrar dene.
+	*/
 	checkout_in_progress: spec(409, "conflict", true),
 	/** `successUrl`, `cancelUrl` or portal `returnUrl` is not in the product's allowed origins: product misconfiguration. */
 	return_url_not_allowed: spec(422, "config"),
 	/** Bu deployment'ta sağlayıcı yapılandırılmamış (503 ama beklemekle düzelmez). */
 	provider_not_configured: spec(503, "config"),
 	provider_error: spec(502, "provider"),
+	/** Not an order code, or its check symbol does not match (a typo in the transfer description). */
+	bank_transfer_code_invalid: spec(422, "validation"),
+	/** No account of the product has this order code. */
+	bank_transfer_code_not_found: spec(404, "not_found"),
+	/** This bank reference is already recorded. */
+	bank_transfer_duplicate: spec(409, "conflict"),
+	/** Nothing of the account waits for exactly this amount, or several items do (name one), or the named checkout is not one. */
+	bank_transfer_unmatched: spec(422, "conflict"),
+	/** The checkout expired (only `acceptExpired` settles it), is closed or cannot be completed: refund the transfer. */
+	bank_transfer_rejected: spec(409, "conflict"),
 	already_issued: spec(409, "conflict"),
 	number_taken: spec(409, "conflict"),
 	invalid_document: spec(422, "validation"),
@@ -718,17 +1199,53 @@ const ERROR_CODES = Object.freeze({
 	invoice_not_voidable: spec(409, "conflict"),
 	/** Void: ödemeli fatura; iptali iade yolundadır (F4d). */
 	invoice_has_payment: spec(409, "conflict"),
+	/** `DELETE /v1/accounts/:ref`: the account has an unpaid invoice; pay or waive it first. */
+	invoice_open: spec(409, "conflict"),
+	/** Pay page session: the invoice is not unpaid (paid, waived, uncollectible, or not an invoice-first invoice). */
+	invoice_not_payable: spec(409, "conflict"),
+	/** Waive: the invoice is not unpaid. */
+	invoice_not_waivable: spec(409, "conflict"),
+	/**
+	* `POST /v1/subscriptions/:id/change`: the requested change is not possible — no active price for
+	* the target plan/interval in the subscription's currency, nothing would change, or the
+	* subscription is not live. Plan lookup errors keep their codes (`plan_not_found`, `plan_not_sellable`).
+	*/
+	subscription_change_invalid: spec(422, "validation"),
+	/**
+	* `POST /v1/subscriptions/:id/uncancel`: the live subscription has no cancellation scheduled for
+	* the period end (an ended or immediately canceled one is `already_canceled`).
+	*/
+	cancel_not_scheduled: spec(409, "conflict"),
+	/** `POST /v1/events/ingest`: more than 1 000 events (or a body over 1 MiB) in one batch; split it. */
+	batch_too_large: spec(422, "validation"),
+	/** `POST /v1/events/ingest`: the unprocessed event backlog is too large; `Retry-After`, keep the batch queued (M11). */
+	events_backlog: spec(503, "unavailable", true),
+	/** Catalog sync: a meter's filter or aggregation changed after its first period opened; use a new meter code (M4). */
+	meter_locked: spec(422, "conflict"),
+	/** Credit grant (or another meter lookup): the code is not an active catalog meter of the product. */
+	meter_not_found: spec(422, "validation"),
+	/** Catalog sync: a metered price's tax terms differ from the plan's base price in that currency (M20). */
+	metered_price_tax_mismatch: spec(422, "validation"),
+	/** A second live subscription would bill the same meter's overage (M20: one billing subscription per meter). */
+	meter_already_billed: spec(409, "conflict"),
 	internal_error: spec(500, "unavailable", true),
 	/** `/health`: veritabanına ulaşılamıyor. */
 	database_unavailable: spec(503, "unavailable", true),
-	/** F2c (K26): anahtar prefix'i başına bütçe aşıldı; `Retry-After` başlığı taşır. */
+	/**
+	* Bugün yalnızca hosted sayfalar üretir (yanlış sayfa anahtarı / aksiyon sınırı; `hosted/routes.ts`,
+	* `hosted/portal-routes.ts`); `Retry-After` başlığı taşır. `/v1` için anahtar başına bütçe (F2c, K26)
+	* ertelendi — geldiğinde aynı kod kullanılır.
+	*/
 	rate_limited: spec(429, "unavailable", true),
 	unknown_provider: spec(404, "not_found"),
 	bad_signature: spec(401, "config"),
 	invalid_payload: spec(400, "validation"),
 	stale_event: spec(400, "validation"),
 	not_configured: spec(503, "config"),
-	/** Yalnızca sahte sağlayıcı (yerel/test). */
+	/**
+	* @deprecated Üretilmiyor: sağlayıcı abonelik yolu silindi (M30) ve sahte sağlayıcı da bu kodu
+	* döndürmüyor. Eski istemciler derlensin diye duruyor; bir sonraki minor sürümde kaldırılacak.
+	*/
 	unknown_subscription: spec(404, "not_found")
 });
 function isKnownErrorCode(code) {
@@ -739,6 +1256,297 @@ function errorCodeSpec(code) {
 	return isKnownErrorCode(code) ? ERROR_CODES[code] : null;
 }
 //#endregion
+//#region ../contract/src/meter-rules.ts
+const METADATA_PREFIX = "metadata.";
+function propertyValue(event, property) {
+	if (property === "name") return event.name;
+	const key = property.slice(9);
+	const metadata = event.metadata;
+	return metadata !== void 0 && metadata !== null && Object.hasOwn(metadata, key) ? metadata[key] : void 0;
+}
+const isScalar = (value) => typeof value === "string" || typeof value === "number" && Number.isFinite(value) || typeof value === "boolean";
+/**
+* Whether an event matches a meter filter (syntax and semantics: `meters.ts`). A condition on an
+* absent metadata key is false for every operator; `eq` needs the same type; `like` is a
+* case-sensitive substring. Throws on a filter the schema would reject.
+*/
+function matchesFilter(event, filter) {
+	if ("and" in filter && Array.isArray(filter.and)) return filter.and.every((f) => matchesFilter(event, f));
+	if ("or" in filter && Array.isArray(filter.or)) return filter.or.some((f) => matchesFilter(event, f));
+	const clause = meterFilterClauseOf(filter);
+	if (clause === null) throw new Error("invalid meter filter condition");
+	const value = propertyValue(event, clause.property);
+	if (!isScalar(value)) return false;
+	const operand = clause.value;
+	switch (clause.operator) {
+		case "eq": return typeof value === typeof operand && value === operand;
+		case "ne": return !(typeof value === typeof operand && value === operand);
+		case "gt": return typeof value === "number" && value > operand;
+		case "gte": return typeof value === "number" && value >= operand;
+		case "lt": return typeof value === "number" && value < operand;
+		case "lte": return typeof value === "number" && value <= operand;
+		case "like": return typeof value === "string" && value.includes(operand);
+		case "not_like": return !(typeof value === "string" && value.includes(operand));
+	}
+}
+function contributionOf(event, aggregation) {
+	if (aggregation.kind === "count") return { kind: "count" };
+	const value = propertyValue(event, `${METADATA_PREFIX}${aggregation.key}`);
+	if (aggregation.kind === "unique") {
+		if (typeof value === "string") return {
+			kind: "unique",
+			value: `s:${value}`
+		};
+		if (typeof value === "number" && Number.isFinite(value)) return {
+			kind: "unique",
+			value: `n:${plainDecimalOf(value)}`
+		};
+		if (typeof value === "boolean") return {
+			kind: "unique",
+			value: `b:${value}`
+		};
+		return { kind: "invalid_value" };
+	}
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return { kind: "invalid_value" };
+	return {
+		kind: aggregation.kind,
+		micro: toMicroUnits(value)
+	};
+}
+/**
+* A meter's value over a set of events (reference computation; the service recomputes a closing
+* period from raw events with the same result, M8): `count` → matching events, `sum` → total,
+* `max` → the largest value (0 when none), `unique` → distinct values. `matched` counts events
+* that passed the filter (invalid ones included), `invalid` those without a usable value.
+*/
+function consumptionOf(events, meter) {
+	let matched = 0;
+	let invalid = 0;
+	let total = 0n;
+	const distinct = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		if (!matchesFilter(event, meter.filter)) continue;
+		matched += 1;
+		const c = contributionOf(event, meter.aggregation);
+		switch (c.kind) {
+			case "invalid_value":
+				invalid += 1;
+				break;
+			case "count":
+				total += MICRO_UNITS_PER_UNIT;
+				break;
+			case "sum":
+				total += c.micro;
+				break;
+			case "max":
+				if (c.micro > total) total = c.micro;
+				break;
+			case "unique": distinct.add(c.value);
+		}
+	}
+	return {
+		consumedMicro: meter.aggregation.kind === "unique" ? BigInt(distinct.size) * MICRO_UNITS_PER_UNIT : total,
+		matched,
+		invalid
+	};
+}
+function nonNegative(name, value) {
+	if (value < 0n) throw new RangeError(`${name} must not be negative`);
+}
+/**
+* The credit rule (M5; decided 2026-09-19): the granted `meter_credit` benefits per meter code.
+* - Several benefits on one meter sum their units AND their rollover caps (plan + add-on).
+* - A benefit code granted by several layers counts once (its first counted grant).
+* - The default plan's credit for a meter counts only when no other layer credits that meter
+*   (`options.defaultPlanCode`): free 50k + team 2M → 2M, free only → 50k.
+* - Benefits of another type, without a code, or whose properties do not parse are ignored.
+* The service (`AccountState.meters.includedUnits`, cycle grants) and the SDK (`stateOf`,
+* `Meters()` fallback) both use this function. Vectors: `credits.json`.
+*/
+function meterCreditsOf(benefits, options = {}) {
+	const defaultSource = options.defaultPlanCode ? `plan:${options.defaultPlanCode}` : null;
+	const parsed = [];
+	for (const benefit of benefits) {
+		if (benefit.type !== "meter_credit" || typeof benefit.code !== "string") continue;
+		const properties = MeterCreditPropertiesSchema.safeParse(benefit.properties);
+		if (!properties.success) continue;
+		const { meter, units, rolloverCapUnits } = properties.data;
+		parsed.push({
+			code: benefit.code,
+			source: benefit.source ?? null,
+			isDefault: defaultSource !== null && benefit.source === defaultSource,
+			meter,
+			unitsMicro: toMicroUnits(units),
+			rolloverCapMicro: rolloverCapUnits === void 0 ? null : toMicroUnits(rolloverCapUnits)
+		});
+	}
+	const creditedElsewhere = new Set(parsed.filter((b) => !b.isDefault).map((b) => b.meter));
+	const credits = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	for (const benefit of parsed) {
+		if (seen.has(benefit.code) || benefit.isDefault && creditedElsewhere.has(benefit.meter)) continue;
+		seen.add(benefit.code);
+		const entry = credits.get(benefit.meter) ?? {
+			unitsMicro: 0n,
+			rolloverCapMicro: null,
+			benefits: []
+		};
+		entry.unitsMicro += benefit.unitsMicro;
+		if (benefit.rolloverCapMicro !== null) entry.rolloverCapMicro = (entry.rolloverCapMicro ?? 0n) + benefit.rolloverCapMicro;
+		entry.benefits.push({
+			code: benefit.code,
+			source: benefit.source,
+			unitsMicro: benefit.unitsMicro,
+			rolloverCapMicro: benefit.rolloverCapMicro
+		});
+		credits.set(benefit.meter, entry);
+	}
+	return credits;
+}
+/** `max(0, consumed − credited)` (M21). */
+function overageOf(input) {
+	const overage = input.consumedMicro - input.creditedMicro;
+	return overage > 0n ? overage : 0n;
+}
+/**
+* Credit standing of a meter (M14): no credit (`creditedMicro` 0) → `ok`; balance
+* (`credited − consumed`) ≤ 0 → `exhausted`; consumption ≥ `lowAt` × credit → `low` (`lowAt`
+* null disables `low`); else `ok`. Exact integer comparison (`lowAt` read as micro units).
+* `billable` does not change the standing — it describes the credit; a billable meter goes
+* `low`/`exhausted` too and only the gate stays open (M15).
+*/
+function standingOf(input) {
+	nonNegative("creditedMicro", input.creditedMicro);
+	nonNegative("consumedMicro", input.consumedMicro);
+	if (input.lowAt !== null && !(input.lowAt > 0 && input.lowAt <= 1)) throw new RangeError("lowAt must be in (0, 1]");
+	if (input.creditedMicro === 0n) return "ok";
+	if (input.creditedMicro - input.consumedMicro <= 0n) return "exhausted";
+	if (input.lowAt !== null && input.consumedMicro * 1000000n >= toMicroUnits(input.lowAt) * input.creditedMicro) return "low";
+	return "ok";
+}
+/**
+* Credit carried into the next period (M6): `min(max(closing balance, 0), cap)`; `capMicro`
+* null (rollover off) → 0. Debt never carries.
+*/
+function rolloverOf(input) {
+	if (input.capMicro === null) return 0n;
+	nonNegative("capMicro", input.capMicro);
+	const balance = input.closingBalanceMicro > 0n ? input.closingBalanceMicro : 0n;
+	return balance < input.capMicro ? balance : input.capMicro;
+}
+function daysInUtcMonth(year, month) {
+	const d = /* @__PURE__ */ new Date(0);
+	d.setUTCFullYear(year, month + 1, 0);
+	return d.getUTCDate();
+}
+/**
+* `from` + `months` months in UTC with the month-end clamp of the service's `addInterval`
+* (`service/src/periods.ts`, date-fns `addMonths` on `UTCDate`): the day of month is kept, or the
+* last day of a shorter month (Jan 31 + 1 → Feb 28/29); the time of day is kept.
+*/
+function addUtcMonths(from, months) {
+	if (!Number.isInteger(months)) throw new RangeError("months must be an integer");
+	const total = from.getUTCMonth() + months;
+	const year = from.getUTCFullYear() + Math.floor(total / 12);
+	const month = (total % 12 + 12) % 12;
+	const out = new Date(from.getTime());
+	out.setUTCFullYear(year, month, Math.min(from.getUTCDate(), daysInUtcMonth(year, month)));
+	return out;
+}
+/**
+* The monthly meter period containing `at` (M7): `[anchor + n months, anchor + (n + 1) months)`,
+* start inclusive, end exclusive, where every boundary is computed FROM THE ANCHOR (`addUtcMonths`;
+* Jan 31 → Feb 28 → Mar 31, no drift) — the same grid as the billing cycle's `nextPeriodEnd` for a
+* monthly subscription. `n` may be negative (`at` before the anchor). UTC throughout.
+*/
+function periodBoundsOf(anchor, at) {
+	if (Number.isNaN(anchor.getTime()) || Number.isNaN(at.getTime())) throw new RangeError("invalid date");
+	let n = (at.getUTCFullYear() - anchor.getUTCFullYear()) * 12 + (at.getUTCMonth() - anchor.getUTCMonth());
+	while (addUtcMonths(anchor, n).getTime() > at.getTime()) n -= 1;
+	while (addUtcMonths(anchor, n + 1).getTime() <= at.getTime()) n += 1;
+	return {
+		start: addUtcMonths(anchor, n),
+		end: addUtcMonths(anchor, n + 1)
+	};
+}
+function nonNegativeInteger(name, value, min = 0) {
+	if (!Number.isSafeInteger(value) || value < min) throw new RangeError(`${name} must be an integer ≥ ${min}`);
+	return BigInt(value);
+}
+/** The overage amount before the cap (BigInt, half up) and the cap (null: none); validates the price. */
+function pricedOverage(input) {
+	const amount = nonNegativeInteger("amountMinor", input.amountMinor);
+	const perUnits = nonNegativeInteger("perUnits", input.perUnits, 1);
+	const cap = input.capMinor === void 0 || input.capMinor === null ? null : nonNegativeInteger("capMinor", input.capMinor);
+	if (input.overageMicro <= 0n) return {
+		minor: 0n,
+		cap
+	};
+	const numerator = input.overageMicro * amount;
+	const denominator = perUnits * MICRO_UNITS_PER_UNIT;
+	let minor = numerator / denominator;
+	if (2n * (numerator % denominator) >= denominator) minor += 1n;
+	return {
+		minor,
+		cap
+	};
+}
+/**
+* Overage amount in minor units (M21): `round_half_up(overage × amountMinor / perUnits)` on micro
+* units with BigInt — proportional (no block rounding), always whole minor units — then clipped
+* by `capMinor`. Tax terms are the price's (gross when tax-inclusive).
+*/
+function rateOverage(input) {
+	const { minor: uncapped, cap } = pricedOverage(input);
+	const minor = cap !== null && uncapped > cap ? cap : uncapped;
+	if (minor > BigInt(Number.MAX_SAFE_INTEGER)) throw new RangeError("overage amount exceeds the safe integer range");
+	return Number(minor);
+}
+/**
+* Whether the period's priced overage reached the rate's `capMinor` (M15: the SDK gate closes on a
+* billable meter once the cap is reached — further use would be free): there is overage
+* (`overageMicro` > 0) and its amount before the cap (`rateOverage` without `capMinor`) is ≥ the
+* cap. No cap → false. Same validation as `rateOverage`.
+*/
+function overageCapReached(input) {
+	const { minor, cap } = pricedOverage(input);
+	return cap !== null && input.overageMicro > 0n && minor >= cap;
+}
+/**
+* Totals and stored lines of an invoice (or meter charge) with overage lines: the manual invoice
+* rule (`manualInvoiceTotals`) with every line at quantity 1 — ONE rounding at invoice level
+* (tax-inclusive: the total is kept and split with `splitInclusiveTax`, the net spread over the
+* lines by largest remainder; exclusive: tax added on the sum). Stored lines are net and keep
+* their meter fields (`meter`, `units`, `priceAmountMinor`, `pricePerUnits`).
+*/
+function meterChargeTotals(lines, terms) {
+	for (const line of lines) nonNegativeInteger("amountMinor", line.amountMinor);
+	const totals = manualInvoiceTotals({
+		lines: lines.map((l) => ({
+			description: l.description,
+			quantity: 1,
+			unitAmountMinor: l.amountMinor
+		})),
+		taxRateBps: terms.taxRateBps,
+		taxInclusive: terms.taxInclusive
+	});
+	return {
+		subtotalMinor: totals.subtotalMinor,
+		taxMinor: totals.taxMinor,
+		totalMinor: totals.totalMinor,
+		lines: totals.lines.map((line, i) => {
+			const source = lines[i];
+			return {
+				...line,
+				...source.meter !== void 0 ? { meter: source.meter } : {},
+				...source.units !== void 0 ? { units: source.units } : {},
+				...source.priceAmountMinor !== void 0 ? { priceAmountMinor: source.priceAmountMinor } : {},
+				...source.pricePerUnits !== void 0 ? { pricePerUnits: source.pricePerUnits } : {}
+			};
+		})
+	};
+}
+//#endregion
 //#region ../contract/src/plan.ts
 const PLAN_SET_MODES = ["ensure", "strict"];
 const PlanSetModeSchema = z.enum(PLAN_SET_MODES);
@@ -909,7 +1717,69 @@ const DoctorCatalogSchema = z.object({
 	/** Satışa açık planların (`sellable`) bugün checkout'ta satılabilen aktif fiyatları. */
 	sellablePrices: z.number().int().nonnegative(),
 	/** Satışa açık planların satılamayan aktif fiyatları (satışa kapalı planların fiyatları sayılmaz). */
-	unsellablePrices: z.array(DoctorUnsellablePriceSchema)
+	unsellablePrices: z.array(DoctorUnsellablePriceSchema),
+	/**
+	* Live subscriptions whose locked amount (or tax inclusion) differs from the current price of
+	* their key (M36): they keep paying what they locked until explicitly moved. Absent from older steward.
+	*/
+	priceDriftSubscriptions: z.number().int().nonnegative().optional()
+});
+/** Billing core facts (M30). Absent from older steward. */
+const DoctorBillingSchema = z.object({ 
+/**
+* Live subscriptions that still carry a provider subscription reference (created by the removed
+* iyzico subscription path). Steward never invoices them and the provider may still charge them:
+* cancel each in the provider panel, then immediately in steward. Should be 0.
+*/
+legacyProviderSubscriptions: z.number().int().nonnegative() });
+/**
+* Event ingest and rollup facts (metering phase 2, M29; only for a product that defines meters).
+* Absent from older steward. Names and meter codes only: no metadata, no account refs.
+*/
+const DoctorEventsSchema = z.object({
+	/** Non-archived meters. */
+	meters: z.number().int().nonnegative(),
+	/** Meters whose already received events are still being counted in (`backfilling`). */
+	backfillingMeters: z.array(z.string()),
+	/** This product's events not rolled up yet (counted up to just above the back-pressure limit). */
+	backlogRows: z.number().int().nonnegative(),
+	/** Age of this product's oldest event not rolled up yet, seconds (0 when none). */
+	rollupLagSeconds: z.number().nonnegative(),
+	/** The deployment's backlog is over the limits: `POST /v1/events/ingest` answers `503 events_backlog`. */
+	backlogged: z.boolean(),
+	/** Events of the last 7 days examined for the fields below (newest first, bounded). */
+	sampledEvents: z.number().int().nonnegative(),
+	/** Event names of the sample that no meter selects (top 5 by count). Normal: events are generic (M2). */
+	unmatchedEventNames: z.array(z.object({
+		name: z.string(),
+		events: z.number().int().nonnegative()
+	})),
+	/** Per meter, sampled events it selects that carry no usable value (M4 `invalid_value`). */
+	invalidValues: z.array(z.object({
+		meter: z.string(),
+		events: z.number().int().nonnegative()
+	})),
+	/** Non-archived meters with no usage in their current periods and no selected event in the sample. */
+	metersWithoutEvents: z.array(z.string())
+});
+/** Rollup lag above which the doctor warns (the `rollup lag > 60 s` alert, M29). */
+const DOCTOR_ROLLUP_LAG_WARN_SECONDS = 60;
+/**
+* Overage facts (metering MF5, M20/M21): present when the catalog has a metered price or the
+* product has meter charges. Absent from older steward.
+*/
+const DoctorOverageSchema = z.object({
+	/** `settings.metering.chargeMode`: `off` | `dry_run` | `live` (open set for newer steward). */
+	chargeMode: z.string(),
+	/** Active metered prices of the catalog. */
+	meteredPrices: z.number().int().nonnegative(),
+	/**
+	* Live subscriptions without a locked rate for a metered price of their plan: a metered price
+	* added after a subscription started is not attached to it (M20), so its overage is not billed.
+	*/
+	unratedSubscriptions: z.number().int().nonnegative(),
+	/** Charges below the minimum invoice amount waiting for their subscription's next invoice. */
+	carriedCharges: z.number().int().nonnegative()
 });
 const DOCTOR_PROVIDER_ENVIRONMENTS = [
 	"sandbox",
@@ -934,7 +1804,7 @@ const DoctorProviderSchema = z.object({
 	lastError: z.object({
 		/** Sağlayıcı hata kodu, ör. `iyzico:timeout`, `iyzico:1001`. */
 		code: z.string(),
-		/** `ensure_price` | `create_checkout` | `retrieve_checkout` | `retrieve_subscription` | `cancel_subscription` | `retry_payment`. */
+		/** Provider operation, e.g. `create_payment_checkout`, `retrieve_payment_checkout`, `retrieve_payment` (open set). */
 		operation: z.string(),
 		at: DateTimeSchema
 	}).nullable()
@@ -1001,6 +1871,12 @@ const DoctorReportSchema = z.object({
 dryRun: z.boolean() }),
 	/** Absent in reports of steward versions without billing emails. */
 	emails: DoctorEmailsSchema.optional(),
+	/** Absent in reports of steward versions before the billing core. */
+	billing: DoctorBillingSchema.optional(),
+	/** Event ingest and rollup (metering); absent for a product without meters and from older steward. */
+	events: DoctorEventsSchema.optional(),
+	/** Metering MF5; absent without metered prices and from older steward. */
+	overage: DoctorOverageSchema.optional(),
 	warnings: z.array(DoctorWarningSchema)
 });
 /** Email readiness from settings and the deployment's transport (pure). */
@@ -1073,14 +1949,15 @@ function buildDoctorReport(facts) {
 	};
 	const { catalog, provider, settings, dunning } = facts;
 	if (!catalog.synced) warn("error", "catalog_not_synced", "katalog senkronlanmamış: `PUT /v1/admin/catalog` (steward catalog push)");
-	const byReason = (reason) => catalog.unsellablePrices.filter((p) => p.reason === reason);
-	const unsynced = byReason("provider_price_missing");
-	if (unsynced.length > 0) warn("error", "price_not_synced_with_provider", `${unsynced.length} fiyatın sağlayıcıda karşılığı yok (checkout plan_not_sellable döner): katalog senkronunu yeniden koşun`);
-	const otherUnsellable = catalog.unsellablePrices.filter((p) => p.reason !== "provider_price_missing" && p.reason !== "provider_not_configured");
+	const otherUnsellable = catalog.unsellablePrices.filter((p) => p.reason !== "provider_not_configured");
 	if (otherUnsellable.length > 0) {
 		const reasons = [...new Set(otherUnsellable.map((p) => p.reason))].join(", ");
 		warn("warning", "price_unsellable", `${otherUnsellable.length} fiyat satılamaz (${reasons})`);
 	}
+	const drift = catalog.priceDriftSubscriptions ?? 0;
+	if (drift > 0) warn("info", "price_drift", `${drift} live subscription(s) keep a locked amount that differs from the current price; moving them to the current price is an explicit operation`);
+	const legacy = facts.billing?.legacyProviderSubscriptions ?? 0;
+	if (legacy > 0) warn("error", "legacy_provider_subscription", `${legacy} live subscription(s) still have a provider subscription: steward never invoices them and the provider may still charge them; cancel each in the provider panel, then immediately in steward`);
 	if (!provider.configured) warn("error", "provider_not_configured", `ödeme sağlayıcısı ${provider.id} bu deployment'ta yapılandırılmamış`);
 	else if (provider.healthy === false) warn("warning", "provider_unhealthy", `ödeme sağlayıcısı ${provider.id} art arda erişilemedi (yanıtı veren pod'un gözlemi)`);
 	const returnOrigins = returnOriginsOf(settings);
@@ -1109,6 +1986,20 @@ function buildDoctorReport(facts) {
 		if (settings.emails?.billingPath === void 0) warn("info", "email_billing_link_missing", "`settings.emails.billingPath` is not set: email buttons open `appUrl`");
 	}
 	if (dunning.dryRun) warn("info", "dunning_dry_run", "dunning dry-run: adımlar yalnızca iz yazar, askı ve sonlandırma uygulanmaz");
+	const ev = facts.events;
+	if (ev) {
+		if (ev.backlogged) warn("warning", "events_backlog", "the event backlog is over the limits: ingest answers 503 events_backlog (the SDK keeps batches queued)");
+		if (ev.rollupLagSeconds > 60) warn("warning", "meter_rollup_lag", `the oldest event waiting for the rollup is ${ev.rollupLagSeconds} s old (${ev.backlogRows} waiting): meters lag behind`);
+		for (const { meter, events } of ev.invalidValues) warn("warning", "events_invalid_value", `meter ${meter}: ${events} recent event(s) carry no usable value (sum/max need a finite, non-negative number; unique needs the key) and add nothing`);
+		if (ev.metersWithoutEvents.length > 0) warn("info", "meter_without_events", `no recent event counts in meter(s) ${ev.metersWithoutEvents.join(", ")}: check the event name and filter`);
+		if (ev.unmatchedEventNames.length > 0) warn("info", "events_unmatched", `recent events no meter selects: ${ev.unmatchedEventNames.map((u) => `${u.name} (${u.events})`).join(", ")} — normal when no meter is meant for them`);
+	}
+	const overage = facts.overage;
+	if (overage && overage.meteredPrices > 0) {
+		if (overage.chargeMode === "off") warn("warning", "overage_charge_mode_off", "metering.chargeMode is off: the catalog has metered prices but overage is neither priced nor invoiced");
+		else if (overage.chargeMode === "dry_run") warn("info", "overage_dry_run", "metering.chargeMode is dry_run: overage is priced into meter charges (GET /v1/accounts/:ref/meter-charges) but not invoiced; switch to live after one full cycle");
+	}
+	if (overage && overage.unratedSubscriptions > 0) warn("info", "overage_unrated_subscriptions", `${overage.unratedSubscriptions} live subscription(s) have no locked rate for a metered price of their plan (added after they started, M20): their overage is not billed until they move to the current terms`);
 	return {
 		ok: !warnings.some((w) => w.severity === "error"),
 		checkedAt: facts.checkedAt.toISOString(),
@@ -1123,8 +2014,11 @@ function buildDoctorReport(facts) {
 		endpoints,
 		dunning,
 		...emails ? { emails } : {},
+		...facts.billing ? { billing: facts.billing } : {},
+		...facts.events ? { events: facts.events } : {},
+		...overage ? { overage } : {},
 		warnings
 	};
 }
 //#endregion
-export { InvoiceVoidResponseSchema as $, PriceSchema as $t, WebhookSecretSchema as A, checkoutRedirectUrl as At, errorCodeSpec as B, TtlMinutesSchema as Bt, WEBHOOK_SECRET_PREFIX as C, CheckoutSessionCreateInputSchema as Ct, WebhookEndpointSchema as D, ConsentSchema as Dt, WebhookEndpointRotateInputSchema as E, CheckoutStatusSchema as Et, PlanSetModeSchema as F, ProductSettingsPatchSchema as Ft, CheckoutSessionResponseSchema as G, AccountsRefreshResultSchema as Gt, AccountDetailSchema as H, applySettingsPatch as Ht, PlanSetResponseSchema as I, ProductSettingsSchema as It, HEADER_API_VERSION as J, CatalogSyncResultSchema as Jt, GrantCreateResponseSchema as K, CatalogSchema as Kt, PlanSetWarningSchema as L, ReturnOriginSchema as Lt, webhookEndpointUrlProblem as M, BrandingSchema as Mt, PLAN_SET_MODES as N, DEFAULT_CHECKOUT_TTL_MINUTES as Nt, WebhookEndpointStatusSchema as O, MAX_CHECKOUT_CONSENT_DOCS as Ot, PlanSetInputSchema as P, DEFAULT_PORTAL_TTL_MINUTES as Pt, InvoiceIssueResponseSchema as Q, PriceDefSchema as Qt, ResyncResultSchema as R, SETTINGS_LOCALES as Rt, WEBHOOK_ENDPOINT_STATUSES as S, CheckoutPrefillSchema as St, WebhookEndpointListSchema as T, CheckoutSessionSchema as Tt, AccountUpsertResponseSchema as U, isReturnUrlAllowed as Ut, isKnownErrorCode as V, WebUrlSchema as Vt, CancelSubscriptionResponseSchema as W, returnOriginsOf as Wt, HEADER_REQUEST_ID as X, FeatureTypeSchema as Xt, HEADER_IDEMPOTENCY_KEY as Y, FeatureDefSchema as Yt, HEADER_SDK as Z, PlanDefSchema as Zt, emailReadinessOf as _, PORTAL_SESSION_ERRORS as _t, DOCTOR_SEVERITIES as a, InvoiceVoidInputSchema as at, DEFAULT_ENDPOINT_EVENT_TYPES as b, CHECKOUT_ERRORS as bt, DoctorEndpointSchema as c, ManualInvoiceLineInputSchema as ct, DoctorReportSchema as d, CancelSubscriptionInputSchema as dt, ManualInvoiceResponseSchema as et, DoctorSettingsSchema as f, GrantCreateInputSchema as ft, buildDoctorReport as g, SubscriptionSchema as gt, DoctorWarningSchema as h, StatsSchema as ht, DOCTOR_REQUIRED_LEGAL_LINKS as i, InvoiceStatusSchema as it, generateWebhookSecret as j, BrandingPatchSchema as jt, WebhookLastDeliverySchema as k, ProviderPayloadSchema as kt, DoctorHostedSchema as l, manualInvoiceTotals as lt, DoctorUnsellablePriceSchema as m, PaymentSchema as mt, DOCTOR_PROVIDER_ENVIRONMENTS as n, InvoiceLineSchema as nt, DoctorCatalogSchema as o, MANUAL_INVOICE_MAX_AMOUNT_MINOR as ot, DoctorSeveritySchema as p, GrantSchema as pt, HEADER_ACTOR_REF as q, CatalogSyncInputSchema as qt, DOCTOR_REQUIRED_BRANDING as r, InvoiceSchema as rt, DoctorEmailsSchema as s, ManualInvoiceInputSchema as st, DOCTOR_PENDING_BACKLOG_MS as t, InvoiceIssueInputSchema as tt, DoctorProviderSchema as u, splitInclusiveTax as ut, endpointDiagnosisOf as v, PortalSessionCreateInputSchema as vt, WebhookEndpointCreateInputSchema as w, CheckoutSessionCreatedSchema as wt, EventTypeSchema as x, CheckoutConsentInputSchema as xt, hostedReadinessOf as y, PortalSessionSchema as yt, ERROR_CODES as z, SettingsLocaleSchema as zt };
+export { rolloverOf as $, MAX_CATALOG_BENEFITS as $n, CheckoutSessionCreatedSchema as $t, WebhookEndpointRotateInputSchema as A, MeteringSettingsPatchSchema as An, InvoiceWaiveInputSchema as At, PlanSetResponseSchema as B, applySettingsPatch as Bn, PaymentSchema as Bt, hostedReadinessOf as C, DEFAULT_PORTAL_TTL_MINUTES as Cn, InvoiceIssueInputSchema as Ct, WEBHOOK_SECRET_PREFIX as D, LateGraceMinutesSchema as Dn, InvoiceSchema as Dt, WEBHOOK_ENDPOINT_STATUSES as E, EventsSettingsSchema as En, InvoicePaymentSessionSchema as Et, generateWebhookSecret as F, ReturnOriginSchema as Fn, splitInclusiveTax as Ft, contributionOf as G, returnOriginsOf as Gn, PortalSessionCreateInputSchema as Gt, ResyncResultSchema as H, eventsSettingsOf as Hn, SubscriptionChangeInputSchema as Ht, webhookEndpointUrlProblem as I, SETTINGS_LOCALES as In, CancelSubscriptionInputSchema as It, meterCreditsOf as J, CatalogSchema as Jn, BankTransferRecordedSchema as Jt, matchesFilter as K, AccountsRefreshResultSchema as Kn, PortalSessionSchema as Kt, PLAN_SET_MODES as L, SettingsLocaleSchema as Ln, GrantCreateInputSchema as Lt, WebhookEndpointStatusSchema as M, PaymentDueDaysSchema as Mn, ManualInvoiceInputSchema as Mt, WebhookLastDeliverySchema as N, ProductSettingsPatchSchema as Nn, ManualInvoiceLineInputSchema as Nt, WebhookEndpointCreateInputSchema as O, METER_CHARGE_MODES as On, InvoiceStatusSchema as Ot, WebhookSecretSchema as P, ProductSettingsSchema as Pn, manualInvoiceTotals as Pt, rateOverage as Q, FeatureTypeSchema as Qn, CheckoutSessionCreateInputSchema as Qt, PlanSetInputSchema as R, TtlMinutesSchema as Rn, GrantSchema as Rt, endpointDiagnosisOf as S, DEFAULT_PAYMENT_DUE_DAYS as Sn, UncancelSubscriptionResponseSchema as St, EventTypeSchema as T, EventsSettingsPatchSchema as Tn, InvoicePaymentSessionCreateInputSchema as Tt, addUtcMonths as U, isReturnUrlAllowed as Un, SubscriptionSchema as Ut, PlanSetWarningSchema as V, billingSettingsOf as Vn, StatsSchema as Vt, consumptionOf as W, meteringSettingsOf as Wn, PORTAL_SESSION_ERRORS as Wt, overageOf as X, CatalogSyncResultSchema as Xn, CheckoutConsentInputSchema as Xt, overageCapReached as Y, CatalogSyncInputSchema as Yn, CHECKOUT_ERRORS as Yt, periodBoundsOf as Z, FeatureDefSchema as Zn, CheckoutPrefillSchema as Zt, DoctorSeveritySchema as _, DEFAULT_CHECKOUT_TTL_MINUTES as _n, InvoiceVoidResponseSchema as _t, DOCTOR_ROLLUP_LAG_WARN_SECONDS as a, PAYMENT_METHODS as an, PriceDefSchema as ar, AccountUpsertResponseSchema as at, buildDoctorReport as b, DEFAULT_METER_CHARGE_MODE as bn, MeResponseSchema as bt, DoctorCatalogSchema as c, checkoutRedirectUrl as cn, CheckoutSessionResponseSchema as ct, DoctorEventsSchema as d, BankTransferSettingsSchema as dn, HEADER_ACTOR_REF as dt, CheckoutSessionSchema as en, MAX_CATALOG_METERED_PRICES as er, standingOf as et, DoctorHostedSchema as f, BillingSettingsPatchSchema as fn, HEADER_API_VERSION as ft, DoctorSettingsSchema as g, DEFAULT_BANK_TRANSFER_PAYMENT_DAYS as gn, InvoiceIssueResponseSchema as gt, DoctorReportSchema as h, BrandingSchema as hn, HEADER_SDK as ht, DOCTOR_REQUIRED_LEGAL_LINKS as i, MAX_CHECKOUT_CONSENT_DOCS as in, PlanDefSchema as ir, AccountDetailSchema as it, WebhookEndpointSchema as j, MeteringSettingsSchema as jn, MANUAL_INVOICE_MAX_AMOUNT_MINOR as jt, WebhookEndpointListSchema as k, MeterChargeModeSchema as kn, InvoiceVoidInputSchema as kt, DoctorEmailsSchema as l, BankTransferPaymentDaysSchema as ln, CreditGrantResponseSchema as lt, DoctorProviderSchema as m, BrandingPatchSchema as mn, HEADER_REQUEST_ID as mt, DOCTOR_PROVIDER_ENVIRONMENTS as n, ConsentSchema as nn, MAX_PLAN_BENEFITS as nr, errorCodeSpec as nt, DOCTOR_SEVERITIES as o, PaymentMethodSchema as on, PriceSchema as or, CancelSubscriptionResponseSchema as ot, DoctorOverageSchema as p, BillingSettingsSchema as pn, HEADER_IDEMPOTENCY_KEY as pt, meterChargeTotals as q, CatalogPlanSchema as qn, BankTransferRecordInputSchema as qt, DOCTOR_REQUIRED_BRANDING as r, INDIVIDUAL_IDENTITY_PLACEHOLDER as rn, METERED_PRICE_TAX_MISMATCH as rr, isKnownErrorCode as rt, DoctorBillingSchema as s, ProviderPayloadSchema as sn, ChangeSubscriptionResponseSchema as st, DOCTOR_PENDING_BACKLOG_MS as t, CheckoutStatusSchema as tn, MAX_CATALOG_METERS as tr, ERROR_CODES as tt, DoctorEndpointSchema as u, BankTransferSettingsPatchSchema as un, GrantCreateResponseSchema as ut, DoctorUnsellablePriceSchema as v, DEFAULT_EVENT_RETENTION_DAYS as vn, InvoiceWaiveResponseSchema as vt, DEFAULT_ENDPOINT_EVENT_TYPES as w, EventRetentionDaysSchema as wn, InvoiceLineSchema as wt, emailReadinessOf as x, DEFAULT_MIN_INVOICE_MINOR as xn, STEWARD_CAPABILITIES as xt, DoctorWarningSchema as y, DEFAULT_LATE_GRACE_MINUTES as yn, ManualInvoiceResponseSchema as yt, PlanSetModeSchema as z, WebUrlSchema as zn, MAX_GRANT_BENEFITS as zt };